panel-manager.hpp

Go to the documentation of this file.

/*
  PANEL-MANAGER.hpp  -  management of dockable GDL panels
 
   Copyright (C)
     2008,            Joel Holdsworth <joel@airwebreathe.org.uk>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef STAGE_WORKSPACE_PANEL_MANAGER_H
#define STAGE_WORKSPACE_PANEL_MANAGER_H
 
#include "stage/panel/panel.hpp"
 
#include <gdlmm.h>
#include <typeinfo>
 
 
using namespace stage::panel;       
 
namespace stage {
namespace workspace {
  
  
  class PanelManager
    {
      WorkspaceWindow& workspaceWindow_;
      
      Gdl::Dock dock_;
      
      Gdl::DockBar dockBar_;
      
      Glib::RefPtr<Gdl::DockLayout> dockLayout_;
      
      GdlDockPlaceholder *dockPlaceholders_[4];
      
      std::list<panel::Panel*> panels_;
      
      static unsigned short panelID;
      
      
    public:
      PanelManager (WorkspaceWindow&);
     ~PanelManager();
      
      void setupDock();
      
      Gdl::Dock& getDock();
      
      Gdl::DockBar& getDockBar();
      
      WorkspaceWindow& getWorkspaceWindow();                             
      
      panel::Panel& showPanel (const int description_index);
      
      bool hasPanel (const int description_index);
      
      void switchPanel (panel::Panel& old_panel, const int description_index);
      
      void splitPanel (panel::Panel& panel, Gtk::Orientation split_direction, panel::Panel* toAdd =nullptr);
      
      
    public:
      template<class P>
      static int findPanelID();
      
      static int getPanelDescriptionCount();
      
      static const gchar* getPanelStockID (const int index);
      
      static const char* getPanelTitle (int index);
      
      
    private:
      void createPanels();
      
      static int findPanelDescription (CStr class_name);
      
      panel::Panel* createPanel_by_index (const int index);
      
      panel::Panel* createPanel_by_index (const int index, Gdl::DockItem& dock_item);
      
      panel::Panel* createPanel_by_name (CStr class_name);
      
      int getPanelType (panel::Panel* const panel) const;
      
      void removePanel (panel::Panel* const panel);
      
      void clearPanels();
      
      
    private:
      void on_panel_shown (panel::Panel *panel);
      
      
      
    private:
      
      class PanelDescription
        {
        protected:
          typedef panel::Panel* (*const CreatePanelProc)(PanelManager&, Gdl::DockItem&);
        private:
          const std::type_info& classInfo_;
          
          const char* const titleName_;
          
          const gchar* const stockID_;
          
          CreatePanelProc createPanelProc_;
          
          
        protected:
          PanelDescription (std::type_info const& classInfo
                           ,const char* title
                           ,const gchar* stockID
                           ,CreatePanelProc createPanelProc)
            : classInfo_(classInfo)
            , titleName_(title)
            , stockID_(stockID)
            , createPanelProc_(createPanelProc)
            {
              REQUIRE(titleName_);
            }
            
          
        public:
          const std::type_info& getClassInfo()  const
            {
              return classInfo_;
            }
          
          const char* getClassName()  const
            {
              return classInfo_.name();
            }
          
          const char* getTitle()  const
            {
              ENSURE(titleName_);
              return titleName_;
            }
          
          const gchar* getStockID()  const
            {
              ENSURE(stockID_);
              return stockID_;
            }
          
          
          panel::Panel*
          create (PanelManager& panelManager, Gdl::DockItem& dockItem)  const
            {
              REQUIRE(createPanelProc_);
              return createPanelProc_ (panelManager, dockItem);
            }
        };
      
      
      
      template<class P>
      class Panel
        : public PanelDescription
        {
        public:
          Panel()
            : PanelDescription (typeid(P)
                               ,P::getTitle()
                               ,P::getStockID()
                               ,Panel::createPanel)
            { }
          
        private:
          static panel::Panel*
          createPanel (PanelManager& panelManager, Gdl::DockItem& dockItem)
            {
              return new P(panelManager, dockItem);
            }
        };
      
      
      static const PanelDescription panelDescriptionList[];
    };
  
  
  
  
  template<class P>
  inline int
  PanelManager::findPanelID()
  {
    return PanelManager::findPanelDescription (typeid(P).name());
  }
  
  
  
}}// namespace stage::workspace
#endif /*STAGE_WORKSPACE_PANEL_MANAGER_H*/