DtToolbarConfiguration.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/DtToolbarPath.h>
#include <vrvCore/DtMenuPath.h>
#include <vrvCore/DtMenuConfiguration.h>

#include <list>
#include <set>
#include <boost/serialization/set.hpp>

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

      typedef std::list<DtToolbarPath> ToolbarPathList;
      typedef std::set<DtToolbarPath> ToolbarPathSet;      

      enum ToolbarLocation
      {
         DockLeft = 0,
         DockRight = 1,
         DockTop = 2,
         DockBottom = 3,
         DockNone = 4
      };

      struct ToolbarGeometry
      {
         int windowId;
         int myTop;
         int myLeft;
         int myHeight;
         int myWidth;

         ToolbarGeometry()
         {
            windowId = -1;
            myTop = 0;
            myLeft = 0;
            myWidth = 0;
            myHeight = 0;
         }

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & DT_SERIALIZE_MEMBER(windowId);
            ar & DT_SERIALIZE_MEMBER(myTop);
            ar & DT_SERIALIZE_MEMBER(myLeft);
            ar & DT_SERIALIZE_MEMBER(myHeight);
            ar & DT_SERIALIZE_MEMBER(myWidth);
         }
      };

      struct ToolbarState
      {
         bool myIsVisible;
         bool myIsFloating;
         ToolbarLocation myLocation;
         ToolbarGeometry myGeometry;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & DT_SERIALIZE_MEMBER(myIsVisible);
            ar & DT_SERIALIZE_MEMBER(myIsFloating);
            ar & DT_SERIALIZE_MEMBER(myLocation);
            ar & DT_SERIALIZE_MEMBER(myGeometry);
         }
      };

   public:

      typedef std::map<DtToolbarPath,ToolbarState> ToolbarStateMap;

      DtToolbarConfiguration ();

      virtual ~DtToolbarConfiguration();

      void addToolbarPath(const DtToolbarPath&);

      void addToolbarPathAfter(const DtToolbarPath& newPath, const DtToolbarPath& relativeTo);
      void addToolbarPathBefore(const DtToolbarPath& newPath, const DtToolbarPath& relativeTo);

      void addMenuPath(const DtMenuPath& path);

      void addMenuPathAfter(const DtMenuPath& newPath, const DtMenuPath& relativeTo);
      void addMenuPathBefore(const DtMenuPath& newPath, const DtMenuPath& relativeTo);
      void removeMenuPath(const DtMenuPath& newPath);

      void addConfiguration(const DtToolbarConfiguration& subConfiguration);

      void removeToolbarPath(const DtToolbarPath&);

      void getRootPaths(ToolbarPathList& children) const;

      void getChildren(const DtToolbarPath& path, ToolbarPathList& children) const;

      void sortChildren(ToolbarPathList& children) const;

      int getNewWeight();

      DtToolbarConfiguration& operator=(const DtToolbarConfiguration& rhs)
      {
         if (this != &rhs)
         {
            myToolbarPaths = rhs.myToolbarPaths;
            myToolbarOrder = rhs.myToolbarOrder;
            myCurrentWeight = rhs.myCurrentWeight;
            myMenuConfiguration = rhs.myMenuConfiguration;
         }

         return *this;
      }

      const DtMenuConfiguration& menuConfiguration() const
      {
         return myMenuConfiguration;
      }

      void merge(const DtToolbarConfiguration& rhs);

      void copyValuesFrom( const DtToolbarConfiguration& source );


      void updateState(const DtToolbarPath& tb, ToolbarState& state);

      const ToolbarState* state(const DtToolbarPath& tb) const;

      const ToolbarStateMap& states() const;

      void setVisible( const DtToolbarPath& tb, bool isVisible );

      DT_DECLARE_serialize_FUNCTIONS

   protected:

      template<class Archive>
      void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_BASE(DtConfiguration);
         ar & DT_SERIALIZE_MEMBER(myToolbarStates);         
      }

      void addToolbarPath(const DtToolbarPath&, int weight);

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

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

         int orderWeight;
         DtToolbarPath relative;
         bool beforeRelative;
      };

      typedef std::map<DtToolbarPath,OrderParameters> ToolbarPathOrderMap;      

      ToolbarStateMap myToolbarStates;
      ToolbarPathSet myToolbarPaths;      
      ToolbarPathOrderMap myToolbarOrder;
      int myCurrentWeight;
      DtMenuConfiguration  myMenuConfiguration;
   };
}