gre/group.h

Go to the documentation of this file.

#ifndef  INC_GRE_GROUP_H
#define  INC_GRE_GROUP_H

#ifndef  INC_GRE_VIEWABLE_H
   #include <gre/viewable.h>
#endif

#ifndef  INC_GRE_LAYER_H
   #include <gre/layer.h>
#endif

#ifndef  INC_MI32_TRANS2DAFFINE_H
   #include <mi32/trans2daffine.h>
#endif

#ifndef  INC_MI32_MATTE_H
   #include <mi32/matte.h>
#endif

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

#define  GROUPFLAG_None                   0x00000000
#define  GROUPFLAG_Ignore                 0x00000001  
#define  GROUPFLAG_NoFixAspectLL          0x00000002  
#define  GROUPFLAG_SingleLayer            0x00000004  
#define  GROUPFLAG_Clip                   0x00000008  
#define  GROUPFLAG_OrientMatchRasterOnly  0x00000010  
#define  GROUPFLAG_OrientMatchRasterOther 0x00000020  
#define  GROUPFLAG_OrientMatchLayer       0x00000040  
#define  GROUPFLAG_NoSave                 0x00000080  
#define  GROUPFLAG_NoUserSettings         0x00000100  
#define  GROUPFLAG_3D                     0x00000200  
#define  GROUPFLAG_NoDeleteGroup          0x00000400  
#define  GROUPFLAG_NoDeleteLayers         0x00000800  
#define  GROUPFLAG_ShowLatLonCoords       0x00001000  
#define  GROUPFLAG_NoAddLayers            0x00002000  
#define  GROUPFLAG_NoLockZoom             0x00004000  
#define  GROUPFLAG_ShowLayerList          0x00008000  
#define  GROUPFLAG_NoClipToAttachedGroup  0x00010000  
#define  GROUPFLAG_CombineLayersInLegend  0x00020000  
#define  GROUPFLAG_TemplateSaveLayersAsIs 0x00040000  
#define  GROUPFLAG_NoClipToRectOnly       0x00080000  
#define  GROUPFLAG_NoLegacyRectExtents    0x00100000  
#define  GROUPFLAG_CreatedBySML           0x00200000  

#define  GROUPFLAG_Mask_Orient            (GROUPFLAG_OrientMatchRasterOnly | GROUPFLAG_OrientMatchRasterOther | GROUPFLAG_OrientMatchLayer)
#define  GROUPFLAG_Mask_NeedRedraw        (GROUPFLAG_Ignore | GROUPFLAG_NoFixAspectLL | GROUPFLAG_Clip | GROUPFLAG_OrientMask | GROUPFLAG_3D | GROUPFLAG_NoClipToAttachedGroup | GROUPFLAG_NoClipToRectOnly)
#define  GROUPFLAG_Mask_NoNotify          GROUPFLAG_TemplateSaveLayersAsIs

#define  GROUPFLAG_OrientMask             GROUPFLAG_Mask_Orient

#define  ATTACHMENT_None         0
#define  ATTACHMENT_Left         1
#define  ATTACHMENT_Bottom       1
#define  ATTACHMENT_Center       2
#define  ATTACHMENT_Right        3
#define  ATTACHMENT_Top          3
#define  ATTACHMENT_Geographic   4

#define  ATTACHREF_None          0
#define  ATTACHREF_Group         1
#define  ATTACHREF_Page          2
#define  ATTACHREF_Margin        3


class GROUP : public GRE::VIEWABLE, public SERIALIZABLE {

   public:

      enum CREATEFLAGS {
         CREATEFLAG_None =             0x0000,
         CREATEFLAG_NoCallCreateCB =   0x0001,  
         CREATEFLAG_Temporary =        0x0002,  
         CREATEFLAG_3D =               0x0004,  
         CREATEFLAG_NoAutoMatch =      0x0008,  
         CREATEFLAG_NoSetActive =      0x0010,  
         CREATEFLAG_DeferCreate =      0x0020,  
         CREATEFLAG_SML =              0x0040   
         };

      enum ORIENTATION_BASE {
         ORIENTATION_BASE_Projection =    0,
         ORIENTATION_BASE_North =         1
         };

      enum LABEL_MANAGEMENT_MODE {
         LABEL_MANAGEMENT_MODE_RenderWithLayer = 0,
         LABEL_MANAGEMENT_MODE_RenderLast
         };

