project_tree_panel.cpp

Go to the documentation of this file.

/*  $Id: project_tree_panel.cpp 25238 2012-02-14 16:11:43Z ucko $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Andrey Yazhuk
 *
 * File Description:
 *
 */

#include <ncbi_pch.hpp>

#include <gui/core/project_tree_panel.hpp>

#include <gui/core/commands.hpp>
#include <gui/core/app_explorer_service.hpp>
#include <gui/core/project_service.hpp>
#include <gui/core/project_task.hpp>
#include <gui/core/fname_validator_imp.hpp>

#include <gui/framework/workbench.hpp>
#include <gui/framework/view_manager_service.hpp>
#include <gui/framework/window_manager_service.hpp>
#include <gui/framework/app_task_service.hpp>
#include <gui/framework/menu_service.hpp>

#include <gui/widgets/wx/ui_command.hpp>
#include <gui/widgets/wx/message_box.hpp>
#include <gui/widgets/wx/wx_utils.hpp>

#include <gui/utils/extension_impl.hpp>


#include <wx/artprov.h>
#include <wx/sizer.h>
#include <wx/panel.h>
#include <wx/menu.h>
#include <wx/wupdlock.h>
#include <wx/frame.h>


BEGIN_NCBI_SCOPE
USING_SCOPE(objects);

///////////////////////////////////////////////////////////////////////////////
/// CExplorerItemData - tree item attachment pointing back to CExplorerItem.
class CExplorerItemData : public wxTreeItemData
{
public:
    CExplorerItemData(CExplorerItem& item)
        :   m_Item(&item)   {}
    CExplorerItemData(const CExplorerItem& item)
        :   m_Item(const_cast<CExplorerItem*>(&item))   {}
    CExplorerItemData(CExplorerItem* item)  :   m_Item(item)   {}

    CRef<CExplorerItem> m_Item;
};

///////////////////////////////////////////////////////////////////////////////
/// CProjectTreeViewDropTarget
CProjectTreeViewDropTarget::CProjectTreeViewDropTarget(CProjectTreePanel* panel)
:   wxDropTarget(new CAppExplorerDataObject()),
    m_Panel(panel),
    m_AcceptableData(false)
{
}


wxDragResult CProjectTreeViewDropTarget::OnEnter(wxCoord x, wxCoord y, wxDragResult def)
{
    m_AcceptableData = true;
    return OnDragOver(x, y, def);
}


wxDragResult CProjectTreeViewDropTarget::OnDragOver(wxCoord x, wxCoord y, wxDragResult def)
{
    if(m_AcceptableData)    {
        return m_Panel->OnDragOver(x, y, def);
    }
    return wxDragNone;
}


wxDragResult CProjectTreeViewDropTarget::OnData(wxCoord x, wxCoord y, wxDragResult def)
{
    GetData();
    CAppExplorerDataObject* data_obj = dynamic_cast<CAppExplorerDataObject*>(m_dataObject);
    m_Panel->OnDrop(x, y, def, *data_obj);
    return def;
}

BEGIN_EVENT_TABLE(CProjectTreeCtrl, wxTreeCtrl)
    EVT_LEFT_UP( CProjectTreeCtrl::OnLeftDown)
    EVT_KEY_UP(CProjectTreeCtrl::OnKeyUp)
    EVT_MOTION( CProjectTreeCtrl::OnMove )
END_EVENT_TABLE()
///////////////////////////////////////////////////////////////////////////////
/// CProjectTreeCtrl
wxTextCtrl *CProjectTreeCtrl::EditLabel(const wxTreeItemId& item, wxClassInfo* textCtrlClass)
{
    wxTextCtrl* t = wxTreeCtrl::EditLabel(item, textCtrlClass);
    
    // In windows, when an item in the tree is selected for editing, all characters
    // are selected by default. This is not true on the Mac, but the EditLabel function
    // does return the edit control so we can use that to select the text.  The 
    // documentation however says that EditLabel returns NULL.  Restrict it to
    // to MAC only since that is where it is needed and it is not validated on other platforms.
#ifdef NCBI_OS_DARWIN
    if (t!=NULL)
        t->SelectAll();
#endif

    return t;
}

