src/gui/widgets/wx/window_manager.cpp

Go to the documentation of this file.

/*  $Id: window_manager.cpp 20439 2009-11-24 23:53:23Z dicuccio $
 * ===========================================================================
 *
 *                            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/widgets/wx/window_manager.hpp>

#include <gui/widgets/wx/dock_manager.hpp>
#include <gui/widgets/wx/dock_container.hpp>
#include <gui/widgets/wx/dock_notebook.hpp>
#include <gui/widgets/wx/dock_panel.hpp>
#include <gui/widgets/wx/min_panel_container.hpp>

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

#include <gui/utils/menu_item.hpp>

#include <algorithm>

#include <wx/sizer.h>
#include <wx/menu.h>
#include <wx/toolbar.h>


BEGIN_NCBI_SCOPE

///////////////////////////////////////////////////////////////////////////////
/// IWMClient::CFingerprint
IWMClient::CFingerprint::CFingerprint()
:   m_Persistent(false)
{
}


IWMClient::CFingerprint::CFingerprint(const string& id, bool persistent)
:   m_Id(id),
    m_Persistent(persistent)
{
}


IWMClient::CFingerprint::CFingerprint(const CFingerprint& orig)
:   m_Id(orig.m_Id),
    m_Persistent(orig.m_Persistent)
{
}


bool IWMClient::CFingerprint::operator==(const CFingerprint& orig) const
{
    return m_Id == orig.m_Id;
}


bool IWMClient::CFingerprint::IsEmpty() const
{
    return m_Id.empty();
}


string IWMClient::CFingerprint::AsPersistentString() const
{
    return m_Persistent ? m_Id : kEmptyStr;
}


void IWMClient::CFingerprint::FromPersistentString(const string& s)
{
    m_Id = s;
    m_Persistent = ! s.empty();
}


///////////////////////////////////////////////////////////////////////////////
/// CWindowManagerEvent

CWindowManagerEvent::CWindowManagerEvent(EEventType type, IWMClient* client)
:   CEvent(type),
    m_Client(client),
    m_Cmd(eCmdInvalid)
{
}

CWindowManagerEvent::CWindowManagerEvent(IWMClient* client, TCmdID cmd)
:   CEvent(ePostCommand),
    m_Client(client),
    m_Cmd(cmd)
{
}


CWindowManagerEvent::CWindowManagerEvent(EEventType type, const vector<IWMClient*>& clients)
:   CEvent(type),
    m_Client(NULL),
    m_Clients(clients),
    m_Cmd(eCmdInvalid)
{
    _ASSERT(type == eCloseClientsRequest);
}


IWMClient* CWindowManagerEvent::GetClient()
{
    return m_Client;
}


void CWindowManagerEvent::GetClients(vector<IWMClient*>& clients)
{
    clients = m_Clients;
}


///////////////////////////////////////////////////////////////////////////////
/// CWindowManager

/// wxEvtHandler table
BEGIN_EVENT_TABLE(CWindowManager, wxPanel)
    EVT_MENU_RANGE(eCmdWindowXXXX, eCmdWindowLast, CWindowManager::OnActivateWindow)
    EVT_MENU(eCmdShowWindowsDlg, CWindowManager::OnShowWindowsDlg)
    EVT_MENU_RANGE(eCmdCloseDockPanel, eCmdWindowRestore,
                   CWindowManager::OnWindowCommand)
    EVT_UPDATE_UI_RANGE(eCmdCloseDockPanel, eCmdWindowRestore,
                   CWindowManager::OnUpdateWindowCommand)

    EVT_LEFT_UP(CWindowManager::OnLeftUp)
    EVT_MOTION(CWindowManager::OnMotion)
    EVT_MOUSE_CAPTURE_LOST(CWindowManager::OnMouseCaptureLost)
END_EVENT_TABLE()

/// CEventHandler map
BEGIN_EVENT_MAP(CWindowManager, CEventHandler)
    ON_EVENT(CWindowManagerEvent, CWindowManagerEvent::ePostCommand,
             &CWindowManager::OnPostCommand)
    ON_EVENT(CWindowManagerEvent, CWindowManagerEvent::eCloseClientsRequest,
             &CWindowManager::OnCloseClientsRequestEvent)
END_EVENT_MAP()


CWindowManager::CWindowManager(wxFrame* frame)
:   wxPanel(),
    m_Advisor(NULL),
    m_MenuListener(NULL),
    m_FrameWindow(frame),
    m_DockManager(NULL),
    m_SavedFocus(NULL),
    m_SavedFocusPanel(NULL),
    m_ActiveClient(NULL),
    m_ActiveClientTarget(NULL),
    m_ClientFactory(NULL),
    m_DragDockPanel(NULL),
    m_IsDragging(false),
    m_Canceled(false)
{
    SetSizer(new wxBoxSizer(wxVERTICAL));

    wxAuiDockArt* dock_art = m_AuiManager.GetArtProvider();
    dock_art->SetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE, 0);
}


void CWindowManager::RegisterImageAliases(wxFileArtProvider& provider)
{
    provider.RegisterFileAlias(_T("wm_menu"), _T("wm_menu.png"));
    provider.RegisterFileAlias(_T("wm_menu_active"), _T("wm_menu_active.png"));

    provider.RegisterFileAlias(_T("wm_minimize"), _T("wm_minimize.png"));
    provider.RegisterFileAlias(_T("wm_minimize_active"), _T("wm_minimize_active.png"));

    provider.RegisterFileAlias(_T("wm_float"), _T("wm_float.png"));
    provider.RegisterFileAlias(_T("wm_float_active"), _T("wm_float_active.png"));

    provider.RegisterFileAlias(_T("wm_close"), _T("wm_close.png"));
    provider.RegisterFileAlias(_T("wm_close_active"), _T("wm_close_active.png"));
}


// this function delegates client creation to m_ClientFactory and then
// registers the client
IWMClient* CWindowManager::CreateClient(const TFingerprint& fingerprint,
                                        wxWindow* parent)
{
    if(m_ClientFactory  &&  ! fingerprint.IsEmpty())   {
        IWMClient* client = m_ClientFactory->CreateClient(fingerprint, parent);
        _ASSERT(client);
        if(client)  {
            x_RegisterClient(*client);
        }
        return client;
    }
    return NULL;
}


void CWindowManager::SetRegistryPath(const string& reg_path)
{
    m_RegPath = reg_path;
}


bool CWindowManager::Create(wxWindow *parent, wxWindowID id,
                            const wxPoint& pos, const wxSize& size)
{
    bool res = wxPanel::Create(parent, id, pos, size, wxBORDER_NONE, _T("window_manager"));
    if(res) {
        m_AuiManager.SetManagedWindow(m_FrameWindow);

        wxAuiPaneInfo info;
        info.CenterPane();

        m_AuiManager.AddPane(this, info);

        m_DockManager = new CDockManager(*this, *this);
        m_DockManager->SetKeyboardHook(m_FrameWindow);

        // create the main Dock Container that will be hosted inside Window Manager
        CDockContainer* dock_cont = m_DockManager->GetMainContainer();
        GetSizer()->Add(dock_cont, 1, wxEXPAND);

        // create a container for minimized Clients
        CMinPanelContainer* cont = m_DockManager->GetMinPanelContainer();
        GetSizer()->Add(cont, 0, wxEXPAND);

        m_AuiManager.Update();
    }   

    return res;
}


CWindowManager::~CWindowManager()
{
    CloseAllClients();

    m_AuiManager.UnInit();

    delete m_DockManager;
    m_DockManager = NULL;
}


void CWindowManager::SetAdvisor(IWindowManagerAdvisor* advisor)
{
    m_Advisor = advisor;
}


void CWindowManager::SetMenuListener(IWindowManagerMenuListener* listener)
{
    m_MenuListener = listener;
}


wxFrame* CWindowManager::GetFrameWindow()
{
    return m_FrameWindow;
}


bool CWindowManager::AddClientInTab(IWMClient& client)
{
    if(client.GetWindow())  {
        if(x_RegisterClient(client))    {
            m_DockManager->AddToDefaultLocation(client);
            x_ResetMenuBar();
        }
        return true;
    }
    return false;
}


void CWindowManager::MoveToMainTab(IWMClient& client)
{
    m_DockManager->MoveToMainTab(client);
}


wxFrame* CWindowManager::MoveToFloatingFrame(IWMClient& client)
{
    return m_DockManager->MoveToFloatingFrame(client);
}


void CWindowManager::Minimize(IWMClient& client)
{
    return m_DockManager->Minimize(client);
}


void CWindowManager::Restore(IWMClient& client)
{
    return m_DockManager->Restore(client);
}


bool CWindowManager::IsInMainTab(IWMClient& client) const
{
    return m_DockManager->IsInMainTab(client);
}


bool CWindowManager::IsFloating(IWMClient& client) const
{
    return m_DockManager->IsFloating(client);
}


bool CWindowManager::IsMinimized(IWMClient& client) const
{
    return m_DockManager->IsMinimized(client);
}


/// max number of characters in the client labels shown in popups
static const int kMaxClientLabel = 30;

string CWindowManager::x_GetClientLabelForMenu(IWMClient& client)
{
    string label = client.GetClientLabel();
    if((int) label.size() > kMaxClientLabel)  {
        label.resize(kMaxClientLabel);
        label += "...";
    }
    return label;
}


// handles commands originating from IDockPanel
bool CWindowManager::OnCaptionPanelCommand(IDockPanel& panel, TCmdID cmd)
{
    switch(cmd) {
    case eCmdCloseDockPanel:
    case eCmdMoveToMainTab:
    case eCmdWindowMinimize:
    case eCmdWindowRestore:
    case eCmdWindowFloat:   {
        /// these commands can affect window hierarchy and result in some windows
        /// being destroyed because of this we need to execute them
        /// asynchronously so that we do not destroy windows on the current call
        /// stack
        CRef<CEvent> evt(new CWindowManagerEvent(panel.GetClient(), cmd));
        Post(evt, CEventHandler::eDispatch_SelfOnly);
        return true;
    }
    case eCmdSetClientColor:
        return OnSetClientColor(panel);
    default:
        //_ASSERT(false);
        break;
    }
    return false;
}


bool CWindowManager::OnSetClientColor(IDockPanel& panel)
{
    IWMClient* client = panel.GetClient();
    if (client)  {
        if(client->GetColor())   {
            // the client does support a notion of color
            CRgbaColor color = *client->GetColor();
            wxWindow* win = dynamic_cast<wxWindow*>(&panel);
            if (NcbiChooseColor(win, color)) {
                client->SetColor(color);
                win->Refresh();
            }
        }
    }
    return true;
}


bool CWindowManager::OnCloseClientsRequest(const TClients& clients)
{
    CRef<CEvent> evt(new CWindowManagerEvent(CWindowManagerEvent::eCloseClientsRequest, clients));
    Send(evt, CEventHandler::eDispatch_SelfOnly);
    return true;
}


void CWindowManager::x_RemoveClient(IWMClient& client)
{
    // check whether the client had focus
    bool reset = false;
    for (  wxWindow* w = m_SavedFocus;  w;  w = w->GetParent()) {
        if(w == m_SavedFocus)    {
            reset = true;
            break;
        }
    }
    if(reset)   {
        m_SavedFocus = NULL;
        m_SavedFocusPanel = NULL;
    }

    // reset active client
    if(&client == m_ActiveClient)   {
        m_ActiveClient = NULL;
        m_ActiveClientTarget = NULL;

        if(m_Advisor)   {
            m_Advisor->OnActiveClientChanged(m_ActiveClient);
        }
        x_ResetMenuBar();
    }

    // disconnect from command routing
    CEventHandler* target = dynamic_cast<CEventHandler*>(&client);
    if(target)  {
        RemoveListener(target);
    }

    // remove from the container
    m_DockManager->Remove(client);
}


bool CWindowManager::CloseClient(IWMClient& client)
{
    if(x_CloseClient(client))   {
        x_ResetMenuBar();
        return true;
    }
    return false;
}


void CWindowManager::CloseClients(const TClients& clients)
{
    for( size_t i = 0;  i < clients.size();  i++ )  {
        IWMClient& client = *clients[i];
        x_CloseClient(client);
    }
    x_ResetMenuBar();
}


void CWindowManager::CloseAllClients()
{
    while( ! m_Clients.empty())  {
        IWMClient& client = *m_Clients.back();
        x_CloseClient(client);
    }
    x_ResetMenuBar();
}


// removes from Root Container, Unregisters and sends notification
bool CWindowManager::x_CloseClient(IWMClient& client)
{
    bool found = IsRegistered(client);
    _ASSERT(found);

    if(found) {
        _ASSERT(m_Advisor);
        if(m_Advisor)   {
            m_Advisor->OnClientAboutToClose(client);
        }

        x_RemoveClient(client);

        x_UnRegisterClient(client);

        if(m_Advisor)   {
            m_Advisor->OnClientClosed(client);
        }
        return true;
    } else {
        ERR_POST("CWindowManager::x_CloseClient() - client not registred, cannot close");
    }
    return false;
}


void CWindowManager::GetAllClients(vector<IWMClient*>& clients)
{
    clients = m_Clients;
}


bool CWindowManager::IsRegistered(IWMClient& client) const
{
    bool found = (std::find(m_Clients.begin(), m_Clients.end(), &client) != m_Clients.end());
    return found;
}


void CWindowManager::ActivateClient(IWMClient& client)
{
    TClients clients;
    clients.push_back(&client);
    ActivateClients(clients);
}


// traverses all containers and adjusts tab panels so that clients become
// visible
void CWindowManager::ActivateClients(TClients& clients)
{
    m_DockManager->ActivateClients(clients);
}


bool CWindowManager::HasToolBar(const string& name)
{
    wxString wx_name = ToWxString(name);
    wxAuiPaneInfo& pane = m_AuiManager.GetPane(wx_name);
    return pane.IsOk();
}


void CWindowManager::AddToolBar(wxToolBar* toolbar)
{
    _ASSERT(toolbar);
    if(toolbar) {
        wxAuiPaneInfo pane_info;

        wxString name = toolbar->GetName();
        pane_info.Name(name);
        pane_info.Caption(name);

        pane_info.ToolbarPane().Top();
        pane_info.TopDockable(true)
                 .LeftDockable(false)
                 .RightDockable(false)
                 .BottomDockable(false);
        pane_info.Resizable(false);
        pane_info.DestroyOnClose(true);

        m_AuiManager.AddPane(toolbar, pane_info);
        m_AuiManager.Update();
    }
}


void CWindowManager::DeleteToolBar(const string& name)
{
    wxAuiPaneInfo& pane = m_AuiManager.GetPane(ToWxString(name));
    if(pane.IsOk()) {
        wxWindow* toolbar = pane.window;
        m_AuiManager.DetachPane(toolbar);
        toolbar->Destroy();
    }
}


IWMClient* CWindowManager::GetActiveClient()
{
    return m_ActiveClient;
}


void CWindowManager::OnShowWindowsDlg(wxCommandEvent& event)
{
    CWindowsDlg dlg;

    string path = CGuiRegistryUtil::MakeKey(m_RegPath, "Windows Dialog");
    dlg.SetRegistryPath(path);

    dlg.SetWindowManager(this);

    dlg.Create(this);
    dlg.ShowModal();
}


// creates entry in m_ClientToRec table if it does not exist
bool CWindowManager::x_RegisterClient(IWMClient& client)
{
    bool registered = IsRegistered(client);
    _ASSERT( ! registered);

    if( ! registered)   {
        m_Clients.push_back(&client);
        wxWindow* window = client.GetWindow();

        _ASSERT(window);
        _ASSERT(m_WindowToClient.find(window) == m_WindowToClient.end());

        m_WindowToClient[window] = &client;
        return true;
    }
    return false;
}


// deletes m_ClientToRec entry corresponding to the client
bool CWindowManager::x_UnRegisterClient(IWMClient& client)
{
    TClients::iterator it =
        std::find(m_Clients.begin(), m_Clients.end(), &client);
    if(it != m_Clients.end())   {
        wxWindow* window = client.GetWindow();
        m_WindowToClient.erase(window);

        m_Clients.erase(it);
        return true;
    }
    return false;
}


void CWindowManager::x_UpdateListener(IWMClient& client)
{
    TEvent evt(TEvent::eClientChanged, &client);
    Send(&evt);
}


// backbone of the menu contributed to the main Menu Bar

WX_DEFINE_MENU(sBaseMenu)
    WX_SUBMENU("&Window")
        WX_MENU_SEPARATOR_L("Actions")
        WX_MENU_ITEM(eCmdWindowMinimize)
        WX_MENU_ITEM(eCmdWindowFloat)
        WX_MENU_ITEM(eCmdMoveToMainTab)
        WX_MENU_SEPARATOR_L("Close")
        WX_MENU_ITEM(eCmdCloseDockPanel)
        WX_MENU_SEPARATOR_L("Actions2")
        WX_MENU_ITEM(eCmdShowWindowsDlg)
        WX_MENU_SEPARATOR_L("Windows")
    WX_END_SUBMENU()
WX_END_MENU()


const wxMenu* CWindowManager::GetMenu()
{
    /// build on demand
    if( ! m_Menu.get())  {
        // create static backbone
        CUICommandRegistry& cmd_reg = CUICommandRegistry::GetInstance();
        m_Menu.reset(cmd_reg.CreateMenu(sBaseMenu));

        _ASSERT(m_Menu.get());

        // create dynamic part
        x_UpdateWindowsMenu(*m_Menu);

        // get menus from only active client
        if (m_ActiveClient) {
            const wxMenu* client_root = m_ActiveClient->GetMenu();
            if(client_root)    {
                // merge Client's menu into Manager's menu
                Merge(*m_Menu, *client_root);
            }
        }
/*
        // get menus from clients
        ITERATE(TClients, it, m_Clients) {
            IWMClient* client = *it;
            const wxMenu* client_root = client->GetMenu();
            if(client_root)    {
                // merge Client's menu into Manager's menu
                Merge(*m_Menu, *client_root);
            }
        }
 */
    }
    return m_Menu.get();
}


