gre/group.h

Go to the documentation of this file.

/**
 * \file group.h <gre/group.h>
 * \brief GRE::GROUP class definitions
 *
 * \if NODOC
 * $Id: group.h_v 1.52 2007/04/23 20:14:02 dwilliss Exp $
 *
 * $Log: group.h_v $
 * Revision 1.52  2007/04/23 20:14:02  dwilliss
 * added static method to get sml class members
 *
 * Revision 1.51  2006/10/10 13:57:17  mju
 * Use miconstruct* instead of micon.
 *
 * Revision 1.50  2006/09/15 15:29:51  mju
 * Serializer changes.
 *
 * Revision 1.49  2006/09/01 17:19:21  mju
 * Add setMatte.
 *
 * Revision 1.48  2006/06/07 12:38:40  mju
 * Add createflag_sml and groupflags_CreatedBySML.
 *
 * Revision 1.47  2006/05/16 16:20:54  mju
 * Remove getRenderCRS as just use getUsedCRS.
 *
 * Revision 1.46  2006/05/05 13:48:04  mju
 * Support deferred creation.
 *
 * Revision 1.45  2005/11/28 18:53:26  mju
 * Add v_getMax/MinScaleVisibleAny.
 *
 * Revision 1.44  2005/11/11 22:51:40  mju
 * Use mistring for reflayername.
 *
 * Revision 1.43  2005/11/04 18:51:51  mju
 * enums in gre namespace.
 *
 * Revision 1.42  2005/11/02 23:00:40  mju
 * Remove objmgr stuff.
 *
 * Revision 1.41  2005/10/19 20:04:50  mju
 * Use gre namespace instead of legacy typedefs.
 *
 * Revision 1.40  2005/10/19 17:25:53  mju
 * Remove unneeded typedef.
 *
 * Revision 1.39  2005/10/14 17:30:09  mju
 * GRE namespace.
 *
 * Revision 1.38  2005/06/30 16:49:19  mju
 * Add mask for groupflag to determine which flags don't require redraw.
 *
 * Revision 1.37  2005/06/14 15:27:28  mju
 * Add parm to getMatchedGroup to determine if want first in link.
 *
 * Revision 1.36  2005/06/10 20:34:59  vdronov
 * combined old and new 3d rendering
 *
 * Revision 1.35  2005/05/31 15:20:00  mju
 * Make getUsedCoordRefSys non-inline.
 *
 * Revision 1.34  2005/05/31 13:45:12  mju
 * Add getNeedUpdateExtents.
 *
 * Revision 1.33  2005/05/13 14:37:25  scowan
 * Moved global standalone group list to system.
 *
 * Revision 1.32  2005/05/02 17:43:36  mju
 * Move highightMode to viewable.
 *
 * Revision 1.31  2005/04/29 17:49:45  mju
 * Support rendertarget.
 *
 * Revision 1.30  2005/03/31 16:57:05  fileserver!dwilliss
 * Rename one of our types to MIUNICODE because it conflicted with a Microsoft #define
 *
 * Revision 1.29  2005/03/22 22:00:55  mju
 * Add invalidateAllViews.
 *
 * Revision 1.28  2005/03/16 23:56:35  vdronov
 * *** empty log message ***
 *
 * Revision 1.27  2005/03/16 22:37:55  vdronov
 * added toggle for advanced 3d rendering
 *
 * Revision 1.26  2005/02/25 20:30:49  mju
 * Move groupview to own header.
 *
 * Revision 1.25  2005/02/25 18:54:09  mju
 * Declare device_mem32rgba.
 *
 * Revision 1.24  2005/02/24 18:52:13  mju
 * Add groupview methods for overlay device.
 *
 * Revision 1.23  2005/02/23 18:52:23  mju
 * Add groupview stuff for overlsy.
 *
 * Revision 1.22  2005/02/14 18:52:38  mju
 * Add groupview class.
 *
 * Revision 1.21  2005/01/20 16:54:11  mju
 * Add createflags.
 * Drawmode enum.
 *
 * Revision 1.20  2004/09/03 22:51:34  dwilliss
 * Added an enum, member to hold it and Get/Set methods
 *
 * Revision 1.19  2004/08/27 21:55:32  mju
 * Set clip region not supported.
 *
 * Revision 1.18  2004/08/12 16:59:53  dglasser
 * Added destroy layer for sml func.
 *
 * Revision 1.17  2004/07/30 14:20:17  mju
 * Add groupflag_noLegacyRectExtents.
 *
 * Revision 1.16  2004/07/27 17:44:36  mju
 * Add groupflag to not clip to rectangle.
 *
 * Revision 1.15  2004/07/20 13:14:47  mju
 * Use new region2d hdr.
 *
 * Revision 1.14  2004/07/14 20:12:40  mju
 * No more mapprojparm.
 *
 * Revision 1.13  2004/07/08 21:23:56  mju
 * Docs for setupequirectangular.
 *
 * Revision 1.12  2004/06/30 22:11:23  mju
 * Make setupequirectangular public.
 *
 * Revision 1.11  2004/06/28 20:30:24  mju
 * Wanted getfullregion to return reference.
 *
 * Revision 1.10  2004/06/28 17:53:09  mju
 * Convert to spatref.
 *
 * Revision 1.9  2004/02/18 21:16:21  mju
 * Add GetLayerZoom1X.
 *
 * Revision 1.8  2003/11/12 22:41:42  mju
 * Use serializer to log errors instead of group.
 *
 * Revision 1.7  2003/11/10 18:43:35  mju
 * Remove savefilename/inode as need in base.
 *
 * Revision 1.5  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.4  2003/08/29 20:13:43  mju
 * Add v_GetExtents.
 *
 * Revision 1.3  2003/07/30 14:58:25  mju
 * Ignore private sections.
 *
 * Revision 1.2  2003/07/29 19:58:55  mju
 * Add SetNeedUpdateExtents.
 *
 * Revision 1.1  2003/06/16 19:39:31  mju
 * Initial revision
 *
 * \endif
**/

