subMenuConfiguration.h

Go to the documentation of this file.

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

#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrvCore/DtMenuConfiguration.h> 
#include <vrvCore/DtMenuPath.h> 

#include <QtCore/QString>

namespace makVrf
{
   class DT_DLL_VRFGUICORE 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_VRFGUICORE 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() override;

      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, const MenuSortFlags& sortFlagsIfMenu 
         = (MenuSortFlags)(SortAllAlphabetically | SortWithinSubmenus | SortBetweenSeparators));

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

      virtual void addMenuPathAfter(const makVrv::DtMenuPath& newPath, const makVrv::DtMenuPath& relativeTo, const MenuSortFlags& sortFlagsIfMenu 
         = (MenuSortFlags)(SortAllAlphabetically | SortWithinSubmenus | SortBetweenSeparators));

      virtual void addMenuPathBefore(const makVrv::DtMenuPath& newPath, const makVrv::DtMenuPath& relativeTo, const MenuSortFlags& sortFlagsIfMenu 
         = (MenuSortFlags)(SortAllAlphabetically | SortWithinSubmenus | SortBetweenSeparators));

      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;
      }

      virtual bool fixSortChildren(makVrv::DtMenuConfiguration::MenuPathList&, bool checkOnly = false);

      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:
      bool sortAbsolute(const makVrv::DtMenuPath& a, const makVrv::DtMenuPath& b) const;

   protected:
      makVrv::DtDe*  myDe;

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