void CProjectTreeCtrl::OnLeftDown(wxMouseEvent& event)
{
    CProjectTreePanel* tree_panel = dynamic_cast<CProjectTreePanel*>(GetParent());
    if( tree_panel ){
        wxTreeEvent tree_event;
        tree_panel->OnSelectionChanged( tree_event );
    }

    event.Skip();
}

void CProjectTreeCtrl::OnKeyUp(wxKeyEvent& event)
{
    // Keep track of cmd(osx)/ctrl(other os) key status since it changes whether
    // drag and drop is a copy or a move (cmd/ctrl down=> copy)
    CProjectTreePanel* tree_panel = dynamic_cast<CProjectTreePanel*>(GetParent());
    bool b = event.CmdDown(); 
    tree_panel->SetCopyMode(b);
    event.Skip();
}

void CProjectTreeCtrl::OnMove(wxMouseEvent& event)
{
#ifdef __WXOSX_COCOA__
    // Tree's built-in drag and drop does not have a 'isdragging' event so
    // we call the 'OnDragOver' on all mouse moves and it checks if a 
    // drag is actually in progress.
    CProjectTreePanel* tree_panel = dynamic_cast<CProjectTreePanel*>(GetParent());
    if( tree_panel ){       
        // The result is ignored (it is used by the other drag method - this method is only
        // for the osx/cocoa case.)
        wxDragResult ignore_me = wxDragMove;
        wxCoord x,y;
        event.GetPosition(&x,&y);
        tree_panel->OnDragOver(x, y, ignore_me);
    }
#endif

    event.Skip();
}

///////////////////////////////////////////////////////////////////////////////
/// CProjectTreePanel

BEGIN_EVENT_TABLE(CProjectTreePanel, wxPanel)
    EVT_CONTEXT_MENU(CProjectTreePanel::OnContextMenu)

    EVT_TREE_ITEM_COLLAPSED(wxID_ANY, CProjectTreePanel::OnItemExpandedCollapsed)
    EVT_TREE_ITEM_EXPANDED(wxID_ANY, CProjectTreePanel::OnItemExpandedCollapsed)
    EVT_TREE_ITEM_ACTIVATED(wxID_ANY, CProjectTreePanel::OnItemActivated)
    EVT_TREE_KEY_DOWN(wxID_ANY, CProjectTreePanel::OnTreeKeyDown)
    EVT_TREE_BEGIN_LABEL_EDIT(wxID_ANY, CProjectTreePanel::OnBeginLabelEdit)
    EVT_TREE_END_LABEL_EDIT(wxID_ANY, CProjectTreePanel::OnEndLabelEdit)

    EVT_TREE_SEL_CHANGED(wxID_ANY, CProjectTreePanel::OnSelectionChanged)

    EVT_TREE_BEGIN_DRAG(wxID_ANY, CProjectTreePanel::OnBeginDrag)
    EVT_TREE_END_DRAG(wxID_ANY, CProjectTreePanel::OnEndDrag)

    EVT_LEFT_UP( CProjectTreePanel::OnLeftDown)

    EVT_MENU(wxID_CUT, CProjectTreePanel::OnCut)
END_EVENT_TABLE()


CProjectTreePanel::CProjectTreePanel()
:   m_DataObject(NULL),
    m_Workbench(NULL),
    m_ExplorerService(NULL),
    m_Tree(NULL),
    m_CopyMode(false)
{
    Init();
}


CProjectTreePanel::~CProjectTreePanel()
{
    delete m_DataObject;
    m_DataObject = NULL;
}


void CProjectTreePanel::Create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size)
{
    wxPanel::Create(parent, id, pos, size, wxBORDER_NONE);
    CreateControls();
}


void CProjectTreePanel::Init()
{
    m_ExplorerService = NULL;
}


