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.20 2004/09/03 22:51:34 dwilliss Exp $
 *
 * $Log: group.h_v $
 * 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.6  2003/11/04 18:43:55  mju
 * Add DlgObjMgr overrides.
 *
 * 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;

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


#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_NoClipToAttached       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_OrientMask             0x00000070
#define  GROUPFLAG_NoNotifyMask           GROUPFLAG_TemplateSaveLayersAsIs

struct MDISPGROUPPOSN {                //! Layout/Positioning parameters
   GRE_GROUP *refgroup;
   UINT8 AttachRefType;                //!< Reference type, ATTACHREF_...
   UINT8 AttachmentThis;               //!< Attachment type for this group (ATTACHMENT_...)
   UINT8 AttachmentRef;                //!< Attachment type for reference group
   UINT8 OffsetType;                   //!< Offset type, OFFSETTYPE_...
   UINT8 PosnSet;
   double offset;                      //!< Offset in METERS
   mutable UNICODE refgroupname[GRE_GROUP_NAMELEN];
   };

class GRE_GROUP : public GRE_VIEWABLE, public SERIALIZABLE {

   public:

      enum LABEL_MANAGEMENT_MODE {
         LABEL_MANAGEMENT_MODE_RenderWithLayer = 0,
         LABEL_MANAGEMENT_MODE_RenderLast
         };

   #ifdef X_NATIVE
      class OBJMGRFORM {
         public:

            //! Constructor.
            OBJMGRFORM (
               GRE_GROUP *group
               );

            //! Destructor.
            ~OBJMGRFORM (
               );

            //! Create the form widget and show in object manager.
            Widget Create (
               );

            Widget GetForm (
               ) const { return (m_form); }

            void HideLayers (
               );

            //! @return Next position after item.
            short SetObjMgrPos (
               short pindex = -2
               );

            void ShowLayers (
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            GRE_GROUP *m_group;
            Widget m_form;
            Widget m_ActiveTB;
            Widget m_ShowLayersTB;
            Widget m_VisibleIcon[GRE_MAXVIEWS];
            Widget m_GroupNameP;
            UNICODE m_GroupNameStr[64];

            static void CB_CmdGroupControls (Widget, GRE_GROUP *group, void*);
            static void CB_CmdGroupDelete (Widget, GRE_GROUP *group, void*);
            static void CB_CmdGroupDeleteActiveLayer (Widget, GRE_GROUP *group, void*);
            static void CB_CmdGroupDeleteAllLayers (Widget, GRE_GROUP *group, void*);
            static void CB_CmdGroupViewpoint (Widget, GRE_GROUP *group, void*);
            static void CB_CmdLayerAddAny (Widget, GRE_GROUP *group, void*);
            static void CB_CmdLayerAdd (Widget, void *vlayertype, void*);
            static void CB_CmdLayerControls (Widget, GRE_GROUP *group, void*);
            static void CB_CmdLayerOrder (Widget, void *voption, void*);
            static void CB_EditGroupName (MxPromptCallbackStruct*, void *vgroup);
            static void CB_NotifyGreObject (const GRE_CALLBACK_MSG *msg, void *vpObjMgrForm);
            static void CB_NotifyGreView (const GRE_CALLBACK_MSG *msg, void*);
            static void CB_ToggleActive (Widget, void *vgroup, XmToggleButtonCallbackStruct*);
            static void CB_ToggleShowLayers (Widget, void *vpObjMgrForm, XmToggleButtonCallbackStruct*);
            static void CB_ToggleVisibleInViewNum (Widget, void *vViewNum, XmToggleButtonCallbackStruct*);

            void DestroyForm ();
            void OnNotifyGreObject (const GRE_CALLBACK_MSG& msg);

            OBJMGRFORM (const OBJMGRFORM&);
            OBJMGRFORM& operator= (const OBJMGRFORM&);

            #endif //!< GENERATING_DOXYGEN_OUTPUT
         }; //! End of GRE_GROUP::OBJMGRFORM
      #endif

      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
      UINT8 ElemSelectMode;               //!< Element selection mode
      double AspectX;
      double AspectY;
      double RotAngle;                    //!< Rotation angle
      double zinit;                       //!< Minimum Z value for group (unscaled)
      double zlast;                       //!< Maximum Z value for group (unscaled)
      GRE_GROUP *prevgroup;
      GRE_GROUP *nextgroup;
      GRE_LAYOUT *layout;                 //!< Pointer to "parent" layout
      UINT32 groupflags;
      MDISPGROUPPOSN 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

      //! Get first 'standalone' group.
      static GRE_GROUP* GetFirst (
         ) { return (s_FirstGroup); }

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

      //! Get last 'standalone' group.
      static GRE_GROUP* GetLast (
         ) { return (s_LastGroup); }

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