// incrementally modify dynamic parts (if they have changed)
void CWindowManager::UpdateMenuBar(wxMenu& menu)
{
    // delete dynamic part and recreate it
    x_UpdateWindowsMenu(menu);
}


const static int    kMaxRecentItems = 10;

// generate a menu item label with numeric access key "&N"
inline string   GenerateWinItemPrefix(int index)
{
    if(index < 10)  {
        return string("&" +  NStr::IntToString(index) + "  ");
    } else if(index == 10) {
        return "1&0  ";
    }
    return "    ";
}


void CWindowManager::x_UpdateWindowsMenu(wxMenu& root_menu)
{
    m_CmdToWindow.clear();

    static wxString sWindow(_T("&Window"));

    wxMenuItem* win_item = ncbi::FindSubItem(root_menu, sWindow);
    wxMenu* win_menu = win_item ? win_item->GetSubMenu() : NULL;

    if(win_menu == NULL)    {
        // not found - create new one
        win_menu = new wxMenu(sWindow);
        root_menu.Append(wxID_ANY, win_menu->GetTitle(), win_menu);
    } else {
        // remove child items corresponding to windows
        wxMenuItemList& items = win_menu->GetMenuItems();
        for(wxMenuItemList::compatibility_iterator it = items.GetFirst();
                                                    it; ) {
            wxMenuItem* sub_item = it->GetData();

            wxMenuItemList::compatibility_iterator it_next = it->GetNext();

            if(sub_item->GetKind() == wxITEM_NORMAL)  {
                TCmdID cmd = sub_item->GetId();
                if(cmd >= eCmdWindowXXXX  &&  cmd <= eCmdWindowLast)    {
                    win_menu->Delete(sub_item);
                }
            }
            it = it_next;
        }
    }

    // show first kMaxRecentItems clients in "Windows" menu
    int index = 0;
    string s;
    ITERATE(TClients, it, m_Clients) {
        IWMClient* client = *it;

        TCmdID cmd = eCmdWindowXXXX + index++;
        m_CmdToWindow[cmd] = client;
        s = GenerateWinItemPrefix(index) + x_GetClientLabelForMenu(*client);
        win_menu->Append(cmd, ToWxString(s));

        if(index >= kMaxRecentItems)    { // show no more then kMaxRecentItems items
            break;
        }
    }
}

