DtMenuConfiguration.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtMenuPath.h>
#include <vrvUtil/DtConfiguration.h>

#include <list>
#include <set>

namespace makVrv
{
   class DT_DLL_VRVCORE DtMenuConfiguration : public DtConfiguration
   {
   public:

      //Ordered vector of paths.
      typedef std::list<DtMenuPath> MenuPathList;

      typedef std::set<DtMenuPath> MenuPathSet;

      enum MenuSortFlags
      {
         NoSort = 0x00000000,                // Do not sort the menu at all
         SortAllAlphabetically = 0x00000001, // Sorts all individual items and sub menus on a menu alphabetically
         SortWithinSubmenus = 0x00000002,    // Goes into sub menus recursively and sorts their contents
         SortBetweenSeparators = 0x00000004, // Sorts all items alphabetically between action separators
         SortBetweenSubMenus = 0x00000010    // Sorts all items alphabetically between sub menus without sorting the sub menus
      };

   public:
      DtMenuConfiguration();

      virtual ~DtMenuConfiguration();

      void addMenuPath(const DtMenuPath&, const MenuSortFlags& sortFlagsIfMenu 
         = (MenuSortFlags)(SortAllAlphabetically | SortWithinSubmenus | SortBetweenSeparators));

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

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

      void addConfiguration(const DtMenuConfiguration& subConfiguration);

      void removeMenuPath(const DtMenuPath&);

      void getRootPaths(MenuPathList& children) const;

      void getChildren(const DtMenuPath& path, MenuPathList& children) const;

      void sortChildren(MenuPathList& children) const;

      DtMenuConfiguration& operator=(const DtMenuConfiguration& rhs)
      {
         if (this != &rhs)
         {
            myMenuPaths = rhs.myMenuPaths;
            myMenuOrder = rhs.myMenuOrder;
            myCurrentWeight = rhs.myCurrentWeight;
            myMenuSortFlags = rhs.myMenuSortFlags;
         }

         return *this;
      }

      void merge(const DtMenuConfiguration& rhs);

      bool hasMenuPath(const DtMenuPath& p) const;

      bool menuSortFlags(const DtMenuPath& p, MenuSortFlags& flags) const;

   protected:

      int getNewWeight();

      void addMenuPath(const DtMenuPath&, int weight);

      bool sortAbsolute(const DtMenuPath& a, const DtMenuPath& b) const;

      struct OrderParameters
      {
         OrderParameters()
         : orderWeight(0)
         , relative(DtMenuPath::empty())
         , beforeRelative(false)
         {
         }

         int orderWeight;
         DtMenuPath relative;
         bool beforeRelative;
      };

      MenuPathSet myMenuPaths;

      typedef std::map<DtMenuPath,OrderParameters> MenuPathOrderMap;
      typedef std::map<DtMenuPath, MenuSortFlags> MenuPathSortFlagsMap;
      MenuPathOrderMap myMenuOrder;
      MenuPathSortFlagsMap myMenuSortFlags;

      int myCurrentWeight;
   };
}