gre/lrtileset.h

Go to the documentation of this file.

#ifndef  INC_GRE_LRTILESET_H
#define  INC_GRE_LRTILESET_H

#ifndef  INC_GRE_LRIMAGE_H
#include <gre/lrimage.h>
#endif

#ifndef INC_SPATMOD_IMAGESOURCETILESET_H
#include <spatmod/imagesourcetileset.h>
#endif

#ifndef INC_SPATMOD_IMAGERESAMPLEMETHOD_H
#include <spatmod/imageresamplemethod.h>
#endif

#ifndef INC_MI32_RASTERFILTERPARMS_H
   #include <mi32/rasterfilterparms.h>
#endif

namespace GRE {
//===================================================================================================================

class LAYER_TILESET : public GRE::LAYER_IMAGE {
   public:

      // LAYER_TILESET::DISPPARM
      class DISPPARM : public LAYER::DISPPARM {
         public:
            DISPPARM ();

            DISPPARM (
               const DISPPARM& rhs
               );

            virtual ~DISPPARM ();

            DISPPARM& operator= (
               const DISPPARM& rhs
               ) { if (this != &rhs) { Copy(rhs); } return (*this); }

            bool GetBlackTransparent (
               ) const { return (m_bBlackTransparent); }

            bool GetWhiteTransparent (
               ) const { return (m_bWhiteTransparent); }

            bool GetDefinedTransparent (
               ) const { return (m_bDefinedTransparent); }

            bool GetDoShading (
               ) const { return (m_bDoShading); }

            const RVC::OBJITEM& GetObjItem (
               ) const { return (m_objitem); }

            RASTER_FILTER_PARMS GetRasterFilterParms (
               ) const { return (m_RasterFilterParms); }

            SPATMOD::IMAGE::RESAMPLEMETHOD GetResampleMethod (
               ) const { return (m_ResampleMethod); }

            double GetSaturation (
               ) const { return (m_Saturation); }

            bool GetShowDatatipTileInfo (
               ) const { return (m_bShowDatatipTileInfo); }

            bool GetShowDatatipImageValue (
               ) const { return (m_bShowDatatipImageValue); }

            bool GetShowLabels (
               ) const { return (m_bShowLabels); }

            double GetTransparency (
               ) const { return (m_Transparency); }

            bool IsValidated (
               ) const { return (m_IsValidated); }

            void SetBlackTransparent (
               bool BlackTransparent
               ) { m_bBlackTransparent = BlackTransparent; }

            void SetWhiteTransparent (
               bool WhiteTransparent
               ) { m_bWhiteTransparent = WhiteTransparent; }

            void SetDefinedTransparent (
               bool DefinedTransparent
               ) { m_bDefinedTransparent = DefinedTransparent; }

            void SetDoShading (
               bool DoShading
               ) { m_bDoShading = DoShading; }

            void SetObjItem (
               const RVC::OBJITEM& objitem
               ) { m_objitem = objitem; }

            void SetRasterFilterParms (
               const RASTER_FILTER_PARMS& RasterFilterParms
               ) { m_RasterFilterParms = RasterFilterParms; }

            void SetResampleMethod (
               SPATMOD::IMAGE::RESAMPLEMETHOD ResampleMethod
               ) { m_ResampleMethod = ResampleMethod; }

            void SetSaturation (
               double Saturation
               ) { m_Saturation = Saturation; }

            void SetShowDatatipTileInfo (
               bool ShowDatatipTileInfo
               ) { m_bShowDatatipTileInfo = ShowDatatipTileInfo; }

            void SetShowDatatipImageValue (
               bool ShowDatatipImageValue
               ) { m_bShowDatatipImageValue = ShowDatatipImageValue; }

            void SetShowLabels (
               bool ShowLabels
               ) { m_bShowLabels = ShowLabels; }