void CWindowManager::OnFocusChanged( wxWindow* new_focus )
{
    if( new_focus != m_SavedFocus ){
        // redraw captions for views affected by changes in focus
        if( m_SavedFocusPanel ){
            wxWindow* win = dynamic_cast<wxWindow*>( m_SavedFocusPanel );
            win->Refresh();
        }

        m_SavedFocus = new_focus;
        m_SavedFocusPanel = x_GetCaptionPanelByWindow( m_SavedFocus );

        x_SetActiveClient( m_SavedFocus );
    }
}

// update m_ActiveClient and  m_ActiveClientTarget to keep it in-sync with focus
void   CWindowManager::x_UpdateActiveClient()
{
    OnFocusChanged( FindFocus() );
}

void CWindowManager::x_SetActiveClient( wxWindow* focused )
{
    // check if focused widget is our client or a child of our client
    for( 
        wxWindow* wid = focused; 
        wid != NULL && wid != this; 
        wid = wid->GetParent()
    ){
        IWMClient* client = GetClientByWindow( wid );

        if( !client || !IsRegistered( *client ) ){ 
            continue;
        }
            
        // this OUR client
        if( m_ActiveClient != client ){    
            m_ActiveClient = client;
            m_ActiveClientTarget = dynamic_cast<CEventHandler*>(m_ActiveClient);

            if( m_Advisor ){
                m_Advisor->OnActiveClientChanged( m_ActiveClient );
            }

            x_ResetMenuBar();
        }

        break;
    }
}


