configurableMenu.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2014 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrfGuiCommonQt/vrfGuiCommonQt.h>
#include <vrfGuiCommonQt/simpleMenu.h>
#include <vrfGuiCore/subMenuConfiguration.h>
#include <vrvUtil/DtVirtualBaseClass.h> 
#include <vrvUtil/DtSignalConnectionManager.h> 
#include <vrvCore/DtToolbarConfiguration.h> 
#include <vrvCoreQt/DtMenuItem.h> 
#include <vrvCoreQt/DtMenu.h> 
#include <vrvCoreQt/DtQtMenuAssembler.h> 
#include <vrvCoreQt/DtMenuManager.h> 

#include <QtCore/QString>


namespace makVrv
{
   class DtDe;
};

namespace makVrf
{
   class DT_DLL_VRFGUICOMMONQT DtSubToolbarPath : public makVrv::DtToolbarPath
   {
   public:
      struct SubToolbarPathBuilder : public ToolbarPathBuilder
      {
      public:
         SubToolbarPathBuilder(const std::string& path)
         : ToolbarPathBuilder(path)
         {
         }
      };

      DtSubToolbarPath(const makVrv::DtToolbarPath& p) : makVrv::DtToolbarPath(p) {};
      DtSubToolbarPath(const std::string& p) : makVrv::DtToolbarPath(SubToolbarPathBuilder(p)) {};
      
      DtSubToolbarPath& operator=(const DtSubToolbarPath& rhs)
      {
         makVrv::DtToolbarPath::operator=(rhs);
         return *this;
      }
      
      DtSubToolbarPath& operator=(const SubToolbarPathBuilder& rhs)
      {
         makVrv::DtToolbarPath::operator=(rhs);
         return *this;
      }
      
      DtSubToolbarPath& operator=(const std::string& rhs)
      {
         myPath = rhs;
         return *this;
      }

      const std::string& path() const
      {
         return makVrv::DtToolbarPath::path();
      }

      static SubToolbarPathBuilder path(const makVrv::DtToolbarPath& p)
      {
         return SubToolbarPathBuilder(p.path());
      }

      static SubToolbarPathBuilder path(const std::string& p)
      {
         return SubToolbarPathBuilder(p);
      }
   };

   class DT_DLL_VRFGUICOMMONQT DtConfigurationMenuManager : public makVrv::DtMenuManager
   {
   public:
      DtConfigurationMenuManager()
      : makVrv::DtMenuManager()
      , myDeleteMenus(false)
      {
      }

      void clear()
      {
         myMenuItems.clear();
         myMenus.clear();
      }

      void setDeleteMenus(bool b)
      {
         myDeleteMenus = b;
      }

      bool deleteMenus() const
      {
         return myDeleteMenus;
      }

      virtual ~DtConfigurationMenuManager()
      {
         if (myDeleteMenus) cleanup();
      }

      void cleanup();

      std::string findMenuPath(QMenu*) const;
      std::string findItemPath(QAction*) const;

   protected:
      bool  myDeleteMenus;
   };

   class DT_DLL_VRFGUICOMMONQT DtConfigurableMenuAssembler : public makVrv::DtQtMenuAssembler
   {
   public:
      DtConfigurableMenuAssembler(makVrv::DtDe& de);

      virtual ~DtConfigurableMenuAssembler()
      {
         myMenuManager.clear();

         if (!myDeleteReferences)
         {
            myMenuBuilders.clear();
            myMenuItemBuilders.clear();
         }
         else
         {
            cleanup();
         }
      }

      void setDeleteReferences(bool b)
      {
         myDeleteReferences = b;
      }

      bool deleteReferences() const
      {
         return myDeleteReferences;
      }

      void setLocalOnly(bool b)
      {
         myLocalOnly = b;
      }

      void setLocalMenuManager(bool b)
      {
         myLocalMenuManager = b;
      }

      virtual void assemble(const makVrv::DtMenuConfiguration& configuration);
      virtual void fixCircularDependencies(DtSubMenuConfiguration& configuration) const;

      virtual bool hasCircularDependency(DtSubMenuConfiguration& configuration) const;

      bool localOnly() const
      {
         return myLocalOnly;
      }

      void cleanup();

      makVrv::DtMenuManager& menuManager()
      {
         if (myLocalMenuManager)
         {
            return myMenuManager;
         }
         else
         {
            return DtQtMenuAssembler::menuManager();
         }
      }

      const makVrv::DtMenuManager& menuManager() const
      {
         if (myLocalMenuManager)
         {
            return myMenuManager;
         }
         else
         {
            return makVrv::DtMenuManager::instance(myDe);
         }
      }

      QMenu* findMenu(const makVrv::DtMenuPath& path)
      {
         return menuManager().findMenu(path);
      }

      QAction* findMenuItem(const makVrv::DtMenuPath& path)
      {
         return menuManager().findMenuItem(path);
      }

