gre/view.h

Go to the documentation of this file.

#ifndef  INC_GRE_VIEW_H
#define  INC_GRE_VIEW_H

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

#ifndef  INC_GRE_VIEWPOS_H
   #include <gre/viewpos.h>
#endif

#ifndef  INC_GRE_GEOLOCK_H
   #include <gre/geolock.h>
#endif

#ifndef  INC_MI32_STEREOVIEW_H
   #include <mi32/stereoview.h>
#endif

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

#ifndef  INC_MI32_LATLONFM_H
   #include <mi32/latlonfm.h>
#endif

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

#ifndef  INC_MI32_CRITSEC_H
   #include <mi32/critsec.h>
#endif

#ifndef  INC_MI32_MITHREAD_H
   #include <mi32/mithread.h>
#endif

#if !defined(INC_MGUI_TIMER_H) && defined(USE_MGUI)
   #include <mgui/timer.h>
#endif

#ifndef INC_MAP
#define INC_MAP
#include <map>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT

namespace RVC {
   class ELEMENT;
   }

namespace GRE {
   class DLG_VIEWZOOM;
   class VIEW_LEGACY_STATUSINFO;
   class VIEWCOMMON;
   }

namespace MGD {
   class DEVICE;
   class DEVICE_MEM32RGBA;
   class CONTEXT;
   }

namespace MGUI {
   class CTRL_TOOLTIP;
   }

namespace SPATMOD {
   namespace IMAGE {
      class STAGE_ARRAY;
      }
   }

namespace SML {
   union ARG;
   class FLAG;
   class CLASSMEMBER;
   class CONTEXT;
   }

class UNSIGNEDSET;
class REGION2D;
class RENDERBUFFER;
class STEREODEVICE;
class STEREORENDER;
class MISTATUSMANAGER;
class MISTATUSCONTEXT;
class VIEW_LEGACY_DATATIP;
class ZVIEW;

#endif


enum GRE_PROJACCUR {
   GRE_PROJACCUR_Exact =   2,       
   GRE_PROJACCUR_Auto =    3,       
   };

enum VIEWFLAGS {
   VIEWFLAG_None =                  0,
   VIEWFLAG_Locator =               0x00000001, 
   VIEWFLAG_3D =                    0x00000002, 
   VIEWFLAG_AllowDiffZoom =         0x00000010, 
   VIEWFLAG_Hardcopy =              0x00000020, 
   VIEWFLAG_NoDrawLayers =          0x00000080, 
   VIEWFLAG_NoDestroyShell =        0x00000100, 
   VIEWFLAG_DialogModal =           0x00000400, 
   VIEWFLAG_AllowGeoLock =          0x00000800, 
   VIEWFLAG_NoCloseOption =         0x00001000, 
   VIEWFLAG_DestroyOnClose =        0x00002000, 
   VIEWFLAG_NoSetPixmapBG =         0x00004000, 
   VIEWFLAG_NoSetPrevViewPos =      0x00008000, 
   VIEWFLAG_DisableDataTips =       0x00010000, 
   VIEWFLAG_NoRenderSeparate =      0x00020000, 
   VIEWFLAG_AutoPanGPS =            0x00040000, 
   VIEWFLAG_NoBlankScreen =         0x00080000, 
   VIEWFLAG_NoEditColorHighlight =  0x00100000, 
   VIEWFLAG_NoFillBackground =      0x00200000, 
   VIEWFLAG_AllowPanOffEdge =       0x00400000, 
   VIEWFLAG_NoShowTrackingCursor =  0x00800000, 
   VIEWFLAG_AlwaysTestCancel =      0x02000000, 
   VIEWFLAG_NoDrawOtherViews =      0x04000000, 
   VIEWFLAG_NoShowInLocator =       0x08000000, 

   VIEWFLAG_SaveMask =              (VIEWFLAG_AllowDiffZoom)
   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(VIEWFLAGS);
#endif

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

class VIEW : public GRE::OBJECT {

   public:

      enum CREATEFLAGS {
         CREATEFLAG_None =                   0x00000000,
         CREATEFLAG_3D =                     0x00000001, 
         CREATEFLAG_NoCallCreateCB =         0x00000002, 
         CREATEFLAG_NoRenderSeparate =       0x00000004, 
         CREATEFLAG_Hardcopy =               0x00000008, 
         CREATEFLAG_DisableDraw =            0x00000010, 
         CREATEFLAG_Locator =                0x00000020, 
         };