bool CWindowManager::OnCommand(const TCmdID cmd)
{
    x_UpdateActiveClient();

    bool b_handled = false;

    if(m_ActiveClientTarget) {
        b_handled = m_ActiveClientTarget->OnCommand(cmd);
    }
    if(! b_handled) {
        if (CEventHandler::OnCommand(cmd)) return true;
    }
    return b_handled;
}


void CWindowManager::OnActivateWindow( wxCommandEvent& event )
{
    int cmd = event.GetId();
    IWMClient* client = m_CmdToWindow[cmd];
    ActivateClient(*client);
}


/// handles an internal command posted to itself
void CWindowManager::OnPostCommand(CEvent* evt)
{
    CWindowManagerEvent* wm_evt = dynamic_cast<CWindowManagerEvent*>(evt);
    _ASSERT(wm_evt  &&  wm_evt->GetClient());

    TCmdID cmd = wm_evt->GetCmd();
    IWMClient* client = wm_evt->GetClient();

    switch(cmd) {
    case eCmdCloseDockPanel:
    case eCmdMoveToMainTab:
    case eCmdWindowFloat:
    case eCmdWindowMinimize:
    case eCmdWindowRestore:
        x_HandlePanelCommand(*client, cmd);
        break;

    default:
        _ASSERT(false);
    }
}