#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_MATTE_H
   #include <mi32/matte.h>
#endif

#ifndef INC_MI32_REGION2D_H
   #include <mi32/region2d.h>
#endif

class GEOCAT_DIALOG;
struct SMLCLASSMEMBER;

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

#define  GROUPFLAG_None                   0x00000000
#define  GROUPFLAG_Ignore                 0x00000001  //!< Completely ignores group for positioning/display
#define  GROUPFLAG_NoFixAspectLL          0x00000002  //!< Don't perform "aspect correction" if viewed in lat/lon projection
#define  GROUPFLAG_SingleLayer            0x00000004  //!< Group can only contain a single layer (other than background)
#define  GROUPFLAG_Clip                   0x00000008  //!< Clip layers in group to specified region
#define  GROUPFLAG_OrientMatchRasterOnly  0x00000010  //!< Match first raster layer or nothing if no raster
#define  GROUPFLAG_OrientMatchRasterOther 0x00000020  //!< Match first raster layer or first layer if no raster
#define  GROUPFLAG_OrientMatchLayer       0x00000040  //!< Match first layer
#define  GROUPFLAG_3D                     0x00000200  //!< 3-D group in a layout
#define  GROUPFLAG_ShowLatLonCoords       0x00001000  //!< Show group coordinates in lat-lon
#define  GROUPFLAG_NoLockZoom             0x00004000  //!< Don't lock group zoom factor
#define  GROUPFLAG_ShowLayerList          0x00008000  //!< Show list of layers for group
#define  GROUPFLAG_NoClipToAttachedGroup  0x00010000  //!< Don't clip to attached group if that group is clipped
#define  GROUPFLAG_CombineLayersInLegend  0x00020000  //!< Combine layers within group in LegendView by showing only legend for active layer
#define  GROUPFLAG_TemplateSaveLayersAsIs 0x00040000  //!< Save layers as-is to template
#define  GROUPFLAG_NoClipToRectOnly       0x00080000  //!< Don't force clipping to just be rectangle (for legacy layouts)
#define  GROUPFLAG_NoLegacyRectExtents    0x00100000  //!< Don't just use layer rectangle when compute extents (for legacy layouts)
#define  GROUPFLAG_CreatedBySML           0x00200000  //!< Group was created by SML

#define  GROUPFLAG_OrientMask             0x00000070
#define  GROUPFLAG_NoNotifyMask           GROUPFLAG_TemplateSaveLayersAsIs
#define  GROUPFLAG_Mask_NoRedraw          (GROUPFLAG_ShowLatLonCoords | GROUPFLAG_NoLockZoom | GROUPFLAG_ShowLayerList | GROUPFLAG_CombineLayersInLegend | GROUPFLAG_TemplateSaveLayersAsIs)

