gre/layout.h

Go to the documentation of this file.

#ifndef  INC_GRE_LAYOUT_H
#define  INC_GRE_LAYOUT_H

#ifndef  INC_GRE_GROUP_H
   #include <gre/group.h>
#endif

#ifndef INC_MI32_MPLAYOUT_H
   #include <mi32/mplayout.h>
#endif


#define  POSNMODE_Tiled          0
#define  POSNMODE_Overlapped     1
#define  POSNMODE_MapLayout      2

#define  GRE_WorldRangeFP  1000000.0      

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

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

   public:

      enum CREATEFLAGS {
         CREATEFLAG_None =             0x0000,
         CREATEFLAG_NoCallCreateCB =   0x0001,  
         CREATEFLAG_Temporary =        0x0002,  
         CREATEFLAG_Hardcopy =         0x0010,  
         CREATEFLAG_DeferCreate =      0x0020   
         };

      static void SMLClassInstall (
         SML::CONTEXT *context                     
         );

      explicit LAYOUT (
         CREATEFLAGS flags = CREATEFLAG_None
         );

      virtual ~LAYOUT ();

   #ifdef USE_MGUI
      ERRVALUE AddGroupLayer (
         MDLGPARENT dlgparent,
         GRE::LAYER::TYPE layertype,
         GRE::LAYER **player = 0                
         );
   #endif

   #ifdef USE_MGUI
      ERRVALUE AddGroupMulti (
         MDLGPARENT dlgparent
         );
   #endif

   #ifdef USE_MGUI
      int AddGroupSaved (
         MDLGPARENT dlgparent,
         bool fromtext
         );
   #endif

      void Create (
         CREATEFLAGS createflags = CREATEFLAG_None
         );

      ERRVALUE CreateGroup (
         GRE::GROUP **retgroup = 0,             
         GRE::GROUP::CREATEFLAGS createflags = GRE::GROUP::CREATEFLAG_None,
         GRE::LISTPOS listpos = GRE::LISTPOS_After,
         GRE::GROUP *refgroup = 0                  
         );

      void DestroyAllGroups (
         );

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

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

      GRE::GROUP* GetActiveGroup (
         ) const { return (m_ActiveGroup); }

      GRE::GROUP* GetFirstGroup (
         ) const { return (m_FirstGroup); }

      virtual void GetFullName (
         MISTRING& name                         
         ) const;

      double GetHardcopyDPI (
         ) const { return (m_HardcopyLayout.dpi); }

      DRECT2D GetHardcopyMarginRect (
         ) const;

      DRECT2D GetHardcopyPageRect (
         ) const;

      DRECT2D GetHardcopyPrintableRect (
         ) const;

      double GetHardcopyScale (
         ) const { return (m_HardcopyLayout.Scale); }

      const LAYOUTPARMS& GetHardcopyValues (
         ) const { return (m_HardcopyLayout); }

      double GetHardcopyZoom (
         ) const { return (m_HardcopyLayout.Zoom); }

      GRE::GROUP* GetLastGroup (
         ) const { return (m_LastGroup); }

      MATTE& GetMatte (
         ) { return (m_Matte); }

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

      LAYOUT* GetNext (
         ) const { return (m_NextLayout); }

      virtual UINT32 GetNextLayerID (
         ) const;

      UINT8 GetPosnMode (
         ) const { return (m_PosnMode); }

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

      virtual ERRVALUE GetSizeMeters (
         DPOINT2D& sizemeters                   
         );

      bool GroupControlsGetAutoRedraw (
         ) const;

      int GroupControlsGetLayoutUnits (
         ) const;

      bool GroupControlsIsOpen (
         ) const;

      void GroupControlsOpen (
         MDLGPARENT dlgparent = 0,     
         GRE::GROUP* group = 0,        
         UINT32 flags = 0              
         );

      void GroupControlsSetPrompts (
         double hoffset,      
         double hsize,        
         double voffset,      
         double vsize,        
         double relscale      
         );
      
      void GroupControlsSetTabLayout (
         );

      virtual bool HasLayers (
         ) const;

      bool HasTempLayers (
         ) const;

      void InvalidateAllViews (
         );

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

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

      bool IsHardcopy (
         ) const { return (m_PosnMode == POSNMODE_MapLayout); }

      bool IsSortLegendNatural (
         ) const { return (m_SortLegendNatural); }

      bool IsValid (
         ) const;

      bool KeepInTNTserverCache (
         ) const { return (m_KeepInTNTserverCache); }

      virtual ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

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

      void SetActiveGroup (
         GRE::GROUP *group
         );

      void SetHardcopyValues (
         const LAYOUTPARMS& values,
         bool notify = true
         );

      void SetKeepInTNTserverCache (
         bool keepInTNTserverCache
         ) {
         if (m_KeepInTNTserverCache != keepInTNTserverCache) m_IsModified = true;
         m_KeepInTNTserverCache = keepInTNTserverCache;
         }

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

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

      ERRVALUE SetName (
         const MISTRING& newname
         );

      void SetNeedUpdatePositions (
         ) { m_NeedUpdatePositions = 1; }

      void SetPosnMode (
         UINT8 posnmode
         );

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

      int SetZoomToFitPage (
         );

      ERRVALUE TemplateRead (
         SERIALIZER& serializer
         );

      ERRVALUE TemplateWrite (
         SERIALIZER& serializer
         );

      int UpdatePositions (
         bool ForceUpdate = true
         );

      void ValidateGroupAttachments (
         );

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

   private:

      static const SERIALIZERITEM* SerialGetItemDef (
         SERIALIZER& serializer
         );

      static ERRVALUE SerializerCB_Group (
         SERIALIZER& serializer,
         const SERIALIZERITEM*,
         void *vlayout,
         SERIALIZERITEM::ACTION action
         );

      static ERRVALUE TemplateCB_Group (
         SERIALIZER& serializer,
         const SERIALIZERITEM*,
         void *vlayout,
         SERIALIZERITEM::ACTION action
         );

      static const SERIALIZERITEM* TemplateGetItemDef (
         );

      GRE::GROUP *m_FirstGroup;           // First group in layout
      GRE::GROUP *m_LastGroup;            // Last group in layout
      UINT8 m_PosnMode;                   // Positioning mode, POSNMODE_...
      LAYOUTPARMS m_HardcopyLayout;       // Used in map/poster layout mode
      double m_PosnScale;                 // Scale used for attachment offsets in group positioning (eg. 24000)
      DRECT2D m_FullExtents;              // Extents of entire layout in layout coordinates
      GRE::GROUP* m_ActiveGroup;          // Currently active group for layout
      LAYOUT *m_PrevLayout;               // Pointer to "previous" layout if multiple layouts are in use
      LAYOUT *m_NextLayout;               // Pointer to "next" layout if multiple layouts are in use
      bool m_IsCreated;                   // Has been created
      bool m_NeedUpdatePositions;         // Need to update positions of layout children
      bool m_KeepInTNTserverCache;        // Keep layout in TNTserver cache
      bool m_SortLegendNatural;           // Sort legend in natural order
      SERIALIZER *m_pSerializer;          // Serializer used while loading
      INT32 m_tilecols;
      INT32 m_tilerows;
      MISTRING m_name;
      mutable MISTRING m_activegroupname; // Name of active group used when saving/loading layout
      MATTE m_Matte;
      MISTRING m_SavedLocations;

      // Create group without CreateChildrenBegin/End notification.
      ERRVALUE CreateGroupNoNotify (
         GRE::GROUP **retgroup = 0,
         GRE::GROUP::CREATEFLAGS createflags = GRE::GROUP::CREATEFLAG_None,
         GRE::LISTPOS listpos = GRE::LISTPOS_After,
         GRE::GROUP *refgroup = 0
         );

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

      LAYOUT (const LAYOUT&);
      LAYOUT& operator= (const LAYOUT&);

      friend class GRE::GROUP;

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

#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(LAYOUT::CREATEFLAGS);
#endif

ERRVALUE DlgEditLayoutSettings (
   MDLGPARENT dlgparent,         
   LAYOUT *layout                
   );

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

#endif   // INC_GRE_LAYOUT_H

---