// handles commands arriving from the application menu bar
void CWindowManager::OnWindowCommand(wxCommandEvent& event)
{
    IWMClient* client = GetActiveClient();
    if(client)  {
        x_HandlePanelCommand(*client, event.GetId());
    }
}


void CWindowManager::OnUpdateWindowCommand(wxUpdateUIEvent& event)
{
    IWMClient* client = GetActiveClient();
    OnUpdateWindowCommand_Client(event, client);
}


void CWindowManager::OnUpdateWindowCommand_Client(wxUpdateUIEvent& event, IWMClient* client)
{
    bool en = false;
    if(client)  {
        switch(event.GetId()) {
        case eCmdCloseDockPanel:
            en = true;
            break;

        case eCmdMoveToMainTab:
            en = m_DockManager->IsInMainTab(*client);
            break;

        case eCmdWindowFloat:
            en = ! m_DockManager->IsFloating(*client);
            break;

        case eCmdWindowMinimize:
            en = ! m_DockManager->IsMinimized(*client);
            break;

        case eCmdWindowRestore:
            en = m_DockManager->IsMinimized(*client);
            break;

        default:
            _ASSERT(false);
            break;
        }
    }
    event.Enable(en);
}


void CWindowManager::x_HandlePanelCommand(IWMClient& client, int cmd)
{
    switch(cmd) {
    case eCmdCloseDockPanel:
        _ASSERT(m_Advisor);
        /// ask advisor to take necessary action
        if(m_Advisor) {
            TClients clients;
            clients.push_back(&client);
            m_Advisor->OnCloseClientsRequest(clients);
        }
        break;

    case eCmdMoveToMainTab:
        m_DockManager->MoveToMainTab(client);
        break;

    case eCmdWindowFloat:
        m_DockManager->MoveToFloatingFrame(client);
        break;

    case eCmdWindowMinimize:
        m_DockManager->Minimize(client);
        break;

    case eCmdWindowRestore:
        m_DockManager->Restore(client);
        break;
    default:
        _ASSERT(false);
        break;
    }
}