      enum EXTENTCOORD {
         EXTENTCOORD_Group,
         EXTENTCOORD_Layout,
         EXTENTCOORD_View
         };

      struct POSN {
         GROUP *refgroup;
         UINT8 AttachRefType;                
         UINT8 AttachmentThis;               
         UINT8 AttachmentRef;                
         UINT8 PosnSet;
         double offset;                      
         mutable MISTRING m_RefGroupName;    
         POSN ();
         ~POSN ();
         void Clear ();
         };

   #ifdef X_NATIVE
      static GROUP* GetFromWidget (
         Widget w
         );
   #endif

      static void SMLClassInstall (
         SMLCONTEXT *context                    
         );

      explicit GROUP (
         CREATEFLAGS createflags = CREATEFLAG_None
         );

      GROUP (
         GRE::LAYOUT *layout,
         CREATEFLAGS createflags = CREATEFLAG_None,
         GRE::LISTPOS listpos = GRE::LISTPOS_Last,
         GROUP *refgroup = 0
         );

      virtual ~GROUP ();

      bool AdjLatLon (
         );

      bool AdjLatLonCanSet (
         );

      void AttachLayerCommonParm (
         LAYER::TYPE LayerType,
         GRE::LAYER::COMMONPARM *pParmInstance
         );

      bool ChangeListPos (
         GROUP* refgroup,
         GRE::LISTPOS listpos
         );

      ERRVALUE CheckAddLayer (
         GRE::LAYER::TYPE layertype = GRE::LAYER::TYPE_None
         ) const;

      void CheckGeorefCompatible (
         ) const;

      void ClearPosns (
         ) { m_xposn.Clear(); m_yposn.Clear(); }

      void ComputeLayoutExtents (
         );

      ERRVALUE ComputeMapExtents (
         ); 

      ERRVALUE ComputeRegionFromLayers (
         REGION2D& region,                   
         bool IncludeMargins,                
         GRE::LAYER::FILTER *filter = 0         
         ) const;

   #ifndef GENERATING_DOXYGEN_OUTPUT
      // Construct GROUPVIEW instance for this group and specified view.
      GRE::GROUPVIEW* ConstructGroupView (
         GRE::VIEW *view
         );
   #endif

      void Create (
         CREATEFLAGS createflags = CREATEFLAG_None
         );

      void DestroyAllLayers (
         );

      void DestroyLayer (
         GRE::LAYER* layer
         );

      ERRVALUE DrawActiveOverlay (
         GRE::DRAWFLAGS DrawFlags = GRE::DRAWFLAG_UpdateScreen,
         GRE::VIEW *view = 0                    
         );

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      ERRVALUE DlgGetClipSettings (
         MDLGPARENT dlgparent
         );
   #endif

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

      double GetAspectX (
         ) const { return (m_AspectX); }

      double GetAspectY (
         ) const { return (m_AspectY); }

      const REGION2D& GetClipRegion (
         ) const;

      bool GetClipToMatchedLayer (
         ) const { return (m_ClipToMatchedLayer); }

      ERRVALUE GetExtents (
         DRECT2D& extents,                      
         EXTENTCOORD coords                     
         );

      GRE::LAYER* GetFirstLayer (
         ) const { return (m_firstlayer); }

      UINT32 GetFlags (
         ) const { return (m_groupflags); }

      virtual void GetFullName (
         MISTRING& name                         
         ) const;

      const REGION2D& GetFullRegion (
         ) const { return (m_FullRegion); }

      LABEL_MANAGEMENT_MODE GetLabelManagementMode (
         ) const { return (m_LabelManagementMode); }

      GRE::LAYER* GetLastLayer (
         ) const { return (m_lastlayer); }

      const GRE::LAYER::COMMONPARM* GetLayerCommonParm (
         LAYER::TYPE LayerType
         ) const;

      GRE::LAYER::COMMONPARM* GetLayerCommonParm (
         LAYER::TYPE LayerType
         );

      GRE::LAYER* GetLayerActive (
         ) const { return (m_activelayer); }

      GRE::LAYER* GetLayerMatched (
         ) const { return (m_matchedlayer); }

      GRE::LAYER* GetLayerZoom1X (
         bool PreferredOnly                     
         ) const;