#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:

      //! Flags for group creation.
      enum CREATEFLAGS {
         CREATEFLAG_None =             0x0000,
         CREATEFLAG_NoCallCreateCB =   0x0001,  //!< Don't call callback list when object created
         CREATEFLAG_Temporary =        0x0002,  //!< Object is temporary
         CREATEFLAG_3D =               0x0004,  //!< Group is 3D
         CREATEFLAG_NoAutoMatch =      0x0008,  //!< Don't default to automatch any layers
         CREATEFLAG_NoSetActive =      0x0010,  //!< Don't make newly-created group "active"
         CREATEFLAG_DeferCreate =      0x0020,  //!< Defer creation until Create() called (standalone group only)
         CREATEFLAG_SML =              0x0040   //!< Being created by SML (standalone group only)
         };

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

      enum LABEL_MANAGEMENT_MODE {
         LABEL_MANAGEMENT_MODE_RenderWithLayer = 0,
         LABEL_MANAGEMENT_MODE_RenderLast
         };

      //! Used with GetExtents().
      enum EXTENTCOORD {
         EXTENTCOORD_Group,
         EXTENTCOORD_Layout,
         EXTENTCOORD_View
         };

      //! Layout/Positioning parameters
      struct POSN {
         GROUP *refgroup;
         UINT8 AttachRefType;                //!< Reference type, ATTACHREF_...
         UINT8 AttachmentThis;               //!< Attachment type for this group (ATTACHMENT_...)
         UINT8 AttachmentRef;                //!< Attachment type for reference group
         UINT8 PosnSet;
         double offset;                      //!< Offset in METERS at design scale
         mutable MISTRING m_RefGroupName;    //!< Name of reference group attached to, used when loading
         POSN ();
         ~POSN ();
         void Clear ();
         };

      GRE::LAYER *firstlayer;             //!< First layer in group
      GRE::LAYER *lastlayer;              //!< Last layer in group
      GRE::LAYER *activelayer;               //!< Currently active layer for group
      GRE::LAYER *matchedlayer;           //!< Layer matched to for auto-match options
      UINT8 RotBase;                      //!< Base for rotation: 0=Projection, 1=North
      double AspectX;
      double AspectY;
      double RotAngle;                    //!< Rotation angle
      double zinit;                       //!< Minimum Z value for group (unscaled)
      double zlast;                       //!< Maximum Z value for group (unscaled)
      GROUP *prevgroup;
      GROUP *nextgroup;
      GRE::LAYOUT *layout;                //!< Pointer to "parent" layout
      UINT32 groupflags;
      POSN xposn, yposn;
      GRE::VIEWPOINT3D *m_ViewPoint3D;    //!< 3-D viewpoint for group when used in layout
      UINT32 VisibleViewLayout;           //!< Bits for whether group is visible in layout views

   #ifdef X_NATIVE
      //! Get group from object attached to Widget userData
      static GROUP* GetFromWidget (
         Widget w
         );
   #endif

      //! Install SML class, called by internal SML function.
      static void SMLClassInstall (
         SMLCONTEXT *context                    //!< SML context
         );

      //! Construct "stand-alone" group
      explicit GROUP (
         CREATEFLAGS createflags = CREATEFLAG_None
         );

      //! Construct group within a layout
      GROUP (
         GRE::LAYOUT *layout,
         CREATEFLAGS createflags = CREATEFLAG_None,
         GRE::LISTPOS listpos = GRE::LISTPOS_Last,
         GROUP *refgroup = 0
         );

      //! Destructor.
      virtual ~GROUP ();

      //! Determine if lat/lon aspect adjustment will be done
      bool AdjLatLon (
         );

      //! Determine if option to adjust lat/lon aspect can be set
      bool AdjLatLonCanSet (
         );

      //! Change group position in list
      bool ChangeListPos (
         GROUP* refgroup,
         GRE::LISTPOS listpos
         );

      //! Check if layer of specified type can be added
      ERRVALUE CheckAddLayer (
         GRE::LAYER::TYPE layertype = GRE::LAYER::TYPE_None
         ) const;

      //! Check if georeference for layers in group are compatible
      void CheckGeorefCompatible (
         ) const;

      //! Compute extents of group in layout
      void ComputeLayoutExtents (
         );

      //! Compute map coordinate extents for group
      ERRVALUE ComputeMapExtents (
         ); 

      ERRVALUE ComputeRegionFromLayers (
         REGION2D& region,                   //!< Region returned, will be in group's RenderCoordRefSys
         bool IncludeMargins,                //!< Include layer margins
         GRE::LAYER::FILTER *filter = 0         //!< Filter
         ) const;

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

      //! Create group if CREATEFLAG_DeferCreate was specified in constructor.
      void Create (
         CREATEFLAGS createflags = CREATEFLAG_None
         );

      //! Destroy all layers in this group
      void DestroyAllLayers (
         );

      //! Destroy specified layer in this group
      void DestroyLayer (
         GRE::LAYER* layer
         );

      //! Draw group overlay containing 'active' element for each layer.
      ERRVALUE DrawActiveOverlay (
         GRE::DRAWFLAGS DrawFlags = GRE::DRAWFLAG_UpdateScreen,
         GRE::VIEW *view = 0                    //!< View to draw overlay for, 0 for all, will be drawn first if drawing multiple
         );

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      //! Dialog to specify group clip settings.
      ERRVALUE DlgGetClipSettings (
         MDLGPARENT dlgparent
         );
   #endif

      //! Find layer using unique ID.
      virtual GRE::LAYER *FindLayerByID (
         UINT32 LayerID
         ) const;

      //! Open geocatalog dialog for adding layers to group.
      ERRVALUE GeoCatDlgOpen (
         MDLGPARENT dlgparent                   //!< Parent for dialog
         );

      //! Set point for next "point search" operation in geocatalog dialog.
      void GeoCatDlgSetSearchPoint (
         const DPOINT2D& SearchPoint,           //!< Point coordinates
         const SPATREF::COORDREFSYS& PointCRS   //!< Point coordinate reference system
         ) const;

      //! Determine "active" layer for group.
      //! @return Active layer or NULL if none.
      GRE::LAYER* GetActiveLayer (
         ) const { return (activelayer); }

      //! Get clipping region for group.
      const REGION2D& GetClipRegion (
         ) const;

      //! Get setting for "clip to matched layer" regardless of whether or not will be auto-matched.
      bool GetClipToMatchedLayer (
         ) const { return (m_ClipToMatchedLayer); }

      //! Get extents of group in specified coordinates
      ERRVALUE GetExtents (
         DRECT2D& extents,                      //!< Group extents returned
         EXTENTCOORD coords                     //!< What to return extents in
         );

      //! Get first layer in group.
      GRE::LAYER* GetFirstLayer (
         ) const { return (firstlayer); }

      //! Get current group flag settings
      UINT32 GetFlags (
         ) const { return (groupflags); }

      //! Get full group name as MISTRING.
      virtual void GetFullName (
         MISTRING& name                         //!< Name returned
         ) const;

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

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

      //! Get last layer in group.
      GRE::LAYER* GetLastLayer (
         ) const { return (lastlayer); }

      //! Get layer to use for 1X zoom.
      GRE::LAYER* GetLayerZoom1X (
         bool PreferredOnly                     //!< Use 'preferred' layers only
         ) const;

      //! Get layout group is contained in.
      //! @return pointer to layout.
      GRE::LAYOUT * GetLayout (
         ) const { return (layout); }

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

      //! Get current group drawing order position in list.
      //! @return 0 for first group, 1 for second, etc.
      int GetListPos (
         );

      //! Return geographically-attached reference group if any.
      GROUP* GetMatchedGroup (
         bool firstonly = false           //! True to return immediate (first link) matched group
         ) const;

      MATTE& GetMatte (
         ) { return (m_Matte); }
      
      //! Get "set" for mutual exclusiveness between groups.
      UINT32 GetMutualExclusiveGroupSet (
         ) const { return (m_MutualExclusiveGroupSet); }

      //! Get group name.
      const MISTRING& GetName (
         ) const { return (m_name); }

      //! Determine if need updated extents.
      bool GetNeedUpdateExtents (
         ) const { return (m_NeedUpdateExtents); }

      //! Get next group in layout.
      GROUP* GetNext (
         ) const { return (nextgroup); }

      //! Get next available unique ID.
      virtual UINT32 GetNextLayerID (
         ) const;

      //! Get previous group in layout.
      GROUP* GetPrevious (
         ) const { return (prevgroup); }

      //! Get relative scale
      double GetRelativeScale (
         ) const { return (m_RelativeScale); }

      //! Get rotation angle relative to base in radians
      double GetRotationAngle (
         ) const { return (RotAngle); }

      //! Get serializer instance being used to load group.
      //! @return Pointer to SERIALIZER, NULL if not being loaded.
      SERIALIZER* GetSerializer (
         ) const { return (m_pSerializer); }

      //! Compute dimensions of object based on scale and georeference
      virtual ERRVALUE GetSizeMeters (
         DPOINT2D& sizemeters                   //!< Size returned in meters
         );

      //! Get transformation from group to view.
      const TRANS2D_AFFINE& GetTransViewToGroup (
         ) const { return (m_ViewToGroup); }

      //! Get CoordRefSys used for rendering.
      const SPATREF::COORDREFSYS& GetUsedCoordRefSys (
         ) const;

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

      //! Get visibility bits.
      UINT32 GetVisible (
         ) const { return (this->VisibleViewLayout); }

      //! Get scale range over which group is visible
      void GetVisibleScaleRange (
         double& MinScaleVisible,            //!< Minimum scale visible returned, 0 for no minimum
         double& MaxScaleVisible             //!< Maximum scale visible returned, 0 for no maximum
         ) { MinScaleVisible = m_MinScaleVisible; MaxScaleVisible = m_MaxScaleVisible; return; }

      //! Determine if group has other groups attached to it
      bool HasAttachedGroups (
         ) const;

      //! Determine if any layers in group have "highlightable" elements.
      bool HasHighlightableLayer (
         GRE::VIEW *view = 0                    //!< Reference view for layer visibility test
         ) const;

      //! Determine if group has any layers
      virtual bool HasLayers (
         ) const;

      //! Determine if group has a legend.
      bool HasLegend (
         ) const { return ((this->groupflags & GROUPFLAG_CombineLayersInLegend) != 0); }

      //! Determine if group has mutually-exclusive layers
      bool HasMutuallyExclusiveLayers (
         ) const { return (m_HasMutuallyExclusiveLayers); }

      //! Determine if group has any temporary layers
      bool HasTempLayers (
         ) const;

      //! Setup for default highlighting of layer elements.
      void HighlightSetupDefault (
         GRE::VIEW *view = 0                    //!< Optional view for determining layer visibility
         );

      //! Invalidate all view buffers for this group.
      void InvalidateAllViews (
         GRE::RENDERTARGET Target = GRE::RENDERTARGET_GroupAll | GRE::RENDERTARGET_LayerAll
         );

      //! Determine if group can be viewed in 3D
      bool Is3D (
         ) const { return (!layout || (groupflags & GROUPFLAG_3D)); }

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

      //! Determine if group is to be clipped.
      bool IsClipped (
         ) const;

      //! Determine if group is to be clipped to the auto-matched layer.
      bool IsClippedToMatchedLayer (
         ) const { return (m_ClipToMatchedLayer && GetMatchedLayer() != 0); }

      //! Determine if group has been created.
      //! This is done automatically by constructor unless CREATEFLAG_DeferCreate was specified.
      bool IsCreated (
         ) const { return (m_IsCreated); }

      //! Determine if group should be ignored for extents determination
      bool IsIgnored (
         ) const;

      //! Determine if group only allows a single layer
      bool IsSingleLayer (
         ) const { return ((groupflags & GROUPFLAG_SingleLayer) != 0); }

      //! Determine if group is a valid object
      bool IsValid (
         ) const;

      //! Determine if group visible at specified scale
      bool IsVisibleAtScale (
         double scale
         ) const { return (!layout || (scale >= m_MinScaleVisible && (m_MaxScaleVisible <= 0.0 || scale <= m_MaxScaleVisible))); }

      //! Determine if group is visible in specified view.
      bool IsVisibleInView (
         const GRE::VIEW *view
         ) const;

      //! Read from serialization
      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      //! Write values to serialization
      virtual ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         ) const;

      //! Set group to 2D
      void Set2D (
         );

      //! Set active layer for group
      void SetActiveLayer (
         GRE::LAYER *layer                      //!< Layer to make active
         );

      //! Set clipping rectangle.
      void SetClipRect (
         const DRECT2D& ClipRect,               //!< Rectangle to clip to
         const SPATREF::COORDREFSYS& RectCRS,   //!< Rectangle CRS
         bool notify = true
         );

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

      //! Set whether to clip to 'auto-matched' layer
      void SetClipToMatchedLayer (
         bool ClipToMatchedLayer,               //!< 'true' to clip, 'false' to not
         bool notify = true                     //!< Send ACTION_ChangeBegin/End notification
         );

      //! Set specified group flags
      void SetFlags (
         UINT32 flags,                          //!< GROUPFLAG_... flag values
         UINT32 mask                            //!< GROUPFLAG_... mask for which flags to change
         );

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

      //! Set group position in list
      void SetListPos (
         int newpos                             //!< New list position
         );

      //! Set matte values.
      void SetMatte (
         const MATTE& matte,                    //!< Matte values to set
         bool notify = true                     //!< Set to invoke callbacks with "Changed" message
         );

      //! Set group to "modified" status
      void SetModified (
         bool notify = true,                    //!< Set to invoke callbacks with "Changed" message
         bool ViewsNeedRedraw = true            //!< Set all views of group as needing redraw
         );

      //! Set "group set" which group is mutually-exclusive with.
      void SetMutualExclusiveGroupSet (
         UINT32 GroupSet                        //!< Group set bits
         );

      //! Set whether layers are mutually-exclusive.
      void SetMutuallyExclusiveLayers (
         bool LayersMutuallyExclusive = true
         );

      //! Set group name.
      ERRVALUE SetName (
         const MISTRING& newname                //!< New name
         );

      //! Set group to recompute extents.
      void SetNeedUpdateExtents (
         ) { m_NeedUpdateExtents = true; }

      //! Set group rotation base and orientation.
      void SetOrientation (
         UINT8 NewRotBase,                      //!< ROTBASE_Projection or ROTBASE_North
         double NewRotAngle                     //!< Rotation angle, radians clockwise relative to base
         ) { RotBase = NewRotBase; RotAngle = NewRotAngle; }

      //! Set group projection to match specified layer
      void SetProjView (
         const GRE::LAYER *layer                //!< Layer to obtain projection from, NULL to match first raster/layer
         );

      //! Set group scale relative to layout design scale.
      void SetRelativeScale (
         double RelativeScale,
         bool notify = true
         );

      //! Set coordinate reference system to render group in.
      ERRVALUE SetRenderCoordRefSys (
         const SPATREF::COORDREFSYS& RenderCRS
         );

      //! Setup equirectangular CRS based on group datum.
      ERRVALUE SetupEquirectangular (
         SPATREF::COORDREFSYS& CoordRefSys,     //!< Coordinate Reference System definition returned
         const DPOINT2D& center                 //!< Projection center in CRS used by group
         ) const;

      //! Set group visibility in specified views
      void SetVisible (
         UINT32 flags,                          //!< Bits indicating which views to modify visibility for
         bool set                               //!< true if visible, false if not
         );

      //! Set scale range over which group is visible
      void SetVisibleScaleRange (
         double MinScaleVisible,
         double MaxScaleVisible
         ) { m_MinScaleVisible = MinScaleVisible; m_MaxScaleVisible = MaxScaleVisible; }

      //! Set group visibility in specified view
      void SetVisibleView (
         GRE::VIEW *view,                       //!< View to set visibility for
         bool visible                           //!< true if visible, false if not
         );

      //! Write template to serialization
      ERRVALUE TemplateWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         );
      
   protected:
      #ifndef GENERATING_DOXYGEN_OUTPUT
         static const SMLCLASSMEMBER* GetSMLClassMembers();
      #endif

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

   #ifdef X_NATIVE
      GEOCAT_DIALOG *m_GeoCatDlg;
   #endif

      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;

      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);

      void Init ();

      //! Determine layer group projection will be auto-matched to
      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 ERRVALUE v_DrawAllViews (GRE::DRAWCONDITION condition);
      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);

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

      friend class GRE::LAYOUT;

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };

DEFINE_ENUM_OP_BITWISE(GROUP::CREATEFLAGS)


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

#endif   //!< INC_GRE_GROUP_H

---