void CProjectTreePanel::CreateControls()
{
    wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
    SetSizer(sizer);

    long style = wxTR_HAS_BUTTONS | wxTR_MULTIPLE | wxTR_EDIT_LABELS 
        | wxTR_HIDE_ROOT | wxBORDER_NONE
    ;
#ifdef __WXGTK__
    style |= wxTR_NO_LINES;
#else
    style |= wxTR_LINES_AT_ROOT;
#endif
    // create Tree Control
    m_Tree = new CProjectTreeCtrl(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style);
    sizer->Add(m_Tree, 1, wxEXPAND);

    m_Tree->SetDropTarget(new CProjectTreeViewDropTarget(this));
}


void CProjectTreePanel::SetWorkbench(IWorkbench* workbench)
{
    m_Workbench = workbench;
}


void CProjectTreePanel::SetService(CAppExplorerService* service)
{
    m_ExplorerService = service;
    if(m_ExplorerService) {
        m_Tree->SetImageList(&m_ExplorerService->GetIconsImageList());
    } else {
        m_Tree->SetImageList(NULL);
    }
    RefreshItems();
}


WX_DEFINE_MENU(kContextMenu)
    WX_MENU_SEPARATOR_L("Top Actions")
    WX_MENU_SEPARATOR_L("Actions")
    WX_MENU_SEPARATOR_L("Edit")
    WX_MENU_SEPARATOR_L("Properties")
WX_END_MENU()


void CProjectTreePanel::OnContextMenu(wxContextMenuEvent& event)
{
    SetFocus();

    CUICommandRegistry& cmd_reg = m_Workbench->GetUICommandRegistry();

    TItemRefVector sel_items;
    GetSelectedItems(sel_items);

    // create menu backbone
    wxMenu* menu = cmd_reg.CreateMenu(kContextMenu);

    // get contributed menus
    vector< CIRef<IExplorerItemCmdContributor> > contributors;
    static string id("project_tree_view::context_menu::item_cmd_contributor");
    GetExtensionAsInterface(id, contributors);

    // Merge contributed menus into the main Menu
    for( size_t i = 0; i < contributors.size(); i++ ) {
        IExplorerItemCmdContributor& obj = *contributors[i];
        IExplorerItemCmdContributor::TContribution
            contrib = obj.GetMenu(sel_items, *m_ExplorerService);
        /// update menu
        wxMenu* obj_menu = contrib.first;
        if(obj_menu)    {
            Merge(*menu, *obj_menu);
            delete obj_menu;

            /// register provided handler
            wxEvtHandler* handler = contrib.second;
            if(handler)  {
                m_ContributedHandlers.push_back(handler);
                PushEventHandler(handler);
            }
        } else {
            _ASSERT(contrib.second == NULL);
            delete contrib.second;
        }
    }

    CleanupSeparators(*menu);   // Remove empty groups

    PopupMenu(menu);

    /// destroy the Menu
    delete menu;

    /// disconnect and destroy contributed handlers
    for(  size_t i = 0;  i < m_ContributedHandlers.size();  i++ )   {
        wxEvtHandler* handler = PopEventHandler();
        _ASSERT(handler == m_ContributedHandlers[i]);
        delete handler;
    }
    m_ContributedHandlers.clear();
}


void CProjectTreePanel::RefreshItems()
{
    //CStopWatch sw; sw.Start();

    wxColour cl_text = m_Tree->GetForegroundColour();
    wxColour cl_back = m_Tree->GetBackgroundColour();
    m_DisabledColor = GetAverage(cl_text, cl_back, 0.5);

    wxWindowUpdateLocker locker(m_Tree);

    // rebuild the tree
    m_Tree->DeleteAllItems();

    if(m_ExplorerService)    {
        CRef<CExplorerItem> root = m_ExplorerService->GetRootItem();
        if(root)    {
            wxTreeItemId item_id =
                m_Tree->AddRoot(wxT(""), -1, -1, new CExplorerItemData(*root));

            x_AddChildItems(item_id, *root);
        }
    }

    //LOG_POST(Info << "CProjectTreePanel::RefreshItems() " << int(1000 * sw.Elapsed()) << " ms");
}