      GRE::LAYOUT * GetLayout (
         ) const { return (m_layout); }

      const DRECT2D& GetLayoutExtents (
         ) const { return (m_LayoutExtents); }

      int GetListPos (
         );

      GROUP* GetMatchedGroup (
         bool firstonly = false           
         ) const;

      MATTE& GetMatte (
         ) { return (m_Matte); }
      
      UINT32 GetMutualExclusiveGroupSet (
         ) const { return (m_MutualExclusiveGroupSet); }

      const MISTRING& GetName (
         ) const { return (m_name); }

      bool GetNeedUpdateExtents (
         ) const { return (m_NeedUpdateExtents); }

      GROUP* GetNext (
         ) const { return (m_nextgroup); }

      virtual UINT32 GetNextLayerID (
         ) const;

      const POSN& GetPosnX (
         ) const { return (m_xposn); }

      const POSN& GetPosnY (
         ) const { return (m_yposn); }

      GROUP* GetPrevious (
         ) const { return (m_prevgroup); }

      double GetRelativeScale (
         ) const { return (m_RelativeScale); }

      double GetRotationAngle (
         ) const { return (m_RotAngle); }

      UINT8 GetRotationBase (
         ) const { return (m_RotBase); }

      const MISTRING& GetSavedLocations (
         ) const { return (m_SavedLocations); }

      SERIALIZER* GetSerializer (
         ) const { return (m_pSerializer); }

      virtual ERRVALUE GetSizeMeters (
         DPOINT2D& sizemeters                   
         );

      const TRANS2D_AFFINE& GetTransViewToGroup (
         ) const { return (m_ViewToGroup); }

      const SPATREF::COORDREFSYS& GetUsedCoordRefSys (
         ) const;

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

      GRE::VISIBLEVIEW GetVisible (
         ) const { return (m_VisibleViewLayout); }

      void GetVisibleScaleRange (
         double& MinScaleVisible,            
         double& MaxScaleVisible             
         ) const { MinScaleVisible = m_MinScaleVisible; MaxScaleVisible = m_MaxScaleVisible; return; }

      bool HasAttachedGroups (
         ) const;

      bool HasHighlightableLayer (
         GRE::VIEW *view = 0                    
         ) const;

      virtual bool HasLayers (
         ) const;

      bool HasLegend (
         ) const { return ((m_groupflags & GROUPFLAG_CombineLayersInLegend) != 0); }

      bool HasMutuallyExclusiveLayers (
         ) const { return (m_HasMutuallyExclusiveLayers); }

      bool HasTempLayers (
         ) const;

      bool HighlightSetupDefault (
         GRE::VIEW *view = 0                    
         );

      void InvalidateAllViews (
         GRE::RENDERTARGET Target = GRE::RENDERTARGET_GroupAll | GRE::RENDERTARGET_LayerAll
         );

      bool Is3D (
         ) const { return (!m_layout || (m_groupflags & GROUPFLAG_3D)); }

      bool IsBeingLoaded (
         ) const { return (m_pSerializer != 0); }

      bool IsClipped (
         ) const;

      bool IsClippedToMatchedLayer (
         ) const { return (m_ClipToMatchedLayer && GetMatchedLayer() != 0); }

      bool IsCreated (
         ) const { return (m_IsCreated); }

      bool IsIgnored (
         ) const;

      bool IsSingleLayer (
         ) const { return ((m_groupflags & GROUPFLAG_SingleLayer) != 0); }

      bool IsValid (
         ) const;

      bool IsVisibleAtScale (
         double scale
         ) const { return (!m_layout || (scale >= m_MinScaleVisible && (m_MaxScaleVisible <= 0.0 || scale <= m_MaxScaleVisible))); }

      bool IsVisibleInView (
         const GRE::VIEW *view
         ) const;

      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      virtual ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         ) const;

      void Set2D (
         );

      void SetActiveLayer (
         GRE::LAYER *layer                      
         );

      void SetAllLayersVisible (
         VISIBLEVIEW views,
         bool visible
         );

      void SetAllLayersVisible (
         VIEW *view,
         bool visible
         );

      void SetClipRect (
         const DRECT2D& ClipRect,               
         const SPATREF::COORDREFSYS& RectCRS,   
         bool notify = true
         );

