gre/viewable.h

Go to the documentation of this file.

#ifndef  INC_GRE_VIEWABLE_H
#define  INC_GRE_VIEWABLE_H

#ifndef  INC_GRE_OBJECTBASE_H
   #include <gre/objectbase.h>
#endif

#ifndef INC_MI32_SERIALIZERITEM_H
   #include <mi32/serializeritem.h>
#endif

#ifndef INC_MI32_SERIALIZABLE_H
   #include <mi32/serializable.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef  INC_MI32_RECT_H
   #include <mi32/rect.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef  INC_RVC_OBJITEM_H
   #include <rvc/objitem.h>
#endif

#ifndef INC_MI32_SMLBASE_H
   #include <mi32/smlbase.h>
#endif

#ifndef INC_MI32_MILIST_H
   #include <mi32/milist.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class STEREORENDER;
#endif

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

class VIEWABLE : public GRE::OBJECT {
   public:

   #ifdef USE_MGUI
      class MAINSCRIPT : public SERIALIZABLE {
         public:
            enum FUNC {
               FUNC_OnViewDataTipShowRequest,            
               FUNC_OnViewDataTipShowText,               
               FUNC_OnGroupDrawLabelsBegin,              
               FUNC_OnGroupDrawLabelsEnd,                
               FUNC_OnLayerDrawLabelsBegin,              
               FUNC_OnLayerDrawLabelsEnd,                
               FUNC_OnDrawLabel,                         
               FUNC_COUNT
               };

            MAINSCRIPT (VIEWABLE *viewable);
            virtual ~MAINSCRIPT ();
            int CallFunction (
               FUNC func,
               SMLARG *ArgIn,
               int NumArg,
               SMLARG *ArgRet = 0
               );
            int CallFunction (
               FUNC func,
               int NumArg,
               void *ArgPtr1,
               void *ArgPtr2 = 0,
               void *ArgPtr3 = 0
               );
            void Destroy ();
            int DlgEdit (MDLGPARENT dlgparent);
            bool HasFunction (FUNC func) const;
            bool HasScript () const;
            ERRVALUE Initialize ();
            void Terminate ();
         private:
            class CONTEXT;
            VIEWABLE *m_viewable;
            CONTEXT *m_pContext;
            MISTRING m_String;
            MISTRING m_DisplayString;
            bool m_IsEncrypted;
            MISTRING m_ScriptPath;

            ERRVALUE CreateSMLContext (SMLCONTEXT *& smlcontext);
            static void GRECB_CtrlScript (const GRE::MSG *pMsg, void *vpCtrlScript);
            static const SERIALIZERITEM* SerialGetItemDef ();
            virtual ERRVALUE SerialRead (SERIALIZER& serializer);
            virtual ERRVALUE SerialWrite (SERIALIZER& serializer, const char *tagname = 0) const;
            friend class MAINSCRIPT::CONTEXT;
         };
   #endif

      class PARM_RENDERTORASTER {
         public:

            PARM_RENDERTORASTER (
               COLORSPACE ColorSpace,
               INT32 RasterColumns,
               INT32 RasterRows,
               double CellSize
               );

            PARM_RENDERTORASTER (
               COLORSPACE ColorSpace,
               INT32 RasterColumns,
               INT32 RasterRows
               );

            PARM_RENDERTORASTER (
               COLORSPACE ColorSpace,
               double CellSize
               );

            ~PARM_RENDERTORASTER ();

            const COLOR& GetBackgroundColor () const
               { return (m_BackgroundColor); }

            double GetCellSize () const
               { return (m_CellSize); }

            const COLOR_ARRAY* GetColorPalette () const
               { return (m_pPalette); }

            COLORSPACE GetColorSpace () const
               { return (m_ColorSpace); }

            const DRECT2D& GetExtentsView () const
               { return (m_ExtentsView); }

            MGD::PIXEL GetFallbackPixel () const
               { return (m_FallbackPixel); }

            INT32 GetImageColumns () const
               { return (m_RasterColumns); }

            INT32 GetImageRows () const
               { return (m_RasterRows); }

            bool GetSaveGeoreference () const
               { return (m_SaveGeoreference); }

            const STEREORENDER* GetStereoValues () const
               { return (m_pStereoValues); }

            bool GetUseClosestColorIfNotInPalette () const
               { return (m_UseClosestIfNotInPalette); }

            int GetViewNum () const
               { return (m_ViewNum); }

            bool HasColorPalette () const
               { return (m_pPalette != 0); }

            bool IsDrawingStereo () const
               { return (m_StereoDrawing && m_pStereoValues != 0); }

            void SetBackgroundColor (
               const COLOR& BackgroundColor
               ) { m_BackgroundColor = BackgroundColor; }