void CWindowManager::OnCloseClientsRequestEvent(CEvent* evt)
{
    CWindowManagerEvent* wm_evt = dynamic_cast<CWindowManagerEvent*>(evt);
    _ASSERT(wm_evt);
    _ASSERT(m_Advisor);

    if(m_Advisor)   {
        TClients clients;
        wm_evt->GetClients(clients);
        m_Advisor->OnCloseClientsRequest(clients);
    }
}


IWMClient* CWindowManager::GetClientByWindow(wxWindow* widget)
{
    IDockPanel* panel = dynamic_cast<IDockPanel*>(widget);
    if(panel)   {
        return panel->GetClient();
    } else {
        TWindowToClientMap::const_iterator it = m_WindowToClient.find(widget);
        return (it == m_WindowToClient.end()) ? NULL : it->second;
    }
}

string CWindowManager::GetNewFloatingFrameTitle()
{
    if(m_Advisor)   {
        return m_Advisor->GetFloatingFrameTitle();
    } else {
        return kEmptyStr;
    }
}

void CWindowManager::RefreshClient( IWMClient& client )
{
    bool found = IsRegistered( client );
    //_ASSERT(found); This is valid for composite view such as Multi-pane alignment view
    if( !found ) return;

    wxWindow* window = client.GetWindow();
    if( !window ) return;


    CDockPanel* panel = dynamic_cast<CDockPanel*>( window->GetParent() );
    if( !panel ) return;

    panel->UpdateCaption();

    wxWindow* parent = panel->GetParent();
    CDockNotebook* notebook = dynamic_cast<CDockNotebook*>( parent );
    if( notebook ){
        notebook->RefreshPageByWindow( panel );
    } else {
       parent->Layout();
       parent->Refresh();
    }
}