      //! Construct "stand-alone" group
      explicit GRE_GROUP (
         UINT32 flags = 0
         );

      //! Construct group within a layout
      GRE_GROUP (
         GRE_LAYOUT *layout,
         GRE_GROUP *refgroup,
         UINT32 flags
         );

      //! Destructor.
      virtual ~GRE_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 (
         GRE_GROUP* refgroup,
         UINT32 insertpos
         );

      //! 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;

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

      //! Destroy specified layer in this group
      void DestroyLayer (
         GRE_LAYER* layer
         );

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

      //! Draw all views containing this group
      virtual ERRVALUE DrawAllViews (
         UINT32 flags = 0                       //!< MDISPDRAW_... flags
         );

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

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

      //! 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
         UINT32 flags                           //!< MDISPEXTENTS_... flags
         );

      //! 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
      GRE_GROUP* GetMatchedGroup (
         ) const;

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

      //! Get group name.
      const UNICODE* GetName (
         ) const { return (m_name); }

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

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

   #ifdef X_NATIVE
      OBJMGRFORM& GetObjMgrForm (
         ) { return (m_ObjMgrForm); }
   #endif

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

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

      //! Get CoordRefSys group is to be rendered in if not auto-matched.
      const SPATREF::COORDREFSYS& GetRenderCoordRefSys (
         ) const { return (m_RenderCRS); }

      //! 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 group actually used for rendering.
      const SPATREF::COORDREFSYS& GetUsedCoordRefSys (
         ) const { return (GetFullRegion().GetCoordRefSys()); }

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

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

      //! 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 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 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 UNICODE* 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:

   #ifdef X_NATIVE
      //! Create initial set of items in object manager.
      virtual void ObjMgrInitItems (
         );
   #endif

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

      static GRE_GROUP *s_FirstGroup;
      static GRE_GROUP *s_LastGroup;

   #ifdef X_NATIVE
      OBJMGRFORM m_ObjMgrForm;
      GEOCAT_DIALOG *m_GeoCatDlg;
      MXDHANDLE m_pDlgObjMgr;
   #endif

      SERIALIZER *m_pSerializer;             // Set while group is being loaded
      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 UNICODE m_ActiveLayerName[64];
      bool m_ClipToMatchedLayer;
      bool m_HasMutuallyExclusiveLayers;
      UINT32 m_MutualExclusiveGroupSet;
      MATTE m_Matte; 
      UNICODE m_name[GRE_GROUP_NAMELEN];
      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_CALLBACK_MSG *msg,
         void *vgroup
         );

      static const SERIALIZER::ITEMDEF* SerialGetItemDef (
         SERIALIZER& serializer
         );

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

      void Init ();

      //! Determine layer group projection will be auto-matched to
      GRE_LAYER *GetMatchedLayer () const;

   #ifdef X_NATIVE
      virtual void OnNotifyGreObjMgr (const GRE_CALLBACK_MSG& msg);
   #endif

      //! GRE_OBJECT overrides.
      virtual bool v_Destroy (bool NotifyParent);
      virtual MICON v_GetIcon () const;
      virtual const char* v_GetTypeName () const;

      //! GRE_VIEWABLE overrides.
   #ifdef X_NATIVE
      virtual void v_DlgObjMgrClose ();
      virtual ERRVALUE v_DlgObjMgrCreate (MDLGPARENT dlgparent, const MISTRING& title);
      virtual void v_DlgObjMgrDestroy ();
      virtual bool v_DlgObjMgrIsOpen () const;
      virtual void v_DlgObjMgrOpen ();
   #endif
      virtual double v_GetDesignScale () const;
      virtual const DRECT2D& v_GetExtents () const;
      virtual void v_SetDesignScale (double DesignScale, bool notify);

      GRE_GROUP (const GRE_GROUP&);
      GRE_GROUP& operator= (const GRE_GROUP&);

      friend class GRE_LAYOUT;
   #ifdef X_NATIVE
      friend class GRE_GROUP::OBJMGRFORM;
   #endif

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };


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

#ifdef WIN32_MFC

#ifndef GENERATING_DOXYGEN_OUTPUT
class GRE_MFC_GROUP : public GRE_MFC_VIEWABLE {
   protected:

      GRE_MFC_GROUP ();
      DECLARE_DYNCREATE(GRE_MFC_GROUP)

   public:

      GRE_GROUP* GetGroup (
         ) const { return (m_group); }

      virtual ~GRE_MFC_GROUP();

   protected:
      GRE_GROUP *m_group;

      DECLARE_MESSAGE_MAP()
   };
#endif //!< GENERATING_DOXYGEN_OUTPUT

#endif

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

#endif   //!< INC_GRE_GROUP_H

---