      enum COLORUSE {
         COLORUSE_Background,
         COLORUSE_HighlightElem,
         COLORUSE_ActiveElem,
         COLORUSE_DataTipElem,
         COLORUSE_COUNT
         };

      enum DATATIPSELECTION {
         DATATIPSELECTION_FromView =         0, 
         DATATIPSELECTION_None =             1, 
         DATATIPSELECTION_ActiveLayer =      2, 
         DATATIPSELECTION_AllLayers =        3, 
         DATATIPSELECTION_AllVisible =       4, 
         DATATIPSELECTION_AutoScale =        5, 
         DATATIPSELECTION_ObjectNames =      6, 
         DATATIPSELECTION_ReverseGeocode =   7, 
         };

      typedef fastdelegate::FastDelegate<void(VIEW*)> DELEGATE_POINTERENTERLEAVE;

      typedef fastdelegate::FastDelegate<void(VIEW*, const DPOINT2D&)> DELEGATE_POINTERMOVE;

   #ifdef USE_MGUI
      static void CursorTrackRestoreAll ();
   #endif

   #ifdef USE_MGUI
      static void CursorTrackSetPosAll (
         const DPOINT2D& pt,
         const SPATREF::COORDREFSYS& crs,
         const GRE::VIEW *viewskip = 0    
         );
   #endif

      static bool DlgEditGlobalSettings (
         MDLGPARENT dlgparent                   
         );

      static VIEW* FindNextOfGroup (
         const GRE::GROUP *group,         
         VIEW *view = 0                   
         );

      static VIEW* FindNextOfLayer (
         const GRE::LAYER *layer,         
         VIEW *view = 0                   
         );

      static void GetDftColor (
         COLORUSE coloruse,               
         COLOR& color                     
         );

      static const VIEWCOMMON& GetGlobalOptions (
         ) { return (GetGlobalOptionsPriv()); }
      
      static const STEREODEVICE& GetStereoDeviceShared2D (
         ) { return (GetStereoDevicePriv2D()); }

      static const STEREODEVICE& GetStereoDeviceShared3D (
         ) { return (GetStereoDevicePriv3D()); }

      static bool GetUpdateAfterDrawLayer (
         );

      static bool GetZoomPanWaitForRMB (
         );

      static void SetGlobalOptions (
         const VIEWCOMMON& options           
         );

      static void SetStereoDeviceShared2D (
         const STEREODEVICE& StereoDevice
         );

      static void SetStereoDeviceShared3D (
         const STEREODEVICE& StereoDevice
         );

      static void SetTrackCursor (
         bool TrackCursor
         );

      static void SetUpdateAfterDrawLayer (
         bool UpdateAfterDrawLayer
         );

      // Install SML class, called by internal SML function.
      static void SML_ClassInstall (
         SML::CONTEXT *context
         );

      VIEW ();

      virtual ~VIEW ();

      void AddDelegateOnPointerEnter (
         DELEGATE_POINTERENTERLEAVE delegate    
         );

      void AddDelegateOnPointerLeave (
         DELEGATE_POINTERENTERLEAVE delegate    
         );

      void AddDelegateOnPointerMove (
         DELEGATE_POINTERMOVE delegate    
         );

      void AttachGroupView (
         GRE::GROUPVIEW *groupview
         );

      void AttachLayerView (
         GRE::LAYERVIEW *layerview
         );

      void CancelDrawing (
         ERRVALUE err = EUserCancel                
         );

      void ClearMessage ();

      bool ContainsLayer (
         const GRE::LAYER *layer                
         ) const;

      double ConvertScreenUnits (
         GRE::LAYER *layer,                     
         double value,                          
         int iunits,                            
         int ounits                             
         );

      ERRVALUE Create (
         VIEWABLE *viewable,
         int iwidth,
         int iheight,
         CREATEFLAGS createflags = CREATEFLAG_None
         );

      DATATIPSELECTION DataTipGetSelection (
         ) const { return (m_DataTipSelection); }

      ERRVALUE DataTipGetString (
         const DPOINT2D& point,                 
         MISTRING& string,                      
         SPATMOD::IMAGE::STAGE_ARRAY& images,   
         FINDFLAGS findflags,                   
         int maxlines = 0,                      
         DATATIPSELECTION selection = DATATIPSELECTION_FromView,
         bool bForceHTML = false,               
         MGUI::CTRL_TOOLTIP* tooltip = 0        
         );

      void DataTipSetDelay (
         INT32 delay                            
         ) { v_DataTipSetDelay(delay); }

      void DataTipSetPixelDelta (
         int PixelDelta                         
         ) { v_DataTipSetPixelDelta(PixelDelta); }