void CProjectTreePanel::x_AddChildItems(wxTreeItemId item_id, const CExplorerItem& item)
{
    const CExplorerItem::TItemRefVector& child_items = item.GetChildItems();

    for(  size_t i = 0;  i < child_items.size();  i++ ) {
        const CExplorerItem& ch_item = *child_items[i];

        // create new tree item
        wxString s = ch_item.GetLabel();
        int index = ch_item.GetIconIndex(wxTreeItemIcon_Normal);
        CExplorerItemData* data = new CExplorerItemData(ch_item);

        wxTreeItemId ch_id = m_Tree->AppendItem(item_id, s, index, -1, data);

        // set disabled look if needed
        if(ch_item.IsDisabled())    {
            m_Tree->SetItemTextColour(ch_id, m_DisabledColor);
        }

        // set expanded icon
        index = ch_item.GetIconIndex(wxTreeItemIcon_Expanded);
        m_Tree->SetItemImage(ch_id, index, wxTreeItemIcon_Expanded);

        // create subitems recursively
        x_AddChildItems(ch_id, ch_item);

        if(ch_item.IsExpanded())    {
            m_Tree->Expand(ch_id);
        } else {
            m_Tree->Collapse(ch_id);
        }
    }
}


CExplorerItem* CProjectTreePanel::x_GetExplorerItem(const wxTreeItemId& id)
{
    wxTreeItemData* data = m_Tree->GetItemData(id);
    CExplorerItemData* ex_data = dynamic_cast<CExplorerItemData*>(data);

    _ASSERT(ex_data);

    return ex_data->m_Item.GetPointer();
}


// returns selection as a vector of pointers to CExplorerItem
void CProjectTreePanel::GetSelectedItems(TItemRefVector& items)
{
    wxArrayTreeItemIds sel_ids;
    m_Tree->GetSelections(sel_ids);

    x_GetItemsFromIds(sel_ids, items);
}


void CProjectTreePanel::x_GetItemsFromIds(const wxArrayTreeItemIds& ids,
                                         TItemRefVector& items)
{
    for(  size_t i = 0;  i < ids.GetCount();  i++ ) {
        wxTreeItemId id = ids[i];
        CExplorerItem* item = x_GetExplorerItem(id);
        items.push_back(TItemRef(item));
    }
}


CExplorerItem* CProjectTreePanel::x_GetSingleSelectedItem()
{
    wxArrayTreeItemIds sel_ids;
    m_Tree->GetSelections(sel_ids);

    if(sel_ids.size() == 1) {
        CExplorerItem* item = x_GetExplorerItem(sel_ids[0]);
        return item;
    }
    return NULL;
}


bool CProjectTreePanel::IsWorkspaceSelected()
{
    TItemRefVector sel_items;
    GetSelectedItems(sel_items);

    return m_ExplorerService->ContainsAllTypes(sel_items, CAppExplorerService::eWorkspace);
}


void CProjectTreePanel::GetSelectedProjectIds(TProjectIdVector& ids)
{
    typedef CAppExplorerService::TProjectTreeItem TProjectTreeItem;

    TItemRefVector sel_items;
    GetSelectedItems(sel_items);

    CProjectService* prj_srv = m_Workbench->GetServiceByType<CProjectService>();
    CRef<CWorkspaceConstPrx> workspace = prj_srv->GetWorkspaceConst();

    NON_CONST_ITERATE(TItemRefVector, it, sel_items)  {
        CExplorerItem& item = **it;
        TProjectTreeItem* project_item = dynamic_cast<TProjectTreeItem*>(&item);
        if(project_item)    {
            TProjectId id = project_item->GetData();
            ids.push_back(id);
        }
    }
}