//    void SetClipRegion (
//       const REGION2D& ClipRegion,            //!< Clip region
//       bool notify = true
//       );

      void SetClipToMatchedLayer (
         bool ClipToMatchedLayer,               
         bool notify = true                     
         );

      void SetFlags (
         UINT32 flags,                          
         UINT32 mask                            
         );

      void SetFlags (
         UINT32 flags,                          
         UINT32 mask,                           
         bool notify
         );

      void SetLabelManagementMode (
         LABEL_MANAGEMENT_MODE mode
         ) { m_LabelManagementMode = mode; }

      void SetListPos (
         GRE::LISTPOS listpos,                  
         GROUP *refgroup = 0                    
         );

      void SetListPos (
         int newpos                             
         );

      void SetMatte (
         const MATTE& matte,                    
         bool notify = true                     
         );

      void SetModified (
         bool notify = true,                    
         bool ViewsNeedRedraw = true            
         );

      void SetMutualExclusiveGroupSet (
         UINT32 GroupSet                        
         );

      void SetMutuallyExclusiveLayers (
         bool LayersMutuallyExclusive = true
         );

      ERRVALUE SetName (
         const MISTRING& newname                
         );

      void SetNeedUpdateExtents (
         ) { m_NeedUpdateExtents = true; }

      void SetOrientation (
         UINT8 NewRotBase,                      
         double NewRotAngle                     
         ) { m_RotBase = NewRotBase; m_RotAngle = NewRotAngle; }

      void SetProjView (
         const GRE::LAYER *layer                
         );

      void SetPosnAttachGeographic (
         GRE::GROUP *RefGroup = 0               
         );

      void SetPosnAttachmentX (
         UINT8 AttachmentThis,                  
         UINT8 AttachmentRef                    
         );

      void SetPosnAttachmentY (
         UINT8 AttachmentThis,                  
         UINT8 AttachmentRef                    
         );

      void SetPosnAttachToX (
         UINT8 AttachRefType,                   
         GRE::GROUP *RefGroup                   
         );

      void SetPosnAttachToY (
         UINT8 AttachRefType,                   
         GRE::GROUP *RefGroup                   
         );

      void SetPosnOffsetX (
         double offset
         ) { m_xposn.offset = offset; }

      void SetPosnOffsetY (
         double offset
         ) { m_yposn.offset = offset; }

      void SetPosnStateX (
         UINT8 PosnState
         ) { m_xposn.PosnSet = PosnState; }

      void SetPosnStateY (
         UINT8 PosnState
         ) { m_yposn.PosnSet = PosnState; }

      void SetPosnValuesX (
         UINT8 AttachRefType,                   
         GRE::GROUP *RefGroup,                  
         UINT8 AttachmentThis,                  
         UINT8 AttachmentRef,                
         double offset
         ) { m_xposn.AttachRefType = AttachRefType; m_xposn.refgroup = RefGroup; m_xposn.AttachmentThis = AttachmentThis; m_xposn.AttachmentRef = AttachmentRef; m_xposn.offset = offset; }

      void SetPosnValuesY (
         UINT8 AttachRefType,                   
         GRE::GROUP *RefGroup,                  
         UINT8 AttachmentThis,                  
         UINT8 AttachmentRef,                   
         double offset
         ) { m_yposn.AttachRefType = AttachRefType; m_yposn.refgroup = RefGroup; m_yposn.AttachmentThis = AttachmentThis; m_yposn.AttachmentRef = AttachmentRef; m_yposn.offset = offset; }

      void SetRelativeScale (
         double RelativeScale,
         bool notify = true
         );

      ERRVALUE SetRenderCoordRefSys (
         const SPATREF::COORDREFSYS& RenderCRS
         );

      void SetSavedLocations (
         const MISTRING& string
         ) { m_SavedLocations = string; }

      void SetSingleLayer (
         bool SingleLayer
         ) { if (SingleLayer) m_groupflags |= GROUPFLAG_SingleLayer; else m_groupflags &= ~GROUPFLAG_SingleLayer; }

      ERRVALUE SetupEquirectangular (
         SPATREF::COORDREFSYS& CoordRefSys,     
         const DPOINT2D& center                 
         ) const;

      void SetViewPoint3D (
         const GRE::VIEWPOINT3D& ViewPoint3D
         );

      void SetVisible (
         UINT32 flags,                          
         bool set                               
         );

      void SetVisibleScaleRange (
         double MinScaleVisible,
         double MaxScaleVisible
         ) { m_MinScaleVisible = MinScaleVisible; m_MaxScaleVisible = MaxScaleVisible; }

      void SetVisibleView (
         GRE::VIEW *view,                       
         bool visible                           
         );

      ERRVALUE TemplateWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         );

      void ValidateAttachments ();
      
   protected:
      #ifndef GENERATING_DOXYGEN_OUTPUT
         static const SML::CLASSMEMBER* GetSMLClassMembers();
      #endif

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

      class SML_GROUPXPOSN;
      class SML_GROUPYPOSN;

      GRE::LAYER *m_firstlayer;              // First layer in group
      GRE::LAYER *m_lastlayer;               // Last layer in group
      GRE::LAYER *m_activelayer;             // Currently active layer for group
      GRE::LAYER *m_matchedlayer;            // Layer matched to for auto-match options
      UINT8 m_RotBase;                       // Base for rotation: 0=Projection, 1=North
      double m_AspectX;
      double m_AspectY;
      double m_RotAngle;                     // Rotation angle
      GROUP *m_prevgroup;
      GROUP *m_nextgroup;
      GRE::LAYOUT *m_layout;                 // Pointer to "parent" layout
      UINT32 m_groupflags;
      POSN m_xposn;
      POSN m_yposn;
      GRE::VIEWPOINT3D *m_ViewPoint3D;       // 3-D viewpoint for group when used in layout
      GRE::VISIBLEVIEW m_VisibleViewLayout;  // Bits for whether group is visible in layout views

      SERIALIZER *m_pSerializer;             // Set while group is being loaded
      bool m_IsCreated;
      bool m_NeedUpdateExtents;              // Extents need to be recomputed
      double m_MinScaleVisible;
      double m_MaxScaleVisible;
      double m_DesignScale;                  // Group Design scale
      double m_RelativeScale;                // Scale relative to layout Design scale
      mutable MISTRING m_ActiveLayerName;
      bool m_ClipToMatchedLayer;
      bool m_HasMutuallyExclusiveLayers;
      GRE::HIGHLIGHTMODE m_ElemHighlightMode;
      UINT32 m_MutualExclusiveGroupSet;
      MATTE m_Matte; 
      MISTRING m_name;
      SPATREF::COORDREFSYS m_RenderCRS;      // Coordinate reference system group rendered in if not auto-matched
      REGION2D m_ClipRegion;                 // Clip region
      REGION2D m_FullRegion;                 // Union of all layer regions in group's render CRS
      TRANS2D_AFFINE m_ViewToGroup;
      DRECT2D m_LayoutExtents;               // Extents in layout coordinates
      LABEL_MANAGEMENT_MODE m_LabelManagementMode;
      LAYER::COMMONPARM **m_PtrsLayerCommonParm;
      MISTRING m_SavedLocations;

      static void GRECB_Group (
         const GRE::MSG *msg,
         void *vgroup
         );

      static const SERIALIZERITEM* SerialGetItemDef (
         SERIALIZER& serializer
         );

      static ERRVALUE SerializerCB_OldClipProj (SERIALIZER&, const SERIALIZERITEM*, void *vgroup, SERIALIZERITEM::ACTION);
      static ERRVALUE SerializerCB_OldClipRect (SERIALIZER&, const SERIALIZERITEM*, void *vgroup, SERIALIZERITEM::ACTION);
      static ERRVALUE SerializerCB_OldGroupFlags (SERIALIZER&, const SERIALIZERITEM*, void *vgroup, SERIALIZERITEM::ACTION);
      static ERRVALUE SerializerCB_ViewPoint3D (SERIALIZER&, const SERIALIZERITEM*, void *vgroup, SERIALIZERITEM::ACTION);

      void Init ();

      GRE::LAYER *GetMatchedLayer () const;

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

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

      GROUP (const GROUP&);
      GROUP& operator= (const GROUP&);

      friend class GRE::LAYOUT;
      friend class GRE::LAYER;
      friend class SML_GROUPXPOSN;
      friend class SML_GROUPYPOSN;

      #endif 
   };

DEFINE_ENUM_OP_BITWISE(GROUP::CREATEFLAGS)


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

#endif   

---