            void SetExtents (
               const DRECT2D& ExtentsView
               ) { m_ExtentsView = ExtentsView; }

            void SetPalette (
               const COLOR_ARRAY* pPalette,              
               bool UseClosestIfNotInPalette = false,    
               MGD::PIXEL *pFallbackPixel = 0            
               );

            void SetSaveGeoreference (
               bool SaveGeoreference
               ) { m_SaveGeoreference = SaveGeoreference; }

            void SetStereoDrawing (
               bool StereoDrawing = true
               ) { m_StereoDrawing = StereoDrawing; }

            void SetStereoValues (
               const STEREORENDER& StereoValues
               );

            void SetViewNum (
               int ViewNum
               ) { m_ViewNum = ViewNum; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            COLORSPACE m_ColorSpace;
            INT32 m_RasterColumns;
            INT32 m_RasterRows;
            double m_CellSize;
            COLOR m_BackgroundColor;
            int m_ViewNum;
            bool m_SaveGeoreference;
            bool m_UseClosestIfNotInPalette;
            const COLOR_ARRAY *m_pPalette;
            MGD::PIXEL m_FallbackPixel;
            DRECT2D m_ExtentsView;
            STEREORENDER *m_pStereoValues;
            bool m_StereoDrawing;

            void InitCommon ();
            #endif
         };

      static void SMLClassInstall (
         SMLCONTEXT* context
         );

      virtual ~VIEWABLE (
         );

      void Clear (
         );

      void ClearSaveLocation (
         ) { m_SaveObjItem.Clear(); }

   #ifdef USE_MGUI
      // Open dialog to edit 'control script' if allowed.
      ERRVALUE ControlScriptEdit (
         MDLGPARENT dlgparent
         );
   #endif

      void DestroyAllViews (
         );

      ERRVALUE DrawAllViews (
         GRE::DRAWCONDITION condition = GRE::DRAWCONDITION_Always
         ) { return (v_DrawAllViews(condition)); }

   #ifdef USE_MGUI
      MAINSCRIPT& GetControlScript (
         ) { return (m_CtrlScript); }
   #endif

      GRE::LAYER* GetActiveLayer (
         ) const { return (v_GetActiveLayer()); }

      const DRECT2D& GetExtents (
         ) const { return (v_GetExtents()); }

      virtual GRE::LAYER *FindLayerByID (
         UINT32 LayerID
         ) const = 0;

      double GetDesignScale (
         ) const { return (v_GetDesignScale()); }

      GRE::HIGHLIGHTMODE GetElemHighlightMode (
         ) const { return (GetTopViewable()->m_ElemHighlightMode); }

      GRE::VIEW* GetFirstView (
         ) const;

      virtual void GetFullName (
         MISTRING& name                         
         ) const = 0;

      const char* GetIniName (
         ) const { return (m_IniName); }

   #ifdef USE_MGUI
      GRE::MACROSCRIPTLIST& GetMacroScriptList (
         ) { return (*m_pMacroScriptList); }
   #endif

      double GetMaxScaleVisibleAny (
         ) const { return (v_GetMaxScaleVisibleAny()); }

      double GetMinScaleVisibleAny (
         ) const { return (v_GetMinScaleVisibleAny()); }

      virtual UINT32 GetNextLayerID (
         ) const = 0;

      void GetNoRenderLayerList (MILIST<GRE::LAYER*>& LayerList);

      const FILEPATH& GetSaveFilePath (
         ) const { return (m_SaveObjItem.GetFilePath()); }

      const RVC::OBJITEM& GetSaveObjItem (
         ) const { return (m_SaveObjItem); }

      virtual ERRVALUE GetSizeMeters (
         DPOINT2D& sizemeters                   
         ) = 0;

   #ifdef USE_MGUI
      GRE::TOOLSCRIPTLIST& GetToolScriptList (
         ) { return (*m_pToolScriptList); }
   #endif

      const VIEWABLE* GetTopViewable (
         ) const;

      VIEWABLE* GetTopViewable (
         );

      GRE::VIEW* GetView (
         int ViewNum
         ) const;

      virtual bool HasLayers (
         ) const = 0;

      bool HasSaveLocation (
         ) const;

      bool IsModified (
         ) const { return (m_IsModified); }

      bool IsTopViewable (
         ) const { return (this == GetTopViewable()); }

      ERRVALUE RenderToRaster (
         RVC::OBJITEM& objitem,                    
         const PARM_RENDERTORASTER& parm           
         );

      void ResetModified (
         ) { m_IsModified = false; }

      void SetDesignScale (
         double DesignScale,                    
         bool notify = true                     
         ) { v_SetDesignScale(DesignScale,notify); }

      void SetElemHighlightMode (
         GRE::HIGHLIGHTMODE HighlightMode
         );

