DtBaseSettingsManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvUtil/vrvUtil.h>

#include <vrvCore/DtWriteSettingsLock.h>
#include <vrvCore/DtReadSettingsLock.h>
#include <vrvCore/DtRecordSettingsBackup.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <vlutil/vlUtil.h>

namespace makVrv
{

   template <typename RecordType>
   class DtCommonBaseSettingsManager : public DtVirtualBaseClass
   {
   public:

      DtCommonBaseSettingsManager( DtDe& de, const std::string& name,
            const std::string& displayName, const std::string& ext )
         : myName( name )
         , myExtension( ext )
         , myDisplayName( displayName )
         , myUseDefaultSettingsRecordFlag( false )
         , myAutoSaveFlag( true )
         , mySettingsBackup( 0 )
         , myDe( de )
      {
         // Create the settings object
         DtDeSettingsManager::instance( myDe ).createSettings( name, ext );
      }

      virtual ~DtCommonBaseSettingsManager()
      {
      }

      virtual void autoSaveIfNecessary()
      {
         if ( autoSave() )
         {
            saveDefaultSettings();
         }
      }

      virtual void setAutoSave( bool doit )
      {
         myAutoSaveFlag = doit;
      }

      virtual bool autoSave() const
      {
         return myAutoSaveFlag;
      }

      virtual void setUseDefaultSettingsRecord( bool useit )
      {
         myUseDefaultSettingsRecordFlag = useit;
      }

      virtual bool useDefaultSettingsRecord() const
      {
         return myUseDefaultSettingsRecordFlag;
      }

      virtual DtDeSettings* settings()
      {
         DtDeSettings* deSettings =
            DtDeSettingsManager::instance(myDe).findSettings( myName );
         if ( ! deSettings )
         {
            DtTHROW_NEW( DtCorruptedState, "DtDeSettings have gone missing!" );
         }
         return deSettings;
      }

      virtual const DtDeSettings* settings() const
      {
         DtDeSettings* deSettings =
            DtDeSettingsManager::instance(myDe).findSettings( myName );
         if ( ! deSettings )
         {
            DtTHROW_NEW( DtCorruptedState, "DtDeSettings have gone missing!" );
         }
         return deSettings;
      }

      virtual DtSettingsBackup* settingsBackup()
      {
         return mySettingsBackup;
      }

      virtual const DtSettingsBackup* settingsBackup() const
      {
         return mySettingsBackup;
      }


      virtual void loadDefaults()
      {
         // Disable auto saving and store state.
         bool autoSaved = autoSave();
         setAutoSave( false );

         // Either set from the default record (if present) or load defaults.
         RecordType record;
         if ( myUseDefaultSettingsRecordFlag &&
            myDe.deInitializer().findDefaultSettingsRecord(myName,record) )
         {
            // This code path:
            //   - allows toolkit users to set a default settings record before application initialization.
            //   - is seldom used by MAK.
            setFromRecord( record );
         }
         else if (getOverriddenFactoryRecord(record))
         {
            // This code path:
            //   - allows VRV developers to override settings, through code, with more ease.
            //   - should never be used in production.
            setFromRecord(record);
         }
         else
         {
            // This code path:
            //  - is almost always used.
            //  - will read from the appData directory (if false is passed)
            //  - will read from the factory directory (if true is passed)
            loadDefaultSettings( false );
         }

         // Restore the auto save state.
         setAutoSave( autoSaved );

         // Initialize the settings backup.
         initializeBackup();
      }

      virtual void initializeBackup() = 0;

      virtual void saveDefaultSettings()
      {
         RecordType record;
         getRecord( record );
         settings()->writeDefaultRecord( record );
      }

      virtual void loadDefaultSettings( bool loadOnlyFactorySettings )
      {
         DtDeSettings* deSettings = settings();
         RecordType record;
         if ( loadOnlyFactorySettings )
         {
            if ( deSettings->readFactoryDefaultRecord(record) )
            {
               setFromRecord( record );
            }
         }
         else
         {
            if ( deSettings->readDefaultRecord(record) )
            {
               setFromRecord( record );
            }
         }
      }

      virtual void importSettings( const std::string& filePath )
      {
         RecordType record;
         if ( settings()->readRecordFrom(record,filePath) )
         {
            setFromRecord( record );
            autoSaveIfNecessary();
         }
      }

      virtual void exportSettings( const std::string& filePath ) const
      {
         RecordType record;
         getRecord( record );
         settings()->writeRecordTo( record, filePath );
      }

      virtual void setFromRecord( const RecordType& record ) = 0;

      virtual void getRecord( RecordType& record ) const = 0;
      
      virtual bool getOverriddenFactoryRecord( RecordType& record ) const = 0;

      

   protected:

      DtSignalConnectionManager myConnections;

      std::string myName;
      std::string myExtension;
      std::string myDisplayName;

      bool myUseDefaultSettingsRecordFlag;
      bool myAutoSaveFlag;

      DtSettingsBackup* mySettingsBackup;

      DtDe& myDe;

   };


   template <typename RecordType>
   class DtBaseSettingsManager : public DtCommonBaseSettingsManager<RecordType>
   {
   protected:

      typedef DtRecordSettingsBackup<DtBaseSettingsManager<RecordType>,RecordType> RecordBackupType;

   public:

      DtBaseSettingsManager( DtDe& de, const std::string& name,
            const std::string& displayName, const std::string& ext )
         : DtCommonBaseSettingsManager<RecordType>( de, name, displayName, ext )
      {
      }

      virtual ~DtBaseSettingsManager()
      {
         DtDELETE( this->mySettingsBackup );
      }


      virtual void initializeBackup()
      {
         DtDELETE( this->mySettingsBackup );
         this->mySettingsBackup = new RecordBackupType( this->myDe, this, this->myName, this->myDisplayName );
         this->mySettingsBackup->setFactoryFile( this->settings()->factoryFilePath() );
         DtSettingsBackupManager::instance(this->myDe).registerSettingsBackup( this->mySettingsBackup );
         this->mySettingsBackup->backup();
      }

      virtual void setFromRecord( const RecordType& record ) = 0;

      virtual void getRecord( RecordType& record ) const = 0;
      
      virtual bool applyFactoryOverrides( RecordType& record ) const = 0;

      virtual bool getOverriddenFactoryRecord(RecordType& record) const
      {
         // get the factory record
         const DtDeSettings* deSettings = this->settings();
         deSettings->readFactoryDefaultRecord(record);

         // Can be overridden by child classes
         return applyFactoryOverrides(record);
      }


   };


   template <typename RecordType,typename SettingsType>
   class DtBaseSharedSettingsManager : public DtCommonBaseSettingsManager<RecordType>
   {
   protected:

      typedef DtSharedRecordSettingsBackup<SettingsType,RecordType> SharedRecordBackupType;

   public:

      DtBaseSharedSettingsManager( DtDe& de, const std::string& name,
            const std::string& displayName, const std::string& ext )
         : DtCommonBaseSettingsManager<RecordType>( de, name, displayName, ext )
      {
      }

      virtual ~DtBaseSharedSettingsManager()
      {
         // Don't delete the settings backup (it's owned by the settings object).
      }


      virtual void initializeBackup()
      {
         DtWriteSettingsLock<SettingsType>
            writeSettings( DtSharedSettingsManager::instance(this->myDe) );
         this->mySettingsBackup = writeSettings->settingsBackup();
         this->mySettingsBackup->setFactoryFile( this->settings()->factoryFilePath() );
         DtSettingsBackupManager::instance(this->myDe).registerSettingsBackup( this->mySettingsBackup );
         writeSettings->backup();
      }

      virtual void setFromRecord( const RecordType& record )
      {
         {
            DtWriteSettingsLock<SettingsType>
               settings( DtSharedSettingsManager::instance(this->myDe) );
            settings->setFromRecord( record );
         }
         this->saveDefaultSettings();
      }

      virtual void getRecord( RecordType& record ) const
      {
         DtReadSettingsLock<SettingsType>
            settings( DtSharedSettingsManager::instance(this->myDe) );
         settings->getRecord( record );
      }

      virtual bool getOverriddenFactoryRecord(RecordType& record) const
      {
         // get the factory record
         const DtDeSettings* deSettings = this->settings();
         deSettings->readFactoryDefaultRecord(record);

         // pass the factory record to the getFactoryOverrideRecord and let the shared settings class 
         // decide whether or not there are overridden values
         DtReadSettingsLock<SettingsType>
            settings(DtSharedSettingsManager::instance(this->myDe));
         return settings->applyFactoryOverrides(record);
      }


   };

}