DtPageConfiguration.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtPagePath.h>
#include <vrvUtil/DtConfiguration.h>
#include <vrvUtil/DtUnicode.h>
#include <boost/unordered_map.hpp>
#include <list>
#include <set>
#include <boost/serialization/set.hpp>

namespace makVrv
{
   class DT_DLL_VRVCORE DtPageConfiguration : public DtConfiguration
   {   

   public:

      typedef std::list<DtPagePath> PagePathList;
      typedef std::set<DtPagePath> PagePathSet;

      DtPageConfiguration();

      virtual ~DtPageConfiguration();

      DtPageConfiguration& operator=(const DtPageConfiguration& rhs);

      enum PageCollectionLocation
      {
         DockLeft = 0,
         DockRight = 1,
         DockTop = 2,
         DockBottom = 3,
         FloatLeft = DockLeft | 4,
         FloatRight = DockRight | 4,
         FloatTop = DockTop | 4,
         FloatBottom = DockBottom | 4,
         Dialog,
         Location_End
      };

      struct PageCollectionGeometry
      {
         int myWindowId;
         int myTop;
         int myLeft;
         int myWidth;         
         int myHeight;

         PageCollectionGeometry()
         {
            myWindowId = -1;
            myTop = 10;
            myLeft = 10;
            myWidth = 10;
            myHeight = 10;
         }

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

      struct PageCollectionState
      {
         DtUnicode myTitle; // deprecated.  Title is NOT state
         PageCollectionLocation myLocation;
         PageCollectionGeometry myFloatingGeometry;
         PageCollectionGeometry myDockedGeometry;
         bool myVisibleFlag;
         int myTabIndex;
         std::string myPageToShow;
         bool myClosable;
         bool myFloatable;
         bool myMovable;

         PageCollectionState()
         {
            myLocation = DtPageConfiguration::DockLeft;
            myVisibleFlag = true;
            myClosable = true;
            myFloatable = true;
            myMovable = true;
            myTabIndex = -1;
            myPageToShow.clear();
         }

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            // Name of temporary variable is very important here for
            // serializarion/deserialization. That name is used to define
            // the xml tag inside the record! Do not change it!
            if ( version < 1 )
            {
               std::string myLocalTitle;
               myTitle.toUtf8(myLocalTitle);
               ar & DT_SERIALIZE_MEMBER(myLocalTitle);
               myTitle = DtUnicode::fromUtf8(myLocalTitle);
            }
            ar & DT_SERIALIZE_MEMBER(myLocation);
            ar & DT_SERIALIZE_MEMBER(myDockedGeometry);
            ar & DT_SERIALIZE_MEMBER(myFloatingGeometry);
            ar & DT_SERIALIZE_MEMBER(myVisibleFlag);
            ar & DT_SERIALIZE_MEMBER(myPageToShow);
            ar & DT_SERIALIZE_MEMBER(myTabIndex);
            if ( version > 1 )
            {
               ar & DT_SERIALIZE_MEMBER(myClosable);
               ar & DT_SERIALIZE_MEMBER(myFloatable);
               ar & DT_SERIALIZE_MEMBER(myMovable);
            }
         }         
      };

      typedef std::map<std::string,PageCollectionState> PageCollectionStatesMap;
      typedef std::map<std::string,DtUnicode> PageCollectionTitlesMap;

      void addPageCollection(const std::string& collectionClassName,
         const DtUnicode& pageTitle, PageCollectionLocation location, 
         bool visible, const std::string& pageClassToShow, bool closable = true,
         bool floatable = true, bool movable = true);

      void removePageCollection(const std::string& collectionClassName);

      const PageCollectionState* findPageCollectionState(const std::string& collectionClassName) const;
      PageCollectionState* findPageCollectionState(const std::string& collectionClassName);

      const bool isPageVisible(const std::string& pageName) const;

      const DtUnicode* findPageCollectionTitle(const std::string& collectionClassName) const;
      DtUnicode* findPageCollectionTitle(const std::string& collectionClassName);

      void addPagePath(const DtPagePath&, int weight = -1);

      void addPagePathAfter(const DtPagePath& newPath, const DtPagePath& relativeTo);

      void addPagePathBefore(const DtPagePath& newPath, const DtPagePath& relativeTo);

      void addConfiguration(const DtPageConfiguration& subConfiguration);

      void removePagePath(const DtPagePath&);

      void getRootPaths(PagePathList& children) const;

      void getChildren(const DtPagePath& path, PagePathList& children) const;

      void sortChildren(PagePathList& children) const;

      virtual PagePathList filterForAbsoluteChildren( const PagePathList &children ) const;

      virtual PagePathList filterForRelativeChildren( const PagePathList &children ) const;

      int getNewWeight();

      void merge(const DtPageConfiguration& rhs);

      void copyValuesFrom( const DtPageConfiguration& source );

      bool hasPagePath(const DtPagePath& p) const;

      const PageCollectionStatesMap& states() const;

      const PageCollectionTitlesMap& titles() const;

      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(myCurrentWeight);         
         ar & DT_SERIALIZE_MEMBER(myCollections);
         ar & DT_SERIALIZE_MEMBER(myPagePaths);
         ar & DT_SERIALIZE_MEMBER(myPageOrder);
      }

      bool comparePagesByPageOrder(const DtPagePath& a, const DtPagePath& b) const;

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

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & DT_SERIALIZE_MEMBER(orderWeight);
            ar & DT_SERIALIZE_MEMBER(relative);
            ar & DT_SERIALIZE_MEMBER(beforeRelative);
         }

         int orderWeight;
         DtPagePath relative;
         bool beforeRelative;
      };

      virtual const OrderParameters& pageOrderFor(const DtPagePath& pagePath) const;

   protected:

      typedef std::map<DtPagePath,OrderParameters> PagePathOrderMap; 

      PagePathSet myPagePaths;     
      PagePathOrderMap myPageOrder;
      PageCollectionStatesMap myCollections;
      PageCollectionTitlesMap myPageCollectionTitles;
      int myCurrentWeight;
   };
}
BOOST_CLASS_VERSION(makVrv::DtPageConfiguration::PageCollectionState,2)