void CProjectTreePanel::OnItemExpandedCollapsed(wxTreeEvent& event)
{
    wxTreeItemId id = event.GetItem();
    bool open = m_Tree->IsExpanded(id);
    CExplorerItem* item = x_GetExplorerItem(id);
    item->Expand(open);

    m_ExplorerService->OnItemExpandedCollapsed(*item);
}


void CProjectTreePanel::OnItemActivated(wxTreeEvent& event)
{
    wxTreeItemId id = event.GetItem();
    if(id.IsOk())   {
        CExplorerItem* item = x_GetExplorerItem(id);
        if(item)    {
            m_ExplorerService->OnItemActivated(*item);
        }
    }
}


void CProjectTreePanel::OnSelectionChanged(wxTreeEvent& event)
{
    CEvent evt(CEvent::eEvent_Message, CViewEvent::eWidgetSelectionChanged);
    Send(&evt, ePool_Parent);
}

void CProjectTreePanel::OnLeftDown(wxMouseEvent& event)
{
    event.Skip();
}


// this functions inititates and performs the whole D&D session
void CProjectTreePanel::OnBeginDrag(wxTreeEvent& event)
{
    // get id selection and preserve it, so that we can restore it later
    wxArrayTreeItemIds sel_ids;
    m_Tree->GetSelections(sel_ids);

    // get item selection
    TItemRefVector sel_items;
    x_GetItemsFromIds(sel_ids, sel_items);

    bool en = m_ExplorerService->CanCutOrCopyToClipboard(sel_items);

    if(en)   {
        // reset D&D state
        m_DropItemId = wxTreeItemId();
        m_DropTimerActive = false;

        // create a wxDataObject for the selected items
        m_DataObject =  m_ExplorerService->CreateDataObject(sel_items, true, false);

        // For osx cocoa, we use wxTreeCtrl's built-in D&D.  For others we continue to
        // use the original (general) drag and drop and approach.  They seem
        // to be equivalent in behavior in this case afik)
#ifdef __WXOSX_COCOA__
        // Tree D&D does not take over the event loop...
        event.Allow();
#else
        wxDropSource source(*m_DataObject, this);

        // the whole D&D session happens in this call
        wxDragResult res = source.DoDragDrop(wxDragCopy | wxDragMove);

        // at this point session has ended and Drag Traget already has done all necessary work

        if(res == wxDragError)  {
            NcbiErrorBox("Unexpected error while performing D&D");
            ERR_POST("CProjectTreePanel::OnBeginDrag() - Unexpected error while performing D&D");
        }

        // reset D&D state
        m_DropItemId = wxTreeItemId();
        m_DropItemTimer.Stop();
        m_DropTimerActive = false;
        delete m_DataObject;
        m_DataObject = NULL;
#endif
    }
}

// end drag for the trees built-in drag and drop (used for osx cocoa)
// never called by other os's since they don't call event.Allow() when
// D&D starts.)
void CProjectTreePanel::OnEndDrag(wxTreeEvent& event)
{
    int flags = 0;
    wxTreeItemId id = m_Tree->HitTest( event.GetPoint(), flags);

    if( id.IsOk() ){
        CExplorerItem* item = x_GetExplorerItem(id);

        if( m_ExplorerService->CanDropTo(*item) ){
            m_ExplorerService->Drop( *item, *m_DataObject->GetDataRef(), !m_CopyMode);
        }
    }

    // reset D&D state
    m_DropItemId = wxTreeItemId();
    m_DropItemTimer.Stop();
    m_DropTimerActive = false;
    delete m_DataObject;
    m_DataObject = NULL;
}

void CProjectTreePanel::x_SetSelections(wxArrayTreeItemIds& ids)
{
    wxArrayTreeItemIds sel_ids;
    m_Tree->GetSelections(sel_ids);

    //reset current selection
    for(  size_t i = 0;  i < sel_ids.size();  i++ ) {
        wxTreeItemId id = sel_ids[i];
        m_Tree->SelectItem(id, false);
    }
    // set new selection
    for(  size_t i = 0;  i < ids.size();  i++ ) {
        wxTreeItemId id = ids[i];
        m_Tree->SelectItem(id, true);
    }
}


