defaultGuiConfigurationCreator.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrfGuiCore/informationPageConfiguration.h>
#include <vrvCore/DtPageConfiguration.h>
#include <vrvCore/DtMenuConfiguration.h>
#include <vrvCore/DtToolbarConfiguration.h>
#include <mtl/envValue.h>
#include <boost/signals2.hpp>

namespace makVrv
{
   class DtDe;
}

class DtEnvList;

namespace makVrf
{

   class DT_DLL_VRFGUICORE DtDefaultGuiConfigurationCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      typedef boost::function<void (const DtString&)> ReadOptionFunction;
      typedef boost::function<void (DtEnvironment*, DtEnvValueSP)> WriteOptionFunction;

      enum Flags
      {
         InformationConfiguration = 1,
         PageConfiguration = 2,
         ToolbarConfiguration = 4,
         MenuConfiguration = 8,
         RightClickMenuConfiguration = 16,
         AllConfigurations = 32
      };

      typedef std::map<std::string, makVrv::DtMenuConfiguration> RightClickConfigurations;

      DtDefaultGuiConfigurationCreator(makVrv::DtDe&);

      virtual ~DtDefaultGuiConfigurationCreator() override;

      static DtDefaultGuiConfigurationCreator& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe& de, DtDefaultGuiConfigurationCreator*);

      virtual void createDefaultGuiConfigurationFile(bool force = false);

      virtual void save(const std::string&);

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

      const DtFilename& filename() const
      {
         return myFilename;
      }

      virtual bool isValid() const;

   public:
      virtual void setInformationPageConfiguration(const DtInformationPageConfiguration&);
      const DtInformationPageConfiguration& informationPageConfiguration() const
      {
         return myLoadedConfigurations.myInformationDialogConfiguration;
      }
      DtInformationPageConfiguration& informationPageConfiguration()
      {
         return myLoadedConfigurations.myInformationDialogConfiguration;
      }
      const std::vector<std::vector<std::string> >& tabbedPageConfigurations() const
      {
         return myLoadedConfigurations.myTabbedPageConfigurations;
      }
      std::vector<std::vector<std::string> >& tabbedPageConfigurations()
      {
         return myLoadedConfigurations.myTabbedPageConfigurations;
      }
      const DtInformationPageConfiguration& originalInformationPageConfiguration() const
      {
         return myBackupConfigurations.myInformationDialogConfiguration;
      }

      virtual void setMainPageConfiguration(const makVrv::DtPageConfiguration&);
      const makVrv::DtPageConfiguration& mainPageConfiguration() const
      {
         return myLoadedConfigurations.myMainPageConfiguration;
      }
      makVrv::DtPageConfiguration& mainPageConfiguration()
      {
         return myLoadedConfigurations.myMainPageConfiguration;
      }
      const makVrv::DtPageConfiguration& originalPageConfiguration() const
      {
         return myBackupConfigurations.myMainPageConfiguration;
      }

      virtual void setMainToolbarConfiguration(const makVrv::DtToolbarConfiguration&);
      const makVrv::DtToolbarConfiguration& mainToolbarConfiguration() const
      {
         return myLoadedConfigurations.myMainToolbarConfiguration;
      }
      makVrv::DtToolbarConfiguration& mainToolbarConfiguration()
      {
         return myLoadedConfigurations.myMainToolbarConfiguration;
      }
      const makVrv::DtToolbarConfiguration& originalToolbarConfiguration() const
      {
         return myBackupConfigurations.myMainToolbarConfiguration;
      }

      virtual void setRightClickMenuConfiguration(const RightClickConfigurations&);
      const RightClickConfigurations& rightClickMenuConfiguration() const
      {
         return myLoadedConfigurations.myRightClickMenuConfigurations;
      }
      RightClickConfigurations& rightClickMenuConfiguration()
      {
         return myLoadedConfigurations.myRightClickMenuConfigurations;
      }
      const RightClickConfigurations& originalRightClickMenuConfiguration() const
      {
         return myBackupConfigurations.myRightClickMenuConfigurations;
      }

      virtual void setMainMenuConfiguration(const makVrv::DtMenuConfiguration&);
      const makVrv::DtMenuConfiguration& mainMenuConfiguration() const
      {
         return myLoadedConfigurations.myMainMenuConfiguration;
      }
      makVrv::DtMenuConfiguration& mainMenuConfiguration()
      {
         return myLoadedConfigurations.myMainMenuConfiguration;
      }
      const makVrv::DtMenuConfiguration& originalMenuConfiguration() const
      {
         return myBackupConfigurations.myMainMenuConfiguration;
      }

      virtual void addRightClickContextMenu(const std::string& context, const makVrv::DtMenuConfiguration& configuration);
      const makVrv::DtMenuConfiguration& rightClickContextMenu(const std::string& context) const;
      makVrv::DtMenuConfiguration& rightClickContextMenu(const std::string& context);
      const makVrv::DtMenuConfiguration& originalRightClickContextMenu(const std::string& context) const;

      virtual void clearAllContextMenus();

      virtual void install();

      boost::signals2::signal<void ()> signal_preInstall;
      boost::signals2::signal<void ()> signal_postInstall;

      virtual void installLockedOnly();

      boost::signals2::signal<void ()> signal_preLockInstall;
      boost::signals2::signal<void ()> signal_postLockInstall;

      virtual void setLock(int, bool);
      bool isLocked(int) const;

      virtual void readOptions(DtEnvironment*, DtEnvValueSP root);

      virtual void saveOptions(DtEnvironment* env, DtEnvValueSP root);

      virtual void addOption(const DtString& option, ReadOptionFunction readFunc, WriteOptionFunction writeFunc);

      virtual double dockedToolbarWidth(const DtString&) const;
      virtual void setDockedToolbarWidth(const DtString&, double);

   protected:
      virtual void setOverrideLayout(const DtString&);
      virtual void writeOverrideLayout(DtEnvironment* env, DtEnvValueSP root);

      virtual void setAllowEditing(const DtString&);
      virtual void postTickSetAllowEditing(bool b);
      virtual void writeAllowEditing(DtEnvironment* env, DtEnvValueSP root);
      virtual void setupTabbedPagedCollections();

      virtual void setLayoutSettingsFile(const DtString&);
      virtual void writeLayoutSettingsFile(DtEnvironment* env, DtEnvValueSP root);

      virtual void saveMenuConfiguration(DtEnvironment* env, DtEnvValueSP root, const makVrv::DtMenuConfiguration&) const;

      virtual void savePageConfiguration(DtEnvironment* env, DtEnvValueSP root, const makVrv::DtPageConfiguration&) const;

      virtual void saveToolbarConfiguration(DtEnvironment* env, DtEnvValueSP root, const makVrv::DtToolbarConfiguration&) const;

   protected:
      struct Configurations
      {
         void operator=(const Configurations& rhs)
         {
            myInformationDialogConfiguration = rhs.myInformationDialogConfiguration;
            myMainPageConfiguration = rhs.myMainPageConfiguration;
            myMainMenuConfiguration = rhs.myMainMenuConfiguration;
            myMainToolbarConfiguration = rhs.myMainToolbarConfiguration;
            myMainToolbarConfiguration.copyValuesFrom(rhs.myMainToolbarConfiguration);
            myRightClickMenuConfigurations = rhs.myRightClickMenuConfigurations;
            myTabbedPageConfigurations = rhs.myTabbedPageConfigurations;
         }

         DtInformationPageConfiguration myInformationDialogConfiguration;
         makVrv::DtPageConfiguration myMainPageConfiguration;
         makVrv::DtMenuConfiguration myMainMenuConfiguration;
         makVrv::DtToolbarConfiguration myMainToolbarConfiguration;
         RightClickConfigurations myRightClickMenuConfigurations;
         std::vector<std::vector<std::string> > myTabbedPageConfigurations;
      };

      Configurations myLoadedConfigurations;
      Configurations myBackupConfigurations;

      makVrv::DtDe& myDe;
      int mySetFlags;
      int myLockedFlags;

      DtFilename myFilename;

      struct OptionFunctions
      {
         ReadOptionFunction readFunction;
         WriteOptionFunction writeFunction;
      };

      typedef std::map<DtString, OptionFunctions> OptionFunctionsMap;
      OptionFunctionsMap myOptionFunctions;

      typedef std::map<DtString, double> DockedToolbarWidths;
      DockedToolbarWidths myDockedToolbarWidths;
   };

   class DT_DLL_VRFGUICORE DtVrfMenuConfigurationWriter : public makVrv::DtMenuConfiguration
   {
   public:
      DtVrfMenuConfigurationWriter(const makVrv::DtMenuConfiguration&);

      virtual ~DtVrfMenuConfigurationWriter() override;

      virtual void writeTo(DtEnvironment* env, DtEnvValueSP root) const;

   protected:
      virtual void writeMenuPath(DtEnvironment* env, DtEnvValueSP root, const makVrv::DtMenuPath& menuPath) const;
   };

   class DT_DLL_VRFGUICORE DtVrfMenuConfigurationReader : public makVrv::DtMenuConfiguration
   {
   public:
      DtVrfMenuConfigurationReader();

      virtual ~DtVrfMenuConfigurationReader() override;

      virtual void readFrom(DtEnvironment* env, DtEnvValueSP root, const std::string& menuType = "mainmenu");

   protected:
      virtual void createMenuFromNode(DtEnvironment* env, DtEnvValueSP menu);
      virtual makVrv::DtMenuConfiguration::MenuSortFlags sortMenuFlags(::DtEnvironment* env, DtEnvValueSP menu) const;
   };

   class DT_DLL_VRFGUICORE DtVrfPageConfigurationWriter : public DtInformationPageConfiguration
   {
   public:
      DtVrfPageConfigurationWriter(const DtInformationPageConfiguration&);

      virtual ~DtVrfPageConfigurationWriter() override;

      virtual void writeTo(DtEnvironment* env, DtEnvValueSP root) const;

   protected:
      virtual void writePagePath(DtEnvironment* env, DtEnvValueSP root, const DtInformationPagePath& menuPath) const;
   };

   class DT_DLL_VRFGUICORE DtVrfPageConfigurationReader : public DtInformationPageConfiguration
   {
   public:
      DtVrfPageConfigurationReader();

      virtual ~DtVrfPageConfigurationReader() override;

      virtual void readFrom(DtEnvironment* env, DtEnvValueSP root);

   protected:
      virtual void createPageFromNode(DtEnvironment* env, DtEnvValueSP menu);

      virtual void parsePageItems(DtEnvironment* env, DtEnvList* items, const DtInformationPagePath::InformationPagePathBuilder& );
   };

   class DT_DLL_VRFGUICORE DtVrfToolbarConfigurationWriter : public makVrv::DtToolbarConfiguration
   {
   public:
      DtVrfToolbarConfigurationWriter(const DtDefaultGuiConfigurationCreator* c, const makVrv::DtToolbarConfiguration&);

      virtual ~DtVrfToolbarConfigurationWriter() override;

      virtual void writeTo(DtEnvironment* env, DtEnvValueSP root) const;

   protected:
      virtual void writeToolbarPath(DtEnvironment* env, DtEnvValueSP root, const makVrv::DtToolbarPath& menuPath) const;

   protected:
      const DtDefaultGuiConfigurationCreator* myCreator;
   };

   class DT_DLL_VRFGUICORE DtVrfToolbarConfigurationReader : public makVrv::DtToolbarConfiguration
   {
   public:
      DtVrfToolbarConfigurationReader(DtDefaultGuiConfigurationCreator*);

      virtual ~DtVrfToolbarConfigurationReader() override;

      virtual void readFrom(DtEnvironment* env, DtEnvValueSP root);
      const ToolbarStateMap& toolbarStates() const { return myToolbarStates; };

   protected:
      virtual void createToolbarFromRow(DtEnvironment* env, DtEnvValueSP row);
      virtual void createToolbar(DtEnvironment* env, DtEnvValueSP toolbar);

   protected:
      DtDefaultGuiConfigurationCreator* myCreator;
   };

   class DT_DLL_VRFGUICORE DtVrfTabbedConfigurationReader
   {
   public:
      DtVrfTabbedConfigurationReader();

      virtual ~DtVrfTabbedConfigurationReader();

      virtual void readFrom(DtEnvironment* env, DtEnvValueSP root);
      const std::vector<std::vector<std::string> >& tabbedPageConfigurations() const { return myTabbedPagedConfigurations; };

   protected:
      virtual void readTabbedConfiguration(DtEnvironment* env, DtEnvValueSP row);

   protected:
      std::vector<std::vector<std::string> > myTabbedPagedConfigurations;
   };
}