DtOverlaySettingsRecord.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2007 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#ifndef DtOverlaySettingsRecord_H_ 
#define DtOverlaySettingsRecord_H_ 
 
#include <makArchives/makArchives.h> 
 
#include <string>
#include <vector>

namespace makArchives 
{ 

   class DT_DLL_MAKARCHIVES DtGradientControlPoint
   {

   public:

      DtGradientControlPoint(double location, double red, double green, double blue, double alpha)
         : myLocation(location)
         , myRed(red)
         , myGreen(green)
         , myBlue(blue)
         , myAlpha(alpha)
      {
      }

      DtGradientControlPoint()
         : myLocation(0)
         , myRed(0)
         , myGreen(0)
         , myBlue(0)
         , myAlpha(0)
      {
      }

      inline bool operator==(const DtGradientControlPoint&c2) const
      {
         return (myLocation == c2.myLocation 
            && myRed == c2.myRed 
            && myGreen == c2.myGreen 
            && myBlue == c2.myBlue 
            && myAlpha == c2.myAlpha);
      }
      
      inline bool operator!=(const DtGradientControlPoint&c2) const
      {
         return !(*this == c2);
      }

      inline double location() const
      {
         return myLocation;
      }

      inline double red() const
      {
         return myRed;
      }

      inline double green() const
      {
         return myGreen;
      }

      inline double blue() const
      {
         return myBlue;
      }

      inline double alpha() const
      {
         return myAlpha;
      }

      inline void getColor(float& r, float& g, float& b, float& a) const
      {
         r = static_cast<float>(myRed);
         g = static_cast<float>(myGreen);
         b = static_cast<float>(myBlue);
         a = static_cast<float>(myAlpha);
      }