wxDragResult CProjectTreePanel::OnDragOver(wxCoord x, wxCoord y, wxDragResult def)
{
    // If null, a drag is not in progress.
    if (m_DataObject == NULL)
        return wxDragNone;

    static const double kExpandDelay = 0.5;
    // get the item under the mouse pointer
    int flags = 0;
    wxTreeItemId id = m_Tree->HitTest(wxPoint(x, y), flags);

    if(id != m_DropItemId)  {
        // current item have changed - need to update highlight and "expand" timer

        // stop the timer
        m_DropItemTimer.Stop();
        m_DropTimerActive = false;

        // change highlight
        if(m_DropItemId.IsOk()) {
            m_Tree->SetItemDropHighlight(m_DropItemId, false);
        }

        m_DropItemId = id;

        if(m_DropItemId.IsOk()) {
            m_Tree->SetItemDropHighlight(m_DropItemId, true);

            // launch "expand" timer
            if(m_Tree->ItemHasChildren(m_DropItemId)  &&  ! m_Tree->IsExpanded(m_DropItemId)) {
                // start the timer
                m_DropItemTimer.Restart();
                m_DropTimerActive = true;
            }
        }
    } else if(m_DropTimerActive)    {
        // current item has not changed and timer is active
        if(m_DropItemTimer.Elapsed() >= kExpandDelay) {
            m_Tree->Expand(m_DropItemId);

            m_DropItemTimer.Stop();
            m_DropTimerActive = false;
        }
    }

    if(id.IsOk())    {
        CExplorerItem* item = x_GetExplorerItem(id);

        if(m_ExplorerService->CanDropTo(*item))    {
            return def;
        } else {
        }
    } else {
    }
    return wxDragNone;
}

// drag end for standard (general) drag and drop used on non-cocoa platforms
wxDragResult CProjectTreePanel::OnDrop(
    wxCoord x, wxCoord y, wxDragResult def, CAppExplorerDataObject& data
){
    if( def == wxDragCopy || def == wxDragMove ){
        int flags = 0;
        wxTreeItemId id = m_Tree->HitTest( wxPoint(x, y), flags );

        if( id.IsOk() ){
            CExplorerItem* item = x_GetExplorerItem(id);

            if( m_ExplorerService->CanDropTo(*item) ){
                bool move = (def == wxDragMove);

                m_ExplorerService->Drop( *item, *data.GetDataRef(), move );

                return def;
            }
        }
    }

    return wxDragNone;
}

void CProjectTreePanel::OnTreeKeyDown(wxTreeEvent& event)
{
    const wxKeyEvent& keyEvent = event.GetKeyEvent();
    m_CopyMode = keyEvent.CmdDown(); 

    if (WXK_F2 != keyEvent.GetKeyCode() || keyEvent.GetModifiers() != wxMOD_NONE) {
        event.Skip();
        return;
    }

    wxArrayTreeItemIds items;
    if (m_Tree->GetSelections(items) != 1)
        return;

    wxTreeItemId item = items[0];
    if (!item.IsOk())
        return;

    (void)m_Tree->EditLabel(item);
}

void CProjectTreePanel::OnBeginLabelEdit(wxTreeEvent& event)
{
    wxTreeItemId item = event.GetItem();
    CExplorerItem* eitem = x_GetExplorerItem(item);
    CAppExplorerService::EItemType itemType = m_ExplorerService->GetItemType(*eitem);

    CProjectService* prj_srv = m_Workbench->GetServiceByType<CProjectService>();
    if (itemType == CAppExplorerService::eWorkspace) {
        CRef<CWorkspaceConstPrx> ws = prj_srv->GetWorkspaceConst();
        m_Tree->SetItemText(item, ToWxString(ws->GetName()));
    }
    else if (itemType == CAppExplorerService::eProject) {
        CAppExplorerService::TProjectTreeItem* prj_item = 
            dynamic_cast<CAppExplorerService::TProjectTreeItem*>(eitem);
        _ASSERT(prj_item);
        CAppExplorerService::TProjectId id = prj_item->GetData();
        CRef<CWorkspaceConstPrx> ws = prj_srv->GetWorkspaceConst();
        CRef<CProjectPrx> project = ws->FindProjectById(id);

        if (!project->IsLoaded()) {
            event.Veto();
        }
        else {
            m_Tree->SetItemText(item, ToWxString(project->GetName()));
        }
    }
    else if (itemType == CAppExplorerService::eProjectItem);
    else
        event.Veto();
}