      void DataTipSetSelection (
         DATATIPSELECTION selection             
         ) { m_DataTipSelection = selection; }

      void DestroyGroupView (
         GRE::GROUP *group
         );

      void DestroyLayerView (
         GRE::LAYER *layer
         );

      void Detach (
         ) { m_viewable = 0; }

      void DetachGroupView (
         GRE::GROUPVIEW *groupview
         );

      void DetachLayerView (
         GRE::LAYERVIEW *layerview
         );

      void DisableRedraw (
         ) { ++m_DisableRedraw; }

      ERRVALUE Draw (
         );

      ERRVALUE DrawGroup (
         GRE::GROUP *group,                        
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      int DrawIfNeeded (
         );

      ERRVALUE DrawIfAutoUpdate (
         ) { if (m_RedrawOnAnyChange) return (Draw()); return (0); }

      ERRVALUE DrawLayer (
         GRE::LAYER *layer,                        
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      ERRVALUE DrawLayerElement (
         GRE::LAYER *layer,                        
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                          
         GRE::RENDERTARGET Target,              
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      ERRVALUE DrawLayerElements (
         GRE::LAYER *layer,                     
         ELEMTYPE ElemType,                     
         const UNSIGNEDSET *pElemSet,           
         GRE::RENDERTARGET Target,              
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      ERRVALUE DrawLayerHighlighted (
         GRE::LAYER *layer,                        
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      void DrawMargins (
         MGD::CONTEXT* gc,                      
         const TRANS2D_AFFINE *pTransViewDevice = 0
         );

      ERRVALUE DrawLayerOverlay (
         GRE::LAYER *layer,                        
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      ERRVALUE DrawThisOnly (
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      int EditColors (
         );

      void EnableRedraw (
         ) { if (m_DisableRedraw > 0) --m_DisableRedraw; }

      ELEMNUM FindClosestLayerElement (
         GRE::LAYER *layer,                        
         int component,                         
         const DPOINT2D& point,                 
         double *distret,                       
         GRE::FINDFLAGS findflags               
         );

      GRE::GROUP* FindPointGroup (
         const DPOINT2D& point,                 
         GRE::FINDFLAGS findflags,              
         const SPATREF::COORDREFSYS *pPointCRS = NULL    
         ) const;

      bool GetAutoRedrawSolid (
         ) const { return (m_AutoRedrawSolid); }

      const char* GetBackgroundColorIniName (
         ) const;

      const LRECT2D& GetCanvasClipRect (
         ) const { return (m_ClipRect); }

      void GetCanvasExtentsUsed (
         LRECT2D& extents,                      
         bool UseNext = false                   
         ) const;

      bool GetClipRegion (
         GRE::GROUP *group,                        
         REGION2D& ClipRegion                   
         );

      const COLOR& GetColor (
         COLORUSE coloruse                      
         ) const { return (m_Colors[coloruse]); }

   #ifdef USE_MGUI
      MDLGPARENT GetDlgParent (
         ) const { return (v_GetDlgParent()); }
   #endif

      UINT32 GetDrawingAreaHeight (
         ) const { return (m_height); }

      UINT32 GetDrawingAreaWidth (
         ) const { return (m_width); }

      MGD::DEVICE* GetDrawingDevice (
         bool UseStereo = false                 
         ) const;

      MGD::DEVICE* GetDrawingDeviceMemory (
         bool UseStereo = false                 
         ) const;

      MGD::DEVICE* GetDrawingDeviceScreen (
         ) const { return (v_GetDrawingDeviceScreen()); }

      bool GetDrawStereo (
         ) const { return (m_DrawStereo); }

      bool GetDrawWireframe3D (
         ) const { return (m_DrawWireframe); }

      const DRECT2D& GetFullExtents (
         ) const { return (m_FullExtents); }

      const GEOLOCKSETTINGS& GetGeoLock (
         ) const { return (m_GeoLock); }

      GRE::GROUP* GetGeorefGroup (
         ) const;

      GRE::GROUP* GetGroup (
         ) const;

      GRE::GROUPVIEW* GetGroupView (
         const GRE::GROUP *group
         ) const;

      const VIEWPOS& GetLastPosn (
         ) const { return (m_LastPosn); }
   
      GRE::LAYERVIEW* GetLayerView (
         const GRE::LAYER *layer
         ) const;

      GRE::LAYOUT* GetLayout (
         ) const;

      double GetMargin (
         ) const { return (m_MarginMeters); }

      const MISTRING& GetMessage (
         ) const { return (m_LastMessage); }

      void GetName (
         MISTRING& name                         
         ) const;

      bool GetNeedNotifyDrawElement () const
         { return (m_NeedNotifyDrawElement); }

      bool GetNeedsRedraw (
         ) const { return (m_NeedsRedraw); }

      VIEW* GetNext (
         ) const;

      VIEW* GetNextOfAll (
         ) const { return (m_nextview); }

      const VIEWPOS& GetNextPosn (
         ) const { return (m_NextPosn); }

      INT16 GetPadPixels (
         ) const { return (m_PadPixels); }

      double GetPixelSizeMM (
         ) const;

      void GetPixelSizeMM (
         DPOINT2D& pixelsize
         ) const;

      GRE_PROJACCUR GetProjAccur (
         ) const { return (m_ProjAccur); }

      bool GetRedrawOnAnyChange (
         ) { return (m_RedrawOnAnyChange); }

      ERRVALUE GetScale (
         double *xscale,                        
         double *yscale                         
         );

      double GetScale (
         ) const { return (m_LastPosn.GetMapScale()); }

      ERRVALUE GetSizeMeters (
         DPOINT2D& size                         
         ) const;

      MISTATUSMANAGER* GetStatusManager (
         ) const { return (m_pStatusMgr); }

      const STEREODEVICE& GetStereoDevice () const;

      const STEREORENDER& GetStereoRender () const;

      bool GetStopDrawOnError (
         ) const { return (m_StopDrawOnError); }

      double GetTimeLastRefresh (
         ) const { return (m_TimeLastRefresh); }

      void GetTransDispToGroup (
         const GRE::GROUP *group,                  
         TRANS2D_AFFINE& DispToGroup            
         ) const;

      int GetTransLayerDisp (
         const GRE::LAYER *layer,                  
         TRANS2D_MAPGEN& trans                  
         ) const;

      ERRVALUE GetTransLayerView (
         const GRE::LAYER *layer,                  
         TRANS2D_MAPGEN& trans                  
         ) const;

      ERRVALUE GetTransToMap (
         TRANS2D_MAPGEN& trans,                 
         bool dooutput,                         
         const GRE::GROUP *group = 0               
         ) const;

      const TRANS2D_AFFINE& GetTransToDisp (
         ) const { return (m_LastPosn.GetTransViewDevice()); }

      VIEWABLE* GetViewable (
         ) const { return (m_viewable); }

      OBJECT::TYPE GetViewableType (
         ) const;

      VIEWFLAGS GetViewFlags (
         ) const { return (m_viewflags); }

      int GetViewNum (
         ) const;

      VIEWPOINT3D* GetViewPoint3D (
         ) const { return (m_ViewPoint3D); }

      void GetVisibleExtents (
         DRECT2D& extents,                      
         bool UseNext = false                   
         ) const;

      bool GetWireframeMode (
         ) const;

      const double& GetZoom (
         ) const { return (m_NextPosn.GetZoom().x); }

      const ZVIEW* GetZView () const;

      bool Has3D () const;

      bool HasObjects () const;

      bool HighlightElementsByPoint (
         const DPOINT2D& pt,                    
         bool PointInDisplayCoords,             
         GRE::HIGHLIGHTMODE HighlightMode = GRE::HIGHLIGHTMODE_NotSet,  
         bool ShowDftTables = false             
         );

      void InvalidateAllLayers (
         );

      bool Is3D (
         ) const;

      bool IsAllowedDiffZoom (
         ) const { return ((m_viewflags & VIEWFLAG_AllowDiffZoom) != 0); }

      bool IsBeingDrawn (
         ) const { return (m_DoingRedraw); }

      bool IsBeingRestored (
         ) const { return (m_DoingRestore); }

      bool IsGeoLocked (
         ) const { return (m_GeoLocked); }

      bool IsGoogleLocked (
         ) const { return (m_GoogleLocked); }

      bool IsGroupVisible (
         const GRE::GROUP *group
         ) const;

      bool IsInteractive (
         ) const { return (m_IsInteractive); }

      bool IsLayerVisible (
         const GRE::LAYER *layer                
         ) const;

      bool IsLegacy (
         ) const { return (m_IsLegacy); }

      bool IsLocator (
         ) const { return ((m_viewflags & VIEWFLAG_Locator) != 0); }

      bool IsRedrawDisabled (
         ) const { return (m_DisableRedraw != 0); }

      void NotifyChangeViewPoint3D (
         bool redraw = true,
         bool IsDragging = false
         );

      void NotifyDrawElementBegin (
         GRE::LAYER *layer,
         const RVC::ELEMENT& element
         ) { v_OnDrawElementBegin(layer,element); }

      void NotifyDrawElementEnd (
         GRE::LAYER *layer,
         const RVC::ELEMENT& element
         ) { v_OnDrawElementEnd(layer,element); }

      void NotifyExposure (
         const LRECT2D& rect                    
         );

      void NotifyLayerRendered (
         GRE::LAYER *layer
         );

      void NotifyPointerEnter (
         );

      void NotifyPointerLeave (
         );

      void NotifyPointerMove (
         const DPOINT2D& point                  
         );

      RENDERBUFFER* OverlayCreate (
         bool AddToFront = false                
         );

      void OverlayDestroy (
         RENDERBUFFER *& pRenderBuffer          
         );

      ERRVALUE PanToLayerElement (
         GRE::LAYER *layer,                        
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                          
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      void ResetCancel (
         ) { m_CancelDraw = 0; }

      void RemoveDelegateOnPointerEnter (
         DELEGATE_POINTERENTERLEAVE delegate    
         );

      void RemoveDelegateOnPointerLeave (
         DELEGATE_POINTERENTERLEAVE delegate    
         );

      void RemoveDelegateOnPointerMove (
         DELEGATE_POINTERMOVE delegate    
         );

      void RestoreFromBuffers (
         bool RenderIfNeeded = true
         );

      void RestoreFromMemory (
         const LRECT2D *rect = 0,               
         bool UseScreenBuffer = false           
         );

   #ifdef USE_MGUI
      ERRVALUE SaveSnapshotQuick (
         );
   #endif

   #ifdef USE_MGUI
      ERRVALUE SaveSnapshotToRaster (
         );
   #endif

      void SetAutoRedrawSolid (
         bool AutoRedrawSolid
         ) { m_AutoRedrawSolid = AutoRedrawSolid; }

      void SetBeingRestored (
         bool BeingRestored
         ) { m_DoingRestore = BeingRestored; }

      int SetCenter (
         const DPOINT2D& pt,                    
         bool redraw = true                     
         );

      void SetCenterByLayer (
         GRE::LAYER *layer,                        
         const DPOINT2D& pt,                    
         bool redraw = true                     
         );

      void SetClipNone (
         );

      void SetClipRect (
         const LRECT2D& cliprect                
         );

      void SetColor (
         COLORUSE coloruse,                     
         const COLOR& color                     
         );

      void SetDrawingAreaSize (
         INT32 width,
         INT32 height
         );

      void SetDrawingDevice (
         MGD::DEVICE *gdisp
         );

      void SetDrawStereo (
         bool DrawStereo
         );

      void SetDrawWireframe3D (
         bool DrawWireframe
         ) { m_DrawWireframe = DrawWireframe; }

      void SetGeoLocked (
         bool GeoLocked = true,
         bool AutoScale = true
         );

      void SetGeoLock (
         const GEOLOCKSETTINGS& GeoLockSettings
         ) { m_GeoLock = GeoLockSettings; }

      void SetGoogleLocked (
         bool Locked
         ) { m_GoogleLocked = Locked; }

      void SetMargin (
         double MarginMeters
         ) { m_MarginMeters = MarginMeters; m_NeedsRedraw = true; }

      void SetNeedNotifyDrawElement (
         bool NeedNotify = true
         ) { m_NeedNotifyDrawElement = NeedNotify; }

      void SetNeedsRedraw (
         ) { m_NeedsRedraw = true; }

      void SetNextPlace (
         const VIEWPLACE& NextPlace,
         bool redraw = true
         );

      void SetNextPosn (
         const VIEWPOS& NextPosn,
         bool redraw = true
         ) { m_NextPosn = NextPosn; m_NeedsRedraw = true; if (redraw) Draw(); }

      void SetPadPixels (
         int pp
         ) { m_PadPixels = static_cast<INT16>(bound(pp,0,100)); }

      void SetProjAccur (
         GRE_PROJACCUR ProjAccur
         ) { m_ProjAccur = ProjAccur; }

      void SetRedrawOnAnyChange (
         bool RedrawOnAnyChange,
         bool redraw = true                  
         );

      ERRVALUE SetScale (
         double NewMapScale,
         bool redraw = true
         );

      ERRVALUE SetScaleMaxDetail (
         GRE::LAYER *ScaleRefLayer,
         bool redraw = true
         );

      ERRVALUE SetScaleMaxDetail (
         bool redraw = true
         ) { return (SetScaleMaxDetail(NULL,redraw)); }

      void SetStatusManager (
         MISTATUSMANAGER *pStatusMgr
         ) { m_pStatusMgr = pStatusMgr; }

      void SetStereoDevice (
         const STEREODEVICE& StereoDevice
         );

      void SetStereoRender (
         const STEREORENDER& StereoRender
         );

      void SetStopDrawOnError (
         bool StopDrawOnError = true            
         ) { m_StopDrawOnError = StopDrawOnError; }
   
      void SetViewFlags (
         VIEWFLAGS viewflags,
         bool redraw = false
         ) { m_viewflags = viewflags; if (redraw) Draw(); }

      bool SetViewFromGeoLock (
         const VIEW *refview=0               
         );

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

      void SetWireframeMode (
         bool mode,
         bool redraw = true                     
         );

      int SetZoom (
         double zoom,                           
         bool redraw = true                     
         );

      int SetZoom (
         const DPOINT2D& zoom,
         bool redraw = true                     
         );

      int SetZoomFull (
         bool redraw = true                     
         ) { return (SetZoom(.99,redraw)); }

      int TestCancel (
         ) { return (v_TestCancel()); }

      ERRVALUE TransDispToGroup (
         GRE::GROUP *group,                        
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         ) const;

      ERRVALUE TransDispToLayer (
         GRE::LAYER *layer,                        
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         );

      void TransDispToView (
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         ) const;

      ERRVALUE TransGroupToDisp (
         GRE::GROUP *group,                        
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         ) const;

      ERRVALUE TransGroupToView (
         GRE::GROUP *group,                        
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         ) const;

      ERRVALUE TransLayerToDisp (
         GRE::LAYER *layer,
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         );

      ERRVALUE TransLayerToView (
         GRE::LAYER *layer,
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         );

      void TransViewToDisp (
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         ) const;

      ERRVALUE TransViewToGroup (
         GRE::GROUP *group,                        
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         ) const;

      ERRVALUE TransViewToLayer (
         GRE::LAYER *layer,
         const DPOINT2D *ipoints,               
         DPOINT2D *opoints,                     
         int numpoints                          
         );

   #ifdef USE_MGUI
      GRE::CTRL_TREEVIEW* TreeViewGetPtr (
         ) const { return (m_pTreeView); }
   #endif

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

      ERRVALUE UpdateExtents (
         );

      void UpdateLastPosn (
         );

      void UpdateMessage (
         const MISTRING& string
         );

      int UpdatePosition (
         );

      void UpdateScriptUI (
         ) { v_UpdateScriptUI(); }

      void UpdateTypeName (
         );

      void UpdateUI (
         ) { v_UpdateUI(); }

      bool UseSeparateRenderDevices (
         );

      int ZoomToGroup (
         GRE::GROUP *group,
         bool redraw = true
         );

      int ZoomToGroupRect (
         GRE::GROUP *group,
         const DRECT2D& rect,
         bool redraw = true
         );

      int ZoomToLayer (
         GRE::LAYER *layer,
         bool redraw = true
         );

      int ZoomToLayerRect (
         GRE::LAYER *layer,
         const DRECT2D& rect,
         bool redraw = true
         );

      ERRVALUE ZoomToViewableRect (
         const DRECT2D& rect,                
         bool redraw = true                  
         );

   protected:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      // SML interface methods.
      static const SML::CLASSMEMBER* SML_GetClassMembers();
      static void SML_ViewDestroy (int, SML::ARG *args, UINT8 *, SML::CONTEXT *);
      #endif

      typedef void DRAWSTATE;

      void ClearNeedsRedraw (
         ) { m_NeedsRedraw = false; }

      void DrawBackground ();

      DRAWSTATE* DrawBegin (
         GRE::DRAWFLAGS drawflags
         );

      void DrawEnd (
         GRE::DRAWFLAGS drawflags,     
         DRAWSTATE *state                 
         );

      ERRVALUE DrawViewable (
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

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

      void OverlayUpdatedLayers ();

      void SetViewPosns (
         const VIEWPOS& ViewPos
         );

      void SetInteractive (
         ) { m_IsInteractive = true; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      typedef GRE::VIEW THISCLASS;
      typedef std::map<GRE::GROUP*,GRE::GROUPVIEW*> GROUPVIEWMAP;
      typedef std::map<GRE::LAYER*,GRE::LAYERVIEW*> LAYERVIEWMAP;

      VIEWABLE *m_viewable;                  // Object being viewed
      VIEW *m_nextview;                      // Pointer to "next" view if multiple views are in use
      MGD::DEVICE *m_gdisp;                  // Generic display handle for drawing
      VIEWFLAGS m_viewflags;
      COLOR m_Colors[COLORUSE_COUNT];
      VIEWPOS m_LastPosn;                    // Position as of last redraw
      VIEWPOS m_NextPosn;                    // Position which will be used for next redraw
      DRECT2D m_FullExtents;                 // Overall extents of VIEWABLE in "view coordinates"
      MISTATUSMANAGER *m_pStatusMgr;
      VIEWPOINT3D *m_ViewPoint3D;            // 3-D viewpoint if viewing single 3-D group
      int m_ViewNum;                         // View number for window title
      int m_CancelDraw;                      // Set by TestCancel to reason redraw was cancelled (usually EUserCancel)
      WPOINT2D m_TrackPos;                   // Position for cursor when tracking from other views
      GRE_PROJACCUR m_ProjAccur;             // Projection accuracy
      INT32 m_width;                         // Width of drawing area in pixels
      INT32 m_height;                        // Height of drawing area in pixels
      INT16 m_PadPixels;
      UINT8 m_DisableRedraw;                 // If > 0 redraws for exposures are disabled
      char m_TypeNameStr[32];
      GEOLOCKSETTINGS m_GeoLock;
      LRECT2D m_ClipRect;                    // Clipping rectangle in display coordinates
   #ifdef USE_MGUI
      void *XXXdelete_m_pDlgViewStereo2D;
      GRE::DLG_VIEWZOOM *m_pDlgViewZoom;
      GRE::CTRL_TREEVIEW *m_pTreeView;
      MGUI::TIMER m_TimerOverlayUpdate;
   #endif
      DATATIPSELECTION m_DataTipSelection;
      GROUPVIEWMAP m_GroupViewMap;
      LAYERVIEWMAP m_LayerViewMap;
      MGD::DEVICE_MEM32RGBA *m_pDeviceWork;  // Device for rendering to before copying to renderbuffer
      MISTRING m_LastMessage;                // Last message string
      double m_TimeLastRefresh;
      double m_MarginMeters;                 // Maximum margin in meters between view extents and viewable extents.
      STEREODEVICE *m_pStereoDevice;
      mutable STEREORENDER *m_pStereoRender;
      bool m_NeedsRedraw;                    // Flag, set if must redraw all on next expose event
      bool m_DoingRedraw;                    // Set while redraw is being performed
      bool m_AutoRedrawSolid;                // (3D) Auto-redraw in solid-rendering mode
      bool m_DoingRestore;                   // Set while in Restore to prevent looping
      bool m_DrawWireframe;
      bool m_DrawStereo;                     // Draw layers in stereo if supported
      bool m_HaveTrackPos;
      bool m_GeoLocked;
      bool m_IsInteractive;                  // View is being directly interacted with by user
      bool m_ClipRectUsed;                   // Set if clipping rectangle used
      bool m_StopDrawOnError;                // Stop drawing if error occurs
      bool m_CanRestore;                     // Set during drawing if has something to restore
      bool m_RedrawOnAnyChange;              // Redraw view on any change
      bool m_IsLegacy;
      bool m_GoogleLocked;
      bool m_NeedNotifyDrawElement;
      MILIST<DELEGATE_POINTERENTERLEAVE> m_DelegateListOnPointerEnter;
      MILIST<DELEGATE_POINTERENTERLEAVE> m_DelegateListOnPointerLeave;
      MILIST<DELEGATE_POINTERMOVE> m_DelegateListOnPointerMove;
      MITHREAD::QUEUE *m_pThreadQueueRemote;
      MITHREAD::ID m_ThreadQueueIdRemote;
      MITHREAD::CRITICALSECTION m_CritSec;

      static VIEWCOMMON& GetGlobalOptionsPriv ();
      static STEREODEVICE& GetStereoDevicePriv2D ();
      static STEREODEVICE& GetStereoDevicePriv3D ();
         
      static void InitStatic ();

      void AddThreadQueueToPoolRemote ();
      bool CheckRenderBuffersValid ();
      bool CheckRenderBuffersValidGroup (GRE::GROUP *group);
      void ComputeAllGroupLayerTrans ();
   #ifdef USE_MGUI
      void CursorTrackDraw ();
      void CursorTrackRestore ();
      void CursorTrackSetPos (const DPOINT2D& pt);
   #endif

      int DrawLayer2D (                      
         GRE::LAYER *layer,                        
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      int DrawGroup2D (
         GRE::GROUP *group,
         GRE::DRAWFLAGS drawflags
         );

      int DrawGroup3D (
         GRE::GROUP *group,
         GRE::DRAWFLAGS drawflags
         );

      int DrawGroup3DI (
         GRE::GROUP *group,
         GRE::DRAWFLAGS drawflags,
         MGD::DEVICE *pDevice,
         STEREOVIEW StereoView = STEREOVIEW_None,
         LRECT2D *DevRect = 0
         );

      ERRVALUE DrawGroupBegin (
         GRE::GROUP *group,
         GRE::DRAWFLAGS drawflags
         );

      ERRVALUE DrawGroupMain (
         GRE::GROUP *group,
         GRE::DRAWFLAGS drawflags
         );

      void DrawGroupMatte (
         GRE::GROUP *group,
         MGD::DEVICE *pDevice,
         const TRANS2D_AFFINE& TransViewDevice
         );

      void DrawGroupFromBuffers (
         GRE::GROUP *group
         );

      ERRVALUE DrawLayout (
         GRE::LAYOUT *layout,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      void DrawLayoutMatte (
         MGD::CONTEXT *gc,
         const TRANS2D_AFFINE& TransViewDevice
         );

      void DrawPageBackground (
         MGD::CONTEXT* gc,
         const TRANS2D_AFFINE& TransViewDevice
         );

      const MGD::DEVICE* GetFirstValidDevice (bool NullIfNone) const;

      MITHREAD::QUEUE& GetThreadQueueRemote ();

      bool HighlightElementsByPoint (
         GRE::GROUP *group,                     
         const DPOINT2D& pt,                    
         GRE::HIGHLIGHTMODE HighlightMode,      
         bool ShowDftTables                     
         );

      void OnThreadQueueDone (
         MITHREAD::ID QueueID
         );

      ERRVALUE SetupWorkDevice ();

      void StartQueuedJobsRemote ();

      void UpdateLayerColors (
         GRE::LAYER *layer
         );

      VIEW (const VIEW&);
      VIEW& operator= (const VIEW&);

      friend class TOOL;

      // GRE::OBJECT overrides.
      virtual bool v_Destroy (bool NotifyParent);
      virtual MICONSTRUCT* v_GetIcon () const;
      virtual const char* v_GetTypeName () const;

      #endif // GENERATING_DOXYGEN_OUTPUT

      // VIEW overridables.

      virtual void v_CreateFinish ();

      virtual void v_DataTipSetDelay (
         INT32 delay                            
         );

      virtual void v_DataTipSetPixelDelta (
         int PixelDelta                         
         );

      virtual ERRVALUE v_Draw ();

      virtual ERRVALUE v_DrawThisOnly (GRE::DRAWFLAGS drawflags);

   #ifdef USE_MGUI
      virtual MDLGPARENT v_GetDlgParent (
         ) const;
   #endif

      virtual MGD::DEVICE* v_GetDrawingDeviceMemory (
         bool UseStereo                      
         ) const;

      virtual MGD::DEVICE* v_GetDrawingDeviceScreen (
         ) const;

      virtual int v_GetViewNum () const;

      virtual void v_OnDrawElementBegin (GRE::LAYER *layer, const RVC::ELEMENT& element);
      virtual void v_OnDrawElementEnd (GRE::LAYER *layer, const RVC::ELEMENT& element);
      virtual void v_OnDrawGroupBegin (GRE::GROUP *group);
      virtual void v_OnDrawGroupEnd (GRE::GROUP *group);
      virtual void v_OnDrawLayerBegin (GRE::LAYER *layer);
      virtual void v_OnDrawLayerEnd (GRE::LAYER *layer);
      virtual void v_OnDrawViewableBegin ();
      virtual void v_OnDrawViewableEnd ();
      virtual void v_OnJobStarted ();
      virtual void v_OnJobsAllDone ();
      virtual void v_OnLayerRendered (GRE::LAYER *layer);

      virtual void v_RestoreFromMemory (
         const LRECT2D *rect,                   
         bool UseScreenBuffer = false           
         );

      virtual ERRVALUE v_TestCancel ();

      virtual void v_UpdateMessage (
         const MISTRING& string
         );

      virtual void v_UpdateScriptUI ();

      virtual void v_UpdateUI ();

      friend class VIEW_LEGACY;
      friend class VIEW_LEGACY_DATATIP;
      friend class GRE::VIEW_LEGACY_STATUSINFO;
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(VIEW::CREATEFLAGS)
#endif

}  // End namespace GRE

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

#endif   // INC_GRE_VIEW_H

---