            void SetTransparency (
               double Transparency
               ) { m_Transparency = Transparency; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            RVC::OBJITEM m_objitem;
            SPATMOD::IMAGE::RESAMPLEMETHOD m_ResampleMethod;
            RASTER_FILTER_PARMS m_RasterFilterParms;
            double m_Saturation;
            double m_Transparency;
            bool m_bDoShading;
            bool m_bShowDatatipTileInfo;
            bool m_bShowDatatipImageValue;
            bool m_bShowLabels;
            bool m_bBlackTransparent;
            bool m_bWhiteTransparent;
            bool m_bDefinedTransparent;
            bool m_IsValidated;

            void Copy (const DISPPARM&);

            // SERIALIZABLE overrides
            virtual const SERIALIZERITEM* SerialGetItemDef (SERIALIZER& serializer) const;
            virtual ERRVALUE SerialRead (SERIALIZER& serializer);
            virtual ERRVALUE SerialWrite (SERIALIZER& serializer, const char *tagname = 0) const;

            // LAYER::DISPPARM overrides
            virtual ERRVALUE v_Validate ();

            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of LAYER_TILESET::DISPPARM

      static void RegisterType (
         );

      static void SMLClassInstall (
         SMLCONTEXT *context                    
         );

      explicit LAYER_TILESET (
         GRE::GROUP *group,                     
         CREATEFLAGS createflags = CREATEFLAG_None,   
         GRE::LISTPOS listpos = GRE::LISTPOS_Last, 
         LAYER *reflayer = 0                    
         );

      virtual ~LAYER_TILESET ();

      const DISPPARM& GetDispParm (
         ) const {
         return (m_dispparm);
         }

      void SetDispParm (
         const DISPPARM& dispparm               
         ) { m_dispparm = dispparm; }

   protected:

      DISPPARM m_dispparm;                      

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      typedef LAYER_IMAGE BASECLASS;
      
      class DLG;
      #ifdef USE_MGUI
         DLG *m_pDlgControlPanel;
      #endif

      SPATMOD::IMAGE::SOURCE_TILESET *m_pSource;
      SIMPLE_ARRAY<INT32> m_ZoomLevelArray;
      bool m_HasError;

      bool FilterDelegate (
         const SPATMOD::IMAGE::SAMPLEITERATOR *ittgt,
         const SPATMOD::IMAGE::SAMPLEITERATOR *itsrc,
         bool valid
         );

      ERRVALUE InsertSpatialFilter (
         SPATMOD::IMAGE::STAGE_AUTOPTR& StagePtr
         );

      ERRVALUE Draw2D (LAYERDC& layerdc);
      bool CanDoShading();

      #ifdef USE_MGUI
      void OnMenuTool (MGUI::ID, bool);
      #endif

      // Overrides from LAYER.
      virtual ERRVALUE v_AssignObject (const RVC::OBJITEM& objitem, MDLGPARENT dlgparent);
      #ifdef USE_MGUI
      virtual int v_ControlPanel (MDLGPARENT dlgparent, UINT32 flags = 0);
      virtual ERRVALUE v_PromptObject (bool OpenCtrlPanel, MDLGPARENT dlgparent);
      virtual void v_MenuAddLayerItems (MGUI::MENU& menu);
      #endif
      bool v_DataTipHasEnabled () const;
      virtual void v_DataTipGetObjectNamesString (const DPOINT2D& point, MISTRING& string, int indent, GRE::VIEW *view) const;
      int v_DataTipGetString (const DPOINT2D& point, MISTRING& string, SPATMOD::IMAGE::STAGE_ARRAY& images, GRE::VIEW *view);
      virtual bool v_CanRender () const;
      virtual LAYER* v_Copy (GRE::GROUP *group) const;
      virtual ERRVALUE v_Draw (LAYERDC& layerdc);
      virtual double v_GetScaleMaxDetail (const DPOINT2D& point, const SPATREF::COORDREFSYS& crs, double DisplayPixelSizeMM) const;
      virtual bool v_HasNullImageCells () const;
      virtual const char* v_SerialGetTagName () const;
      virtual void v_SetDftName (bool ReplaceExisting);
      virtual ERRVALUE v_UpdateExtents (bool forceupdate);
      
      LAYER_TILESET (const LAYER_TILESET&);
      LAYER_TILESET& operator= (const LAYER_TILESET&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   }; // End of LAYER_TILESET


//===================================================================================================================
}  // End namespace GRE

#endif   // INC_GRE_LRTILESET_H

---