dock-area.hpp

Go to the documentation of this file.

/*
  DOCK-AREA.hpp  -  maintain a docking area within the WorkspaceWindow

  Copyright (C)         Lumiera.org
    2008,               Joel Holdsworth <joel@airwebreathe.org.uk>
    2018,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef STAGE_WORKSPACE_DOCK_AREA_H
#define STAGE_WORKSPACE_DOCK_AREA_H

#include "stage/panel/panel.hpp"

#include <gdlmm.h>
#include <typeinfo>


using namespace stage::panel;       

namespace stage {
namespace workspace {
  
  
  class DockArea
    {
      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:
      DockArea (WorkspaceWindow&);
     ~DockArea();
      
      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);
      
      
    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 (const char* 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 (const char* 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)(DockArea&, 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 (DockArea& 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 (DockArea& panelManager, Gdl::DockItem& dockItem)
            {
              return new P(panelManager, dockItem);
            }
        };
      
      
      static const PanelDescription panelDescriptionList[];
    };
  
  
  
  
  template<class P>
  inline int
  DockArea::findPanelID()
  {
    return DockArea::findPanelDescription (typeid(P).name());
  }
  
  
  
}}// namespace stage::workspace
#endif /*STAGE_WORKSPACE_DOCK_AREA_H*/