      void SetIniBase (
         const char* name
         );

   #ifdef USE_MGUI
      void SetMacroScriptList (
         const GRE::MACROSCRIPTLIST& ScriptList
         );
   #endif

      void SetSaveFilePath (
         const FILEPATH& SaveFilePath
         );

      void SetSaveObjItem (
         const RVC::OBJITEM& SaveObjItem
         ) { m_SaveObjItem = SaveObjItem; }

   #ifdef USE_MGUI
      void SetToolScriptList (
         const GRE::TOOLSCRIPTLIST& ScriptList
         );
   #endif

   #ifdef USE_MGUI
      void TreeViewGetAll (
         SIMPLE_ARRAY<GRE::CTRL_TREEVIEW*>& TreeViewPtrs
         ) const;
   #endif

   #ifdef USE_MGUI
      void TreeViewSetPtr (
         GRE::CTRL_TREEVIEW *pTreeView
         ) { m_pTreeView = pTreeView; }
   #endif

      void UpdateViewScriptUI (
         );

      void UnhighlightAllElements (
         bool redrawviews
         ) { v_UnhighlightAllElements(redrawviews); }

   protected:

      bool m_IsModified;                     

      explicit VIEWABLE (
         OBJECT::TYPE type,               
         VIEWABLE *container              
         );

      // Initialize 'control script' if exists and is allowed.
      ERRVALUE ControlScriptInitialize (
         );

      UINT8 GetIniIndex (
         ) const { return (m_IniIndex); }

      static const SERIALIZERITEM* SerialGetItemDef (
         SERIALIZER&
         ) { return (TemplateGetItemDef()); }

      void SetIniIndex (
         UINT8 IniIndex
         );

      static const SERIALIZERITEM* TemplateGetItemDef (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      VIEWABLE *m_Container;                 // Container viewable, 0 if at top
      char m_IniName[20];                    // Name of object for use in Ini file access
      UINT8 m_IniIndex;                      // Unique index of object for use in Ini file access
      UINT8 m_IniBaseLen;                    // Length of base name not including appended index number
      RVC::OBJITEM m_SaveObjItem;            // Object item where saved
      GRE::HIGHLIGHTMODE m_ElemHighlightMode;
   #ifdef USE_MGUI
      MAINSCRIPT m_CtrlScript;
      GRE::CTRL_TREEVIEW *m_pTreeView;
      GRE::TOOLSCRIPTLIST *m_pToolScriptList;      // ToolScripts saved with this object
      GRE::MACROSCRIPTLIST *m_pMacroScriptList;    // MacroScripts saved with this object
   #endif

   #ifdef USE_MGUI
      static ERRVALUE SerialCB_MacroScript (SERIALIZER&, const SERIALIZERITEM*, VIEWABLE *viewable, SERIALIZERITEM::ACTION);
      static ERRVALUE SerialCB_ToolScript (SERIALIZER&, const SERIALIZERITEM*, VIEWABLE *viewable, SERIALIZERITEM::ACTION);
   #endif

      // VIEWABLE overridables.
      virtual void v_Clear () = 0;
      virtual ERRVALUE v_DrawAllViews (GRE::DRAWCONDITION condition) = 0;
      virtual GRE::LAYER* v_GetActiveLayer () const = 0;
      virtual double v_GetDesignScale () const = 0;
      virtual const DRECT2D& v_GetExtents () const = 0;
      virtual double v_GetMaxScaleVisibleAny () const = 0;
      virtual double v_GetMinScaleVisibleAny () const = 0;
      virtual void v_SetDesignScale (double DesignScale, bool notify) = 0;
      virtual void v_UnhighlightAllElements (bool redraw) = 0;

      VIEWABLE (const VIEWABLE&);
      VIEWABLE& operator= (const VIEWABLE&);

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

//===================================================================================================================

int DlgEditScaleRanges (
   MDLGPARENT dlgparent,         
   VIEWABLE *viewable            
   );

ERRVALUE DlgRenderToRaster (
   MDLGPARENT dlgparent,         
   VIEWABLE *viewable            
   );

ERRVALUE DlgRenderToKML (
   MDLGPARENT dlgparent,         
   VIEWABLE *viewable            
   );

ERRVALUE DlgRenderToPDF (
   MDLGPARENT dlgparent,         
   VIEWABLE *viewable            
   );

ERRVALUE DlgRenderToSVG (
   MDLGPARENT dlgparent,         
   VIEWABLE *viewable            
   );

ERRVALUE DlgRenderToTileset (
   MDLGPARENT dlgparent,         
   VIEWABLE *viewable            
   );

//===================================================================================================================

}  // End namespace GRE


#endif   // INC_GRE_VIEWABLE_H

---