include/gui/widgets/workspace/window_manager.hpp

Go to the documentation of this file.

#ifndef GUI_WIDGETS_WORKSPACE___WINDOW_MANAGER_HPP
#define GUI_WIDGETS_WORKSPACE___WINDOW_MANAGER_HPP

/*  $Id: window_manager.hpp 14515 2007-05-04 17:18:18Z kazimird $
 * ===========================================================================
 *
 *                            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 <corelib/ncbistl.hpp>
#include <corelib/ncbistd.hpp>

#include <gui/widgets/workspace/wm_container.hpp>
#include <gui/widgets/workspace/wm_tab_control.hpp>
#include <gui/widgets/workspace/wm_splitter.hpp>
#include <gui/widgets/workspace/wm_caption_panel.hpp>
#include <gui/widgets/workspace/wm_dock_container.hpp>

#include <objects/general/User_field.hpp>
#include <gui/widgets/fl/frame_window.hpp>


BEGIN_NCBI_SCOPE


class CWMRootContainer;
class CWindowManagerEvent;

///////////////////////////////////////////////////////////////////////////////
///  CWindowManager - component controlling windowing of client windows.
///
/// CWindowManager provides centralized control other multiple clients (views)
/// associated with an application. Window Manager provides two major ways to
/// place clients - in independent top-level frame windows (floating) or in
/// containers emdedded into manager's main window (docked). CWindowManager
/// allows for dynamic creation of hierarchical layouts consisting of containers
/// such as CSplitter and CTabControl and clients.
/// IWMClient interface represents an abstract client window that can  be
/// managed by CWindowManager. IWMContainer interface represents an abstract
/// container that can be embedded into CWindowManager. IWMCPosition represents
/// abstract notion of position in IWMContainer.

class  CWindowManager
    : public Fl_Group,
      public CCommandTarget,
      public IWindowManager,
      public IFrameWindowClient
{
public:
    enum    EClientState    {
        eInvalidClientState = -1,
        eFloating,
        eEmbedded,
        eHidden
    };

    enum    EFrameCmd   {
        eActivate,
        eMaximize,
        eMinimize,
        eRestore
    };

    typedef CWMDockContainer::EDockPos  TDockPos;

    typedef vector<IWMClient*>  TClients;
    typedef CWindowManagerEvent TEvent;

public:
    CWindowManager(CResourceManager& res_mgr);
    virtual ~CWindowManager();

    Fl_Group*    GetRootWMContainer();

    bool    AddClientInFrame(IWMClient& client);
    bool    AddClientInTab(IWMClient& client);
    bool    AddClientToDock(IWMClient& client, const string& dock_pos);
    bool    AddClient(IWMClient& client, IWMContainer& cont,
                      const IWMPosition& pos);

    bool    MoveClientToFrame(IWMClient& client);
    bool    MoveClientToTab(IWMClient& client);

    bool    CloseClient(IWMClient& client);
    void    CloseAllClients();

    /// checks if the client in registered in the Manager
    bool    Contains(IWMClient& client) const;

    void    GetAllClients(vector<IWMClient*>& clients);
    IWMClient*  GetActiveClient();

    void    ActivateClient(IWMClient& client);
    void    ActivateClients(TClients& clients);

    EClientState    GetClientState(IWMClient& client);
    bool    FrameCommand(IWMClient& client, EFrameCmd cmd);

    void    OnMoveToFrame(IWMContainer& container, const IWMPosition& pos);

    virtual string    GetDockPosLabel(IWMClient& client);
    virtual TDockPos  GetDockPos(IWMClient& client);

    /// @name Event handlers
    /// @{
    void    OnCloseContainer(CEvent* evt);
    void    OnCloseClient(CEvent* evt);
    void    OnMoveToTopLevel(CEvent* evt);
    void    OnDockClient(CEvent* evt);
    void    OnMaximize(CEvent* evt);
    void    OnRestoreMaximizedEvt(CEvent* evt);
    /// @}

    void    OnFocusChanged(Fl_Widget* new_focus); /// focus listener

    virtual objects::CUser_object*   LayoutToUserObject(const IWMContainer& cont) const;

    /// @name IWindowManager implementation
    /// @{
    virtual void    GetPopupItems(IWMContainer& container, const IWMPosition& pos,
                                  vector<CMenuItem*>& items);
    virtual bool    OnContainerCommand(IWMContainer& container,
                                       const IWMPosition& pos, TCmdID cmd);
    virtual bool    OnContainerUpdateCommand(IWMContainer& container,
                                       const IWMPosition& pos, TCmdID cmd, ICmdUI* pCmdUI);
    virtual CMenuItem*    GetCaptionPanelMenu(CWMCaptionPanel& panel);
    virtual bool    OnCaptionPanelCommand(CWMCaptionPanel& panel, TCmdID cmd);
    virtual bool    OnCaptionPanelUpdateCommand(CWMCaptionPanel& panel, TCmdID cmd, ICmdUI* pCmdUI);
    virtual CResourceManager*   GetResourceManager();
    /// @}

    /// @name IFrameWindowClient implementation
    /// @{
    virtual void    SetFrameWindow(CFrameWindow* frame);
    virtual CMenuItem*    GetMenu();
    virtual void    UpdateMenu(CMenuItem& root);
    /// @}

    /// @name Settings support
    /// @{
    void    SetRegistryPath(const string& path);
    void    LoadSettings();
    void    SaveSettings() const;
    /// @}

    /// @name Command handling
    /// @{
    void    OnInsertSplitter(TCmdID cmd);
    void    OnActivateWindow(TCmdID cmd);

    bool    OnResizeClient(TCmdID resize_cmd, CWMCaptionPanel& panel);

    bool    OnMinimizeClient(CWMCaptionPanel& panel);
    bool    OnRestoreClient(CWMCaptionPanel& panel);
    bool    OnRestoreMaximized();
    bool    OnRestoreMinimizedClient(CWMCaptionPanel& panel);

    bool    IsMaximized() const;

    bool    PostDockEvent(TCmdID cmd, CWMCaptionPanel& panel);

    bool    OnSetClientColor(CWMCaptionPanel& panel);
    /// @}

    virtual bool    Dispatch(CEvent* evt, EDispatch disp_how, int pool);

protected:
    DECLARE_EVENT_MAP();

protected:
    struct  SClientRec
    {
        IWMClient*          m_Client;
        IWMContainer*       m_Container; // container hosting the client
        CWMCaptionPanel*    m_Panel;     // panel associated with the client
        bool        m_bFrame;
        TDockPos    m_DockPos; // docking position, eInvalidDockPos if not docked

        SClientRec();
    };

    virtual void    x_CreateRootContainers();
    virtual void    x_RegisterIcons();

    bool    x_RegisterClient(IWMClient& client);
    bool    x_UnRegisterClient(IWMClient& client);

    SClientRec* x_GetClientRec(IWMClient* client);
    const SClientRec* x_GetClientRec(IWMClient* client) const;

    int         x_GeneratePseudoCommand(IWMClient& client, int cmd);
    CMenuItem*  x_GetMoveFromFrameMenu(IWMContainer& container,
                                       const IWMPosition& pos);
    CMenuItem*  x_GetMoveHereMenu(IWMContainer& container, const IWMPosition& pos);
    //CMenuItem*  x_CreateDockMenu() const;
    void    x_GetDockItems(vector<CMenuItem*>& items) const;

    bool    x_OnPseudoCommand(IWMContainer& container, const IWMPosition& pos,
                              TCmdID cmd);
    bool    x_UpdateDockCommand(CWMCaptionPanel& panel, TCmdID cmd,
                                ICmdUI* cmd_ui);
    bool    x_UpdateMinMaxCommand(CWMCaptionPanel& panel, TCmdID cmd,
                                  ICmdUI* cmd_ui);
    bool    x_OnContainerUpdateCommand(IWMContainer& container,
                        const IWMPosition& pos, TCmdID cmd, ICmdUI* cmd_ui);

    enum    EAddOption  {
        eAddToRootTab,
        eAddToFrame,
        eAddToContainer
    };

    bool    x_AddClient(IWMClient& client, EAddOption option,
                        IWMContainer* cont = NULL, const IWMPosition* pos = NULL);

    bool    x_IsFloatingEnabled()   const   {   return m_bEnableFloating;   }

    void    x_PutClientInFrame(IWMClient& client);
    void    x_PutClientInTab(IWMClient& client);
    void    x_GetFramedClients(TClients& clients);
    CWMCaptionPanel* x_InsertClient(IWMClient& client, IWMContainer& container,
                                    const IWMPosition& pos,
                                    bool minimized = false);
    void    x_MoveInContainer(IWMClient& client, IWMContainer& container,
                           const IWMPosition& pos);
    void    x_MoveClientToTopLevel(IWMClient& client);
    void    x_MoveToDockPos(IWMClient& client, TDockPos pos);
    void    x_Close(IWMContainer& container, const IWMPosition& pos);
    bool    x_CloseClient(IWMClient& client);
    void    x_RemoveContainer(IWMContainer& container);
    void    x_RemoveClient(IWMClient& client);
    void    x_RemoveClient(SClientRec& rec);
    void    x_CascadeClose(IWMContainer& container, Fl_Widget* child);

    void    x_InsertSplitter(IWMContainer& container, const IWMPosition& pos,
                             CSplitter::EMode mode);
    CWMTabControl* x_WrapClientInTabControl(IWMContainer& cont, IWMPosition& pos);

    void    x_Maximize(IWMClient& client);
    void    x_RestoreMaximized();

    void    x_UpdateListener(IWMClient& client);

    void    x_ResetMenu();

    virtual void    x_UpdateActiveClient(void);
    virtual void    x_SetActiveClient(void);

    virtual void    x_OnSaveLayout(IWMContainer& cont, const IWMPosition* pos);

    /// overrdining CCommandTarget behavior
    virtual bool    OnCommand(const TCmdID cmd);
    //virtual bool    OnUpdateCommand(const TCmdID cmd, ICmdUI* pCmdUI);

    IWMClient*          x_GetClientByWidget(Fl_Widget* widget) const;
    const   IWMClient*  x_GetClientByWidget(const Fl_Widget* widget) const;
    CWMCaptionPanel*    x_GetCaptionPanelByClient(Fl_Widget* widget);
    CWMCaptionPanel*    x_GetCaptionPanelByWidget(Fl_Widget* widget);
    CWMCaptionPanel*    x_GetCaptionPanelByClient(IWMClient& client);
    IWMContainer*       x_GetContainerByWidget(IWMClient& client);

    virtual void    x_UpdateWindowsMenu(CMenuItem& root);

    virtual Fl_Widget*  x_CreateWindowFromUserObject(IWMContainer* cont,
                                                     const IWMPosition* pos,
                                   const objects::CUser_object& descr);
    virtual objects::CUser_object*
                x_ChildToUserObject(const IWMContainer::TChild* child) const;

    string  x_GetClientLabelForMenu(IWMClient& client);

protected:
    typedef map<IWMClient*, SClientRec*>    TClientToRecMap;
    typedef map<Fl_Widget*, IWMClient*>     TWidgetToClientMap;
    typedef map<int, pair<IWMClient*, int> >    TPseudoCmdMap;
                    /// maps generated commands to pair IWMClient, Command

    typedef map<int, IWMClient*>    TCmdToWindowMap;

    CResourceManager&   m_ResourceManager;

    bool    m_bEnableFloating;  /// enable support for floating frames

    CWMTabControl*      m_RootCont; /// root IWMContainer
    TClientToRecMap     m_ClientToRec;
    TWidgetToClientMap  m_WidgetToClient;

    TPseudoCmdMap   m_PseudoCmdMap;
    int             m_PseudoCmdCount; /// number of generated commands (for current popup)

    int m_DefFrameW;
    int m_DefFrameH;
    int m_PosIncr;
    int m_FrameX, m_FrameY;

    CFrameWindow*   m_FrameWindow;
    Fl_Widget*      m_PrevFocus;  /// widget that was previously focused

    IWMClient*      m_ActiveClient;
    CCommandTarget* m_ActiveClientTarget; /// pointer to CCommandTarget interface
    /// belonging to focused IWMClient

    TCmdToWindowMap m_CmdToWindow;

    CWMDockContainer*   m_DockContainer;

    // if a client is maximized m_RestorePos holds it "restored" position in
    // m_RestoreCont
    CWMCaptionPanel*    m_MaximizedPanel;
    auto_ptr<IWMPosition>   m_RestorePos;
    IWMContainer*   m_RestoreCont;

    string m_RegPath; // path to the setting in CGuiRegistry
};



///////////////////////////////////////////////////////////////////////////////
/// CWindowManagerEvent
class  CWindowManagerEvent : public CEvent
{
public:
    enum EEventType {
        eClientChanged = CEvent::eEvent_MinClientID,
        eBeforeClientClosed,
        eClientClosed,
        eCloseContainer,
        eCloseClient,
        eMoveToTopLevel,
        eDockClient,
        eMaximize,
        eRestoreMaximized
    };

    CWindowManagerEvent(EEventType type, IWMClient* client);
    CWindowManagerEvent(CWindowManager::TDockPos pos, IWMClient* client);
    CWindowManagerEvent(EEventType type, IWMContainer* container);

    IWMClient*      GetClient();
    IWMContainer*   GetContainer();
    CWindowManager::TDockPos    GetDockPos() const;

protected:
    IWMClient*      m_Client;
    IWMContainer*   m_Container;
    CWindowManager::TDockPos    m_DockPos;
};



END_NCBI_SCOPE

#endif  // GUI_WIDGETS_WORKSPACE___WINDOW_MANAGER_HPP

---