void CProjectTreePanel::OnEndLabelEdit(wxTreeEvent& event)
{
    wxTreeItemId item = event.GetItem();
    wxString label = event.GetLabel();
    CExplorerItem* eitem = x_GetExplorerItem(item);
    CAppExplorerService::EItemType itemType = m_ExplorerService->GetItemType(*eitem);

    CProjectService* prj_srv = m_Workbench->GetServiceByType<CProjectService>();
    if (itemType == CAppExplorerService::eWorkspace) {
        CRef<CWorkspacePrx> ws = prj_srv->GetWorkspace();
        if (event.IsEditCancelled())
            label = ToWxString(ws->GetName());
        ws->SetName(ToStdString(label));
        CRef<CWorkspaceFolderPrx> ws_folder = ws->GetRootFolder();
        ws_folder->SetName(ws->GetName());
    }
    else if (itemType == CAppExplorerService::eProject) {
        CAppExplorerService::TProjectTreeItem* prj_item = 
            dynamic_cast<CAppExplorerService::TProjectTreeItem*>(eitem);
        _ASSERT(prj_item);
        CAppExplorerService::TProjectId id = prj_item->GetData();
        CRef<CWorkspaceConstPrx> ws = prj_srv->GetWorkspaceConst();
        CRef<CProjectPrx> project = ws->FindProjectById(id);

        if (!project->IsLoaded()) {
            event.Veto();
        }
        else {
            if (event.IsEditCancelled())
                label = ToWxString(project->GetName());
            project->SetName(ToStdString(label));
        }
    }
    else if (itemType == CAppExplorerService::eProjectItem) {
        if (event.IsEditCancelled())
            return;

        // get the Project and the Item proxies
        CAppExplorerService::TProjectItemTreeItem* tree_item = 
            dynamic_cast<CAppExplorerService::TProjectItemTreeItem*>(eitem);
        _ASSERT(tree_item);
        TProjectId prj_id = m_ExplorerService->GetProjectIdByChild(*eitem);
        CRef<CWorkspaceConstPrx> ws = prj_srv->GetWorkspaceConst();
        CRef<CProjectPrx> project = ws->FindProjectById(prj_id);
        CAppExplorerService::TPrjItemId item_id = tree_item->GetData();
        CRef<CProjectItemPrx> pr_item = project->FindProjectItemById(item_id);
        string oldName = pr_item->GetName();

        // get the parent item and check whether it is a Folder
        CExplorerItem* parent_item = eitem->GetParent();
        CAppExplorerService::TProjectFolderTreeItem* folder_parent_item =
            dynamic_cast<CAppExplorerService::TProjectFolderTreeItem*>(parent_item);
        _ASSERT(folder_parent_item);

        CProjectFolderPrx::TId parent_id = folder_parent_item->GetData();
        CRef<CProjectFolderPrx> pr_parent_folder = project->FindProjectFolderById(parent_id);

        CPrjItemNameValidator validator(*pr_parent_folder, oldName);
        string err;
        if (!validator.IsValid(ToStdString(label), err)) {
            NcbiErrorBox(err);
            label = ToWxString(oldName);
            event.Veto();
        }
        else
            pr_item->SetName(ToStdString(label));
        return;
    }

    event.Veto();
}

void CProjectTreePanel::OnCut( wxCommandEvent& event )
{
    event.Skip();
}


END_NCBI_SCOPE