// for any given widget returns the parent Caption Panel
IDockPanel* CWindowManager::x_GetCaptionPanelByWindow( wxWindow* widget )
{
    //try {
        for( wxWindow* w = widget; w != NULL; ){
            IDockPanel* panel = dynamic_cast<IDockPanel*>(w);
            if( panel ){
                return panel;
            }
            w = w->GetParent();
        }
    
    /*
    }catch(...) {
        ERR_POST("CWindowManager::x_GetCaptionPanelByWindow() - unhandled exception");
    }
    */
    return NULL;
}


bool CWindowManager::Dispatch( CEvent* evt, EDispatch disp_how, int pool )
{
    if( disp_how == eDispatch_FirstHandler ){
        // try to deliver event to the active client
        IWMClient* client = GetActiveClient();
        CEventHandler* client_handler = dynamic_cast<CEventHandler*>(client);

        if(HasListener(client_handler, pool)) {
            return client_handler->Send(evt, disp_how, pool);
        }
    }

    // default pathway
    return CEventHandler::Dispatch(evt, disp_how, pool);
}


bool CWindowManager::ProcessEvent( wxEvent& event )
{
    // Stops the same event being processed repeatedly
    static wxEventType inEvent = wxEVT_NULL;
    if( inEvent == event.GetEventType() ){
        return false;
    }
    inEvent = event.GetEventType();
    
    // Redirect events to active child first.
    bool res = false;
    if( event.IsCommandEvent() ){
        wxEventType type = event.GetEventType();

        if( type == wxEVT_UPDATE_UI || type == wxEVT_COMMAND_MENU_SELECTED ){
            IWMClient* client = GetActiveClient();
            if( client ){

                wxEvtHandler* handler = client->GetCommandHandler();
                _ASSERT(handler);

                res = handler->ProcessEvent( event );
            }
        }
    }
    if( !res ){
        res = TParent::ProcessEvent( event );
    }

    inEvent = wxEVT_NULL;
    return res;
}


