configurableMenu.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <vrfGuiCoreQt/simpleMenu.h>
#include <vrvUtil/DtVirtualBaseClass.h> 
#include <vrvUtil/DtSignalConnectionManager.h> 
#include <vrvCore/DtMenuConfiguration.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_VRFGUICOREQT DtSubMenuPath : public makVrv::DtMenuPath
   {
   public:
      struct SubMenuPathBuilder : public MenuPathBuilder
      {
      public:
         SubMenuPathBuilder(const std::string& path)
         : MenuPathBuilder(path)
         {
         }
      };

      DtSubMenuPath(const makVrv::DtMenuPath& p) : makVrv::DtMenuPath(p) {};
      DtSubMenuPath(const std::string& p) : makVrv::DtMenuPath(SubMenuPathBuilder(p)) {};
      
      DtSubMenuPath& operator=(const DtSubMenuPath& rhs)
      {
         makVrv::DtMenuPath::operator=(rhs);
         return *this;
      }
      
      DtSubMenuPath& operator=(const SubMenuPathBuilder& rhs)
      {
         makVrv::DtMenuPath::operator=(rhs);
         return *this;
      }
      
      DtSubMenuPath& operator=(const std::string& rhs)
      {
         myPath = rhs;
         return *this;
      }

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

      static SubMenuPathBuilder path(const makVrv::DtMenuPath& p)
      {
         return SubMenuPathBuilder(p.path());
      }

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

      void strip(const std::string& str1, const std::string& str2)
      {
         QString str = myPath.c_str();
         str.replace(str1.c_str(), str2.c_str());
         myPath = str.toLatin1().constData();
      }
   };

   class DT_DLL_VRFGUICOREQT 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_VRFGUICOREQT DtSubMenuConfiguration : public makVrv::DtMenuConfiguration
   {
   public:
      DtSubMenuConfiguration()
      : makVrv::DtMenuConfiguration()
      , myDe(0)
      {
      }

      DtSubMenuConfiguration(const makVrv::DtMenuConfiguration& c)
      : makVrv::DtMenuConfiguration(c)
      , myDe(0)
      {
      }

      DtSubMenuConfiguration(makVrv::DtDe* de);

      virtual ~DtSubMenuConfiguration();

      virtual bool isUnique(const std::string&) const;

      int size() const
      {
         return myMenuPaths.size();
      }

      void convert(const std::string& str1, const std::string& str2)
      {
         MenuPathSet::iterator curIter = myMenuPaths.begin();
         for ( ; curIter != myMenuPaths.end(); curIter++)
         {
            if (curIter->isMenu() || curIter->isAbsolutePath())
            {
               ((DtSubMenuPath&)*curIter).strip(str1, str2);
            }
         }

         MenuPathOrderMap newMap;
         MenuPathOrderMap::const_iterator iter = myMenuOrder.begin();
         for ( ; iter != myMenuOrder.end(); iter++)
         {
            if (iter->first.isMenu() || iter->first.isAbsolutePath())
            {
               DtSubMenuPath path(iter->first);
               path.strip(str1, str2);

               newMap[path] = iter->second;
            }
            else
            {
               newMap[iter->first] = iter->second;
            }
         }
         myMenuOrder = newMap;
      }

      virtual void addMenuPath( const makVrv::DtMenuPath& path, int weight = -1);

      virtual void removeMenuPath(const makVrv::DtMenuPath& path);

      virtual void addMenuPathAfter(const makVrv::DtMenuPath& newPath, const makVrv::DtMenuPath& relativeTo);

      virtual void addMenuPathBefore(const makVrv::DtMenuPath& newPath, const makVrv::DtMenuPath& relativeTo);

      virtual void addMenuItemAfter(const std::string& menuItem, const std::string& after);

      virtual void removeMenuItem(const std::string& menuItem);

      virtual void addMenuItemBefore(const std::string& menuItem, const std::string& before);

      virtual makVrv::DtMenuPath menuPathForItem(const std::string& menuItem) const;

      virtual std::string mainMenu() const;

      DtSubMenuConfiguration& operator=(const makVrv::DtMenuConfiguration& rhs)
      {
         makVrv::DtMenuConfiguration::operator=(rhs);

         return *this;
      }

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

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

      const MenuPathSet& pathsRemoved() const
      {
         return myPathsRemoved;
      }

      const MenuPathSet& menuPaths() const
      {
         return myMenuPaths;
      }

      void setProtected(const std::string& p, bool b)
      {
         if (b)
         {
            myIsProtected[p] = b;
         }
         else
         {
            std::map<std::string, bool>::iterator iter = myIsProtected.find(p);
            if (iter != myIsProtected.end())
            {
               myIsProtected.erase(iter);
            }
         }
      }

      bool isProtected(const std::string& p) const
      {
         return (myIsProtected.find(p) != myIsProtected.end());
      }

      bool isGoingToBeRemoved(const makVrv::DtMenuPath& p) const
      {
         return (myPathsRemoved.find(p) != myPathsRemoved.end());
      }

      virtual void reworkRelativeOrder();

   protected:
      makVrv::DtDe*  myDe;

      std::vector<makVrv::DtMenuConfiguration*> myMakeChangesTo;
      MenuPathSet                               myPathsRemoved;
      std::map<std::string, bool>               myIsProtected;
   };

   class DT_DLL_VRFGUICOREQT 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_VRFGUICOREQT 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;
      }

      bool localOnly() const
      {
         return myLocalOnly;
      }

      void cleanup();

      makVrv::DtMenuManager& menuManager()
      {
         return myMenuManager;
      }

      const makVrv::DtMenuManager& menuManager() const
      {
         return myMenuManager;
      }

      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:
      DtConfigurationMenuManager                myMenuManager;
      std::vector<makVrv::DtQtMenuAssembler*>   myMakeChangesTo;
      bool                                      myDeleteReferences;
      bool                                      myLocalOnly;
      bool                                      myCreateSubMenusForMissingMenus;
   };

   class DT_DLL_VRFGUICOREQT 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);

      boost::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::signal<void (QAction*)> signal_validateMenuItem;

   }; 
}