      virtual void registerMenu(makVrv::DtMenu*);

      virtual void unregisterMenu(makVrv::DtMenu*, bool deleteBuilder = true);

      virtual void registerMenu(makVrv::DtMenuItem*);

      virtual void unregisterMenu(makVrv::DtMenuItem*, bool deleteBuilder = true);

      virtual void merge(const DtQtMenuAssembler::MenuBuilderMap&);

      virtual void merge(const DtQtMenuAssembler::MenuItemBuilderMap&);

      void makeChangesTo(makVrv::DtQtMenuAssembler* c)
      {
         myMakeChangesTo.push_back(c);
      }

      void clearMakeChangesTo()
      {
         myMakeChangesTo.clear();
      }

      virtual QMenuBar* menuBar()
      {
         if (myLocalOnly) return 0;
         else return makVrv::DtQtMenuAssembler::menuBar();
      }

      virtual QWidget* menuWindow()
      {
         if (myLocalOnly) return 0;
         else return makVrv::DtQtMenuAssembler::menuWindow();
      }

      void setCreateSubMenusForMissingMenus(bool b)
      {
         myCreateSubMenusForMissingMenus = b;
      }

      virtual void assembleMenu(const makVrv::DtMenuPath& menuPath);

   protected:
      virtual bool fixMenuPath(const makVrv::DtMenuPath& menuPath, DtSubMenuConfiguration& configuration, bool checkOnly = false) const;

   protected:
      DtConfigurationMenuManager                myMenuManager;
      std::vector<makVrv::DtQtMenuAssembler*>   myMakeChangesTo;
      bool                                      myDeleteReferences;
      bool                                      myLocalOnly;
      bool                                      myCreateSubMenusForMissingMenus;
      bool                                      myLocalMenuManager;
   };

   class DT_DLL_VRFGUICOMMONQT DtConfigurableMenu : 
       public makVrv::DtMenu, public makVrv::DtVirtualBaseClass
   { 
   public:

      DtConfigurableMenu(makVrv::DtDe&, const std::string& className);

      virtual ~DtConfigurableMenu();

      virtual DtSubMenuConfiguration& menuConfiguration()
      {
         return myConfiguration;
      }

      virtual DtConfigurableMenuAssembler& menuAssembler()
      {
         return myAssembler;
      }

      virtual void registerMenu(makVrv::DtMenu* customMenu);
      
      virtual void registerMenuItem(makVrv::DtMenuItem* customMenuItem);
      
      virtual void createSimpleMenu(std::string menuText, makVrv::DtMenuPath menuIdPath, int weight = -1);
      virtual void createSimpleMenuAfter(std::string menuText, makVrv::DtMenuPath menuIdPath, makVrv::DtMenuPath afterIdPath);
      virtual void createSimpleMenuBefore(std::string menuText, makVrv::DtMenuPath menuIdPath, makVrv::DtMenuPath beforeIdPath);

      virtual void createSimpleMenuItem(std::string itemText, makVrv::DtMenuPath itemIdPath, 
         DtSimpleMenuItemAction* action, void* usr = NULL, int weight = -1);
      virtual void createSimpleMenuItemAfter(std::string itemText, makVrv::DtMenuPath itemIdPath, makVrv::DtMenuPath afterIdPath, 
         DtSimpleMenuItemAction* action, void* usr = NULL);
      virtual void createSimpleMenuItemBefore(std::string itemText, makVrv::DtMenuPath itemIdPath, makVrv::DtMenuPath beforeIdPath,
         DtSimpleMenuItemAction* action, void* usr = NULL);

      virtual void mergeMenu(makVrv::DtQtMenuAssembler& assembler, makVrv::DtMenuConfiguration& configuration);

      virtual void mergeMenu(makVrv::DtQtMenuAssembler& assembler);

      virtual void mergeMenu(makVrv::DtMenuConfiguration& configuration);

      static bool hasMenuPath(const makVrv::DtMenuConfiguration& menus, const makVrv::DtMenuPath& sourcePath, const std::string& item, makVrv::DtMenuPath& foundPath);

      boost::signals2::signal<void (DtConfigurableMenu*)> signal_menuRecreated;

   protected:
      virtual void initMenuItems(makVrv::DtDe& de);

      DtConfigurableMenuAssembler& assembler()
      {
         return myAssembler;
      }

      DtSubMenuConfiguration& configuration()
      {
         return myConfiguration;
      }

      virtual void createMenuConfiguration(makVrv::DtDe&) {};

   protected:
      DtConfigurableMenuAssembler   myAssembler;
      DtSubMenuConfiguration        myConfiguration;
      bool                          myInitialized;
      makVrv::DtSignalConnectionManager myConnections;

   public:
      boost::signals2::signal<void (QAction*)> signal_validateMenuItem;

   }; 
}