objects::CUser_object* CWindowManager::SaveLayout()
{
    objects::CUser_object* layout = m_DockManager->SaveLayout();
    return layout;
}


void CWindowManager::ApplyLayout( const objects::CUser_object& layout )
{
    m_DockManager->ApplyLayout( layout );

    x_ResetMenuBar();
}


void CWindowManager::LoadLayout( const objects::CUser_object& layout, IWMClientFactory& factory )
{
    m_ClientFactory = &factory;

    // Window Manager works as a proxy for m_ClientFactory
    m_DockManager->LoadLayout( layout, *this );

    m_ClientFactory = NULL;

    x_ResetMenuBar();
}


void CWindowManager::x_ResetMenuBar()
{
    m_Menu.reset(); // delete the old one

    if( m_MenuListener ){
        m_MenuListener->UpdateMenuBar(); // request Menu Bar update
    }
}


void CWindowManager::OnDockPanelStartDrag( CDockPanel* panel, const wxPoint& pt )
{
    m_DragDockPanel = panel;

    // translate mouse position into local (client) coordinate system
    wxPoint sc_mouse_pos = m_DragDockPanel->ClientToScreen(pt);
    m_ClickPoint = ScreenToClient(sc_mouse_pos);
    m_IsDragging = true;

    /// capture mouse to receive all mouse events - now we handle the mouse
    CaptureMouse();

    x_OnBeginDrag(m_ClickPoint);
}


void CWindowManager::OnMotion(wxMouseEvent& evt)
{
    wxPoint pt = evt.GetPosition();
    //WM_POST("CWindowManager::OnMotion()  " << pt.x << " " << pt.y);

    if(m_IsDragging) {
        if ( ! evt.LeftIsDown())    {
            x_OnEndDrag(pt, CDockManager::eDrop);
        } else {
            x_OnDrag(pt);
        }
    }
}


void CWindowManager::OnLeftUp(wxMouseEvent& evt)
{
    wxPoint pt = evt.GetPosition();
    //WM_POST("CWindowManager::OnLeftUp()  " << pt.x << " " << pt.y);

    if (HasCapture())   {
        //WM_POST("ReleaseMouse()");
        ReleaseMouse();
    }

    if (m_IsDragging)   {
        x_OnEndDrag(pt, CDockManager::eDrop);
    }
}


void CWindowManager::OnMouseCaptureLost(wxMouseCaptureLostEvent& evt)
{
    //WM_POST("CWindowManager::OnMouseCaptureLost()");
    if (m_IsDragging)   {
        wxPoint pt = ::wxGetMousePosition();
        x_OnEndDrag(pt, CDockManager::eCancel);
    }
}


void CWindowManager::x_OnBeginDrag(const wxPoint& mouse_pos)
{
    //WM_POST("CWindowManager::x_OnBeginDrag()");

    m_IsDragging = true;
    wxPoint sc_mouse_pos = ClientToScreen(mouse_pos);
    m_DockManager->OnBeginDrag(*m_DragDockPanel, sc_mouse_pos);
}


void CWindowManager::x_OnDrag(const wxPoint& mouse_pos)
{
    //WM_POST("CWindowManager::x_OnDrag()");

    wxPoint sc_mouse_pos = ClientToScreen(mouse_pos);
    bool ok = m_DockManager->OnDrag(*m_DragDockPanel, sc_mouse_pos);

    if( ! ok) {
        // dragging has been canceled
        //WM_POST("CWindowManager::x_OnDrag() ok = false - canceling");

        m_Canceled = true;
        ReleaseMouse();
        //WM_POST("ReleaseMouse()");

        m_IsDragging = false;

        m_DragDockPanel->FinishDrag();
    }
}


void CWindowManager::x_OnEndDrag(const wxPoint& mouse_pos, CDockManager::EDragResult result)
{
    //LOG_POST("CWindowManager::x_OnEndDrag()");
    wxPoint sc_mouse_pos = ClientToScreen(mouse_pos);
    m_DockManager->OnEndDrag(*m_DragDockPanel, result, sc_mouse_pos);
    m_IsDragging = false;

    m_DragDockPanel->FinishDrag();
}


END_NCBI_SCOPE

---