   protected:

      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myLocation);
         ar & BOOST_SERIALIZATION_NVP(myRed);
         ar & BOOST_SERIALIZATION_NVP(myGreen);
         ar & BOOST_SERIALIZATION_NVP(myBlue);
         ar & BOOST_SERIALIZATION_NVP(myAlpha);
      }

   protected:
      double myLocation;
      double myRed;
      double myGreen;
      double myBlue;
      double myAlpha;

   };

   class DT_DLL_MAKARCHIVES DtRasterLayerRecord 
   {
   public:

      DtRasterLayerRecord();

      DtRasterLayerRecord(const DtRasterLayerRecord& orig);

      bool operator==(const DtRasterLayerRecord& orig) const;
      bool operator!=(const DtRasterLayerRecord& orig) const;

      DtRasterLayerRecord& operator=(const DtRasterLayerRecord& orig);

      ~DtRasterLayerRecord();

   public:

      void setEnabled(bool);
      bool enabled() const;

      void setName(const std::string&);
      const std::string& name() const;

      void setFilename(const std::string&);
      const std::string& filename() const;

      void setWrapMode(char);
      char wrapMode() const;

      void setBlendMode(char);
      char blendMode() const;

      void setTransformIsSet(bool);
      bool transformIsSet() const;

      void setScale(double x, double y);
      void scale(double& x, double& y) const;

      void setOffset(double x, double y);
      void offset(double& x, double& y) const;

      void setRasterOperation(int);
      int rasterOperation() const;

   protected:

      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myEnabled);
         ar & BOOST_SERIALIZATION_NVP(myName);
         ar & BOOST_SERIALIZATION_NVP(myFilename);
         ar & BOOST_SERIALIZATION_NVP(myWrapMode);
         ar & BOOST_SERIALIZATION_NVP(myBlendMode);
         ar & BOOST_SERIALIZATION_NVP(myTransformIsSet);
         ar & BOOST_SERIALIZATION_NVP(myScaleX);
         ar & BOOST_SERIALIZATION_NVP(myScaleY);
         ar & BOOST_SERIALIZATION_NVP(myOffsetX);
         ar & BOOST_SERIALIZATION_NVP(myOffsetY);
      }

   protected:
         bool myEnabled;
         std::string myFilename;
         std::string myName;
         char myWrapMode;
         char myBlendMode;
         bool myTransformIsSet;
         double myScaleX;
         double myScaleY;
         double myOffsetX;
         double myOffsetY;

         int myRasterOperation;
   };

   class DT_DLL_MAKARCHIVES DtOverlaySettingsRecord 
   { 

   public:

      DtOverlaySettingsRecord();

      DtOverlaySettingsRecord(const DtOverlaySettingsRecord& orig);

      bool operator==(const DtOverlaySettingsRecord& orig) const;
      bool operator!=(const DtOverlaySettingsRecord& orig) const;

      DtOverlaySettingsRecord& operator=(const DtOverlaySettingsRecord& orig);

      virtual ~DtOverlaySettingsRecord();

      typedef std::vector<DtGradientControlPoint> ControlPointList;




      bool baseSourceEnabled() const;

      void setBaseSourceEnabled(bool enabled);


      void addRasterLayer(const DtRasterLayerRecord& rec);

      std::string addRasterLayer(const std::string& name = "");

      bool removeRasterLayer(const std::string& name);

      void insertRasterLayerRecord(const DtRasterLayerRecord&, int iIndex);

      int moveRasterLayer(const std::string& raster, int iBy);

      virtual bool renameRasterLayer(const std::string& oldName, const std::string& newName);

      bool hasRasterLayer(const std::string& name) const;

      DtRasterLayerRecord rasterLayerRecord(const std::string& name) const;

      int rasterLayerIndex(const std::string& name) const;

      const DtRasterLayerRecord& rasterLayerRecord(int) const;
      DtRasterLayerRecord& rasterLayerRecord(int);

      int numRasterLayers() const;

      void setEnabled(const std::string& raster, bool);
      bool enabled(const std::string& raster) const;

      void setName(const std::string& raster, const std::string&);
      std::string name(const std::string& raster) const;

      void setFilename(const std::string& raster, const std::string&);
      std::string filename(const std::string& raster) const;

      void setRasterOperation(const std::string& raster, int);
      int rasterOperation(const std::string&) const;

      void setWrapMode(const std::string& raster, char);
      char wrapMode(const std::string& raster) const;

      void setBlendMode(const std::string& raster, char);
      char blendMode(const std::string& raster) const;

      void setTransformIsSet(const std::string& raster, bool);
      bool transformIsSet(const std::string& raster) const;

      void setScale(const std::string& raster, double x, double y);
      void scale(const std::string& raster, double& x, double& y) const;

      void setOffset(const std::string& raster, double x, double y);
      void offset(const std::string& raster, double& x, double& y) const;




      bool contourEnabled() const;

      bool contourIntermediateLinesEnabled() const;

      double contourInterval() const;

      double contourThickness() const;

      void setContourEnabled(bool enabled);

      void setContourIntermediateLinesEnabled(bool enabled);

      void setContourInterval(double interval);

      void setContourThickness(double thickness);



      bool elevationEnabled() const;

      const DtOverlaySettingsRecord::ControlPointList& elevationGradient() const;

      void setElevationEnabled(bool enabled);

      void setElevationGradient(const DtOverlaySettingsRecord::ControlPointList& gradient);


      protected:

         friend class boost::serialization::access;

         template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myBaseSourceEnabled);
            ar & BOOST_SERIALIZATION_NVP(myContourEnabled);
            ar & BOOST_SERIALIZATION_NVP(myContourIntermediateLinesEnabled);
            ar & BOOST_SERIALIZATION_NVP(myContourInterval);
            ar & BOOST_SERIALIZATION_NVP(myContourThickness);
            ar & BOOST_SERIALIZATION_NVP(myElevationEnabled);
            ar & BOOST_SERIALIZATION_NVP(myElevationGradient);
            ar & BOOST_SERIALIZATION_NVP(myRasterLayerRecords);
         }


   protected:

         bool myBaseSourceEnabled;
         bool myContourEnabled;
         bool myContourIntermediateLinesEnabled;
         double myContourInterval;
         double myContourThickness;
         bool myElevationEnabled;
         ControlPointList myElevationGradient;
         std::vector<DtRasterLayerRecord> myRasterLayerRecords;
   }; 
} 

BOOST_CLASS_VERSION(makArchives::DtOverlaySettingsRecord, 0)
 
#endif