gre/layer.h

Go to the documentation of this file.

#ifndef  INC_GRE_LAYER_H
#define  INC_GRE_LAYER_H

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

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

#ifndef  INC_MI32_GRTREE_H
   #include <mi32/grtree.h>
#endif

#ifndef  INC_RVC_ELEMENT_H
   #include <rvc/element.h>
#endif

#ifndef  INC_RVC_DISPPARMUSAGE_H
   #include <rvc/dispparmusage.h>
#endif

#ifndef  INC_MGUI_DLGGETOBJECTSTYLE_H
   #include <mgui/dlggetobjectstyle.h>
#endif

#ifndef  INC_RVC_OBJECTNAME_H
   #include <rvc/objectname.h>
#endif

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

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

#ifndef  INC_MI32_SERIALIZERITEM_H
   #include <mi32/serializeritem.h>
#endif

#ifndef  INC_MI32_ELEMSTYL_H
   #include <mi32/elemstyl.h>
#endif

#ifndef  INC_RVC_OTYPESET_H
   #include <rvc/otypeset.h>
#endif

#ifndef  INC_MI32_SMLBASE_H
   #include <mi32/smlbase.h>
#endif

#ifndef  INC_MI32_TRANS2DMAPGEN_H
   #include <mi32/trans2dmapgen.h>
#endif

#ifndef  INC_MI32_MG2ENUMS_H
   #include <mi32/mg2enums.h>
#endif

#ifndef  INC_MI32_UNSIGNEDSET_H
   #include <mi32/unsignedset.h>
#endif

#ifndef  INC_MI32_DELEGATEFILTER_H
   #include <mi32/delegatefilter.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class DBEDIT;
struct DATATIPPARMS;
struct DBEDIT_MSG;
struct MENUITEM;
class MENUITEMARRAY;
namespace RVC {
   class DESCRIPTOR;
   class DBTABLE;
   class DBASE_ELEMENT;
   class OBJECT;
   class OBJITEM;
   class OBJITEMLIST;
   }
namespace MGD {
   class DEVICE;
   }
namespace SPATMOD {
   namespace IMAGE {
      class STAGE_ARRAY;
      }
   }
namespace MGUI {
   class DLGSHELL;
   class MENU;
   class DLG_GETOBJECT_FILTER;
   }
#endif   // GENERATING_DOXYGEN_OUTPUT


namespace GRE {

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

enum DISPFLAGS {
   DISPFLAG_None =                     0x00000000,
// DISPFLAG_SaveDrawnSetOBS =          0x00000001, // OBSOLETE, DO NOT USE, used in old dispparms
// DISPFLAG_KeepOpenOBS =              0x00000002, // OBSOLETE, DO NOT USE, used in old dispparms
   DISPFLAG_ExcludeFromGroupExtents =  0x00000004, 
// DISPFLAG_EditObjectOBS =            0x00000008, // OBSOLETE, DO NOT USE, used in old dispparms

   DISPFLAG_WarpToGeorefModel =        0x00000100, 
   DISPFLAG_UsesTransparency =         0x00000200, 
   DISPFLAG_NoDrawWireframe =          0x00000400, 
   DISPFLAG_MayUseTransparency =       0x00000800, 
   DISPFLAG_Antialias =                0x00001000, 
   DISPFLAG_HintThinLines =            0x00002000, 
   DISPFLAG_EnableMultiPassRender =    0x00004000, 
   DISPFLAG_NoMergeLegendDups =        0x00008000, 
   // Layer-specific flags use         0x0XXX0000

   DISPFLAG_NoDrawLabels =             0x40000000, 
   DISPFLAG_DrawLabelsOnly =           0x80000000, 

   // Layer-specific flags can use range of 0x0FFF0000.

   // Vector layer flags
   DISPFLAG_VectDrawNodes =            0x00010000, 
   DISPFLAG_VectLinesFirst =           0x00020000, 
   DISPFLAG_VectNoFillPoly =           0x00040000, 
   DISPFLAG_VectNoFillHighlighted =    0x00080000, 

   // TIN layer flags
   DISPFLAG_TINEdgesFirst =            0x00020000, 
   DISPFLAG_TINNoFillTri =             0x00040000, 

   // Raster layer flags
   DISPFLAG_RastNullTransp =           0x00010000, 
   DISPFLAG_RastSkipOddLines =         0x00020000, 
   DISPFLAG_RastSkipEvenLines =        0x00040000, 
   DISPFLAG_RastDoBlendMask =          0x00080000, 
   DISPFLAG_RastBlackTransp =          0x00100000, 
//                                     0x00200000, //   Used in legacy layouts, cannot reuse
   DISPFLAG_RastHyperspectLossy =      0x00400000, 
   DISPFLAG_RastWhiteTransp =          0x00800000, 
   DISPFLAG_RastLinesBetweenCells =    0x01000000, 
   DISPFLAG_RastLabelsInCells =        0x02000000, 

   // Surface layer flags
   DISPFLAG_SurfProjOffEdge =          0x00010000, 

   // Formula layer flags
   DISPFLAG_FormulaNullTransp =        0x00010000, 
   DISPFLAG_FormulaSkipOddLines =      0x00020000, 
   DISPFLAG_FormulaSkipEvenLines =     0x00040000, 
   };
#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(DISPFLAGS)
#endif

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

enum LAYERFLAGS {
   LAYERFLAG_None =                    0x00000000, 
   LAYERFLAG_NoSelNewObj =             0x00000010, 
   LAYERFLAG_HiliteColorSet =          0x00000040, 
   LAYERFLAG_DataTipIgnoreDrawnSet =   0x00000080, 
   LAYERFLAG_NoInvalidateViews =       0x00000100, 
   LAYERFLAG_3D =                      0x00000200, 
   LAYERFLAG_KeepOpen =                0x00020000, 
   LAYERFLAG_Editable =                0x00040000, 
   LAYERFLAG_CanShowInLocator =        0x00100000, 
   LAYERFLAG_NoGeoreference =          0x00080000, 
   LAYERFLAG_NoDrawActiveElem =        0x01000000, 
   LAYERFLAG_NoShowInLayerMgr =        0x02000000, 
   LAYERFLAG_NoAllowHide =             0x04000000, 
   LAYERFLAG_NoAllowDelete =           0x08000000, 
   LAYERFLAG_Temporary =               0x10000000, 
   LAYERFLAG_MaskAll =                 0xFFFFFFFF, 
   };
#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(LAYERFLAGS)
#endif

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

enum LAYERDRAWFLAGS {
   LAYERDRAWFLAG_None =             0x0000,  
// LAYERDRAWFLAG_ClipTo =           0x0001,
   LAYERDRAWFLAG_Clip =             0x0002,  
   LAYERDRAWFLAG_NoClipToGroup =    0x0004,  
   LAYERDRAWFLAG_SaveToTemplate =   0x0008,  
   LAYERDRAWFLAG_MaskAll =          0xFFFF,  
   };
#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(LAYERDRAWFLAGS)
#endif

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

#define  GRE_MAXLAYERTYPES    32

class LAYER : public GRE::OBJECT {
   public:

      enum TYPE {
         TYPE_None =             0,
         TYPE_Raster =           1,
         TYPE_Vector =           2,
         TYPE_CAD =              3,
         TYPE_DBPinmap =         4,
         TYPE_MapGrid =          5,
         TYPE_ScaleBar =         6,
         TYPE_Text =             7,
         TYPE_Legend =           8,
         TYPE_TIN =              9,
         TYPE_Sketch =           10,
         TYPE_Region =           11,
         TYPE_Surface =          12,
         TYPE_Script =           13,
         TYPE_Formula =          14,
         TYPE_Legend2 =          15,
         TYPE_Shape =            16,
         TYPE_Image_SpatMod =    17,
         TYPE_Image_WMS =        18,
         TYPE_Generic =          19,
         TYPE_Image_ArcIMS =     20,
         TYPE_Image_Tileset =    21,
         TYPE_Lidar =            22,
         TYPE_KML =              23,
         TYPE_Image_BingMaps =   24,
         TYPE_COUNT
         // Check GRE_MAXLAYERTYPES when add new types
         };

      enum CREATEFLAGS {
         CREATEFLAG_None =             0x0000,
         CREATEFLAG_NoCallCreateCB =   0x0001,
         CREATEFLAG_Temporary =        0x0002,
         CREATEFLAG_NoSelNewObj =      0x0004,  
         CREATEFLAG_KeepOpen =         0x0008,  
         CREATEFLAG_Editable =         0x0010,  
         CREATEFLAG_NoGeoreference =   0x0020,  
         CREATEFLAG_IgnoreExtents =    0x0040,  
         CREATEFLAG_NoAllowDelete =    0x0080,  
         CREATEFLAG_NoControlPanel =   0x0100,  
         CREATEFLAG_NoComputePos =     0x0200,  
         CREATEFLAG_NoSetActive =      0x0400,  
         CREATEFLAG_NoShowInMgr =      0x0800,  
         CREATEFLAG_NoChangeGroupRenderCRS = 0x1000, 
         };

      enum DIMENSION {
         DIMENSION_Height  = 0,
         DIMENSION_Width   = 1
         };

      enum SETACTIVEFLAGS {
         SETACTIVEFLAG_None =          0x0000,
         SETACTIVEFLAG_First =         0x0001,
         SETACTIVEFLAG_Previous =      0x0002,
         SETACTIVEFLAG_Next =          0x0004,
         SETACTIVEFLAG_Last =          0x0008,
         SETACTIVEFLAG_KeepCurrent =   0x0010,  
         SETACTIVEFLAG_NoWrap =        0x0020,  
         SETACTIVEFLAG_UpdateScreen =  0x0040,  
         SETACTIVEFLAG_UpdateBuffers = 0x0080,  
         };

      enum SNAPTO {
         SNAPTO_EndPoint =    1,    
         SNAPTO_Vertex =      2,    
         SNAPTO_Element =     3,    
         };

      class GLOBALOPTIONS {      // LAYER::GLOBALOPTIONS
         public:

            class FORM;                         

            enum DFTNAMEMODE {
               DFTNAMEMODE_ObjectDesc =      0,    
               DFTNAMEMODE_ObjectName =      1,    
               DFTNAMEMODE_FileObjNames =    2     
               };

            GLOBALOPTIONS (
               );

         #ifdef X_NATIVE
            Widget CreateEditForm (
               Widget parent,
               const Arg *arglist,
               int argcount
               );
         #endif

            bool GetAntialiasing (
               ) const {return(m_Antialiasing); }

            bool GetAutoOpenDftTableOnSel (
               ) const { return (m_AutoOpenDftTableOnSel); }

            DFTNAMEMODE GetDftNameMode (
               ) const { return (m_DftNameMode); }

            bool GetDftRenderMultiPass (
               ) const { return (m_DftRenderMultiPass); }

            bool GetDftShowSystemTables (
               ) const { return (m_DftShowSystemTables); }

            bool GetForceGeorefAffine (
               ) const { return (m_ForceGeorefAffine); }

            bool GetHintThinLines (
               ) const {return(m_HintThinLines);}

            void IniRead ();

            void IniWrite () const;

            void SetAntialiasing (
               bool antialias
               ) { m_Antialiasing = antialias; }

            void SetAutoOpenDftTableOnSel (
               bool AutoOpenDftTableOnSel
               ) { m_AutoOpenDftTableOnSel = AutoOpenDftTableOnSel; }

            void SetDftNameMode (
               DFTNAMEMODE DftNameMode
               ) { m_DftNameMode = DftNameMode; }

            void SetDftShowSystemTables (
               bool DftShowSystemTables
               ) { m_DftShowSystemTables = DftShowSystemTables; }
               
            void SetForceGeorefAffine (
               bool ForceGeorefAffine
               ) { m_ForceGeorefAffine = ForceGeorefAffine; }
               
            void SetHintThinLines (
               bool hint
               ) { m_HintThinLines = hint;}

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            DFTNAMEMODE m_DftNameMode;
            bool m_AutoOpenDftTableOnSel;       
            friend class LAYER;
            bool m_Antialiasing;
            bool m_HintThinLines;
            bool m_DftRenderMultiPass;
            bool m_DftShowSystemTables;
            bool m_ForceGeorefAffine;

            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of LAYER::GLOBALOPTIONS

      class LEGENDREDRAWDISABLER {
         public:
            LEGENDREDRAWDISABLER (GRE::LAYER *layer);
            ~LEGENDREDRAWDISABLER ();
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            GRE::LAYER *m_layer;
            #endif
         };

      class COMMONPARM;
      class DISPPARM;

      class TYPEDEFN;
      class COMPINFO;
      class FILTER;
      class FILTER_EXCLUDE;

      static bool CanConstructFromObject (
         const RVC::OBJITEM& objitem
         );

      static ERRVALUE ConstructAndAssignObject (
         GRE::GROUP *group,                        
         LAYER::TYPE layertype,              
         const RVC::OBJITEM& objitem,           
         LAYER **retlayer = 0,               
         CREATEFLAGS createflags = LAYER::CREATEFLAG_None,  
         GRE::LISTPOS listpos = GRE::LISTPOS_Last, 
         LAYER *reflayer = 0                 
         );

   #ifdef USE_MGUI
      static ERRVALUE ConstructAndPromptObject (
         MDLGPARENT dlgparent,                  
         GRE::GROUP *group,                        
         LAYER::TYPE layertype,              
         LAYER **retlayer,                
         CREATEFLAGS createflags,               
         GRE::LISTPOS listpos,                  
         LAYER *reflayer,                    
         bool OpenSettings                      
         );
   #endif

      static ERRVALUE ConstructFromObject (
         GRE::GROUP *group,                     
         const RVC::OBJITEM& objitem,           
         LAYER **retlayer = 0,                  
         CREATEFLAGS createflags = CREATEFLAG_None,
         GRE::LISTPOS listpos = GRE::LISTPOS_Last, 
         LAYER *reflayer = 0,                
         MDLGPARENT dlgparent = 0                  
         );

      static ERRVALUE ConstructFromObjList (
         GRE::GROUP *group,                           
         const RVC::OBJITEMLIST& objlist,             
         MDLGPARENT dlgparent = 0,                    
         GRE::LISTPOS listpos = GRE::LISTPOS_After,   
         LAYER *reflayer = 0                          
         );

      static bool EditGlobalSettings (
         MDLGPARENT dlgparent
         );

      static GLOBALOPTIONS::DFTNAMEMODE GetDftNameMode (
         ) { return (s_GlobalOptions.m_DftNameMode); }

      static const GLOBALOPTIONS& GetGlobalOptions (
         ) { InitStatic(); return (s_GlobalOptions); }

      static UINT16 GetNumTypes (
         ) { return (s_NumTypes); }

      static const TYPEDEFN& GetTypeDefn (
         UINT16 idx
         ) { return (*s_TypeDefns[idx]); }

      static const TYPEDEFN* GetTypeDefn (
         TYPE layertype
         );

      static TEXTID GetTypeName (
         TYPE layertype
         );

   #ifdef USE_MGUI
      static ERRVALUE PromptGeoDatabasesAndConstruct (
         MDLGPARENT dlgparent,                  
         GRE::GROUP *group                      
         );
   #endif

   #ifdef USE_MGUI
      static ERRVALUE PromptObjects (
         MDLGPARENT dlgparent,                  
         RVC::OBJITEMLIST& objlist,             
         MGUI::DLG_GETOBJECT_STYLE dlgstyle = MGUI::DLG_GETOBJECT_STYLE_OnlyExisting,
         const MISTRING *pDlgTitle = 0          
         );
   #endif

   #ifdef USE_MGUI
      static ERRVALUE PromptObjectsAndConstruct (
         MDLGPARENT dlgparent,                  
         GRE::GROUP *group,                        
         MGUI::DLG_GETOBJECT_STYLE dlgstyle = MGUI::DLG_GETOBJECT_STYLE_AllowDuplicate|MGUI::DLG_GETOBJECT_STYLE_WebLayers,   
         GRE::LISTPOS listpos = GRE::LISTPOS_After,   
         LAYER *reflayer = 0
         );
   #endif

      static void RegisterLayerType (
         TYPEDEFN& typedefn
         );

      static void SetAutoOpenDftTableOnSel (
         bool AutoOpenDftTableOnSel
         ) { s_GlobalOptions.m_AutoOpenDftTableOnSel = AutoOpenDftTableOnSel; }

      static void SetDftNameMode (
         GLOBALOPTIONS::DFTNAMEMODE DftNameMode
         ) { s_GlobalOptions.m_DftNameMode = DftNameMode; }

      static void SetGlobalOptions (
         const GLOBALOPTIONS& options
         ) { s_GlobalOptions = options; }

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

      static SML::CLASSMEMBER* GetSMLClassMembers (
         );

      LAYER (
         GRE::GROUP *group,                           
         TYPE layertype,                           
         DISPPARM& dispparm,                       
         CREATEFLAGS createflags,                  
         GRE::LISTPOS listpos = GRE::LISTPOS_Last, 
         LAYER *reflayer = 0                    
         );

      virtual ~LAYER ();

   #ifdef X_NATIVE
      void AppendPopupMenuItems (
         Widget widget,                      
         const DPOINT2D *point,              
         MENUITEMARRAY& menuitems            
         ) { v_AppendPopupMenuItems(widget,point,menuitems); }
   #endif

      ERRVALUE AssignObject (
         const RVC::OBJITEM& objitem,           
         MDLGPARENT dlgparent = 0               
         ) { return (v_AssignObject(objitem,dlgparent)); }

      int CallDrawFilter (LAYERDC *ldc, const RVC::ELEMENT& element, void *vpStyle) {
         if (m_DrawFilter != 0) return (m_DrawFilter(ldc, element.GetType(), static_cast<INT32>(element.GetNumber()), vpStyle));
         return (1);
         }
      
      int CallDrawFilter (LAYERDC *ldc, ELEMTYPE ElemType, INT32 ElemNum, void *vpStyle) {
         if (m_DrawFilter != 0) return (m_DrawFilter(ldc, ElemType, ElemNum, vpStyle));
         return (1);
         }

      bool CanGetElemExtents (
         ) const { return (m_CanGetElemExtents); }

      bool CanOpenControlPanel (
         ) const { return (!m_IsControlPanelDisabled); }

      bool CanRender (
         ) const { return (v_CanRender()); }

      bool CanReportRawElemInfo (
         ) const { return (m_CanReportRawElemInfo); }

      bool CanShowDetails (
         ) const { return (v_CanShowDetails()); }

      bool CanShowInView (
         const VIEW *view = 0          
         ) const;

      bool CanTestElementByRegion (
         ) const { return (m_CanTestElementByRegion); }

      bool CanViewIn2D () const;

      bool CanViewIn3D () const
         { return (m_CanViewIn3D); }

      bool CanViewStereo2D () const
         { return (m_CanViewStereo2D && CanViewIn2D()); }
      
      bool CanZoomToMaxDetail (
         ) const;

      bool ChangeListPos (
         LAYER* reflayer,                    
         GRE::LISTPOS listpos                   
         );

      ERRVALUE CheckDenseDetail (
         MDLGPARENT dlgparent                   
         );

      void CloseObject (
         ) { v_CloseObject(); };

      double ComputeDftMaxVisibleScale () const
         { return (v_ComputeDftMaxVisibleScale()); }

      void ComputeMargins (
         double& tmargin,                       
         double& bmargin,                       
         double& lmargin,                       
         double& rmargin                        
         ) { v_ComputeMargins(tmargin,bmargin,lmargin,rmargin); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
      // Construct LAYERSECTION instance for this layer and specified view.
      GRE::LAYERSECTION* ConstructLayerSection (
         GRE::VIEW *view
         ) { return (v_ConstructLayerSection(view)); }
   #endif
   
   #ifndef GENERATING_DOXYGEN_OUTPUT
      // Construct LAYERVIEW instance for this layer and specified view.
      GRE::LAYERVIEW* ConstructLayerView (
         GRE::VIEW *view
         ) { return (v_ConstructLayerView(view)); }
   #endif
   
      LAYER* Copy (
         GRE::GROUP* NewGroup
         ) const { return (v_Copy(NewGroup)); }

      void DataTipCloseTables (
         );

      void DataTipGetDefaultPrefix (
         int component,                         
         DATATIPPARMS& DataTipParms             
         ) const { v_DataTipGetDefaultPrefix(component,DataTipParms); }

      void DataTipGetObjectNamesString (
         const DPOINT2D& point,
         MISTRING& string,
         int indent = 0,
         GRE::VIEW *view = 0           
         ) const { return (v_DataTipGetObjectNamesString(point, string, indent, view)); }

      const DATATIPPARMS *DataTipGetParms (
         int component                          
         ) const { return (v_DataTipGetParms(component)); }

      int DataTipGetSearchDist (
         ) const;

      int DataTipGetString (
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                          
         MISTRING& string,                      
         SPATMOD::IMAGE::STAGE_ARRAY& images    
         ) { return (v_DataTipGetString(ElemType,ElemNum,string,images)); }

      int DataTipGetString (
         const DPOINT2D& point,                 
         MISTRING& string,                      
         SPATMOD::IMAGE::STAGE_ARRAY& images,   
         GRE::VIEW *view = 0                    
         ) { return (v_DataTipGetString(point,string,images,view)); }

      bool DataTipHasAvailable (
         ) const { return (v_DataTipHasAvailable()); }

      bool DataTipHasEnabled (
         ) const { return (v_DataTipHasEnabled()); }

      bool DataTipIsEnabled (
         ) const { return (m_DataTipEnabled); }

      void DataTipSetDefault (
         bool force = false                     
         );

      void DataTipSetDefault (
         int component,                         
         bool force = false                     
         );

      void DataTipSetDefaultPrefix (
         int component                          
         );

      ERRVALUE DataTipSetParms (
         int component,                         
         const DATATIPPARMS& DataTipParms       
         ) { return (v_DataTipSetParms(component,DataTipParms)); }

      ERRVALUE DataTipSetTableField (
         int component,
         const RVC::OBJECTNAME& TableName,      
         const RVC::OBJECTNAME& FieldName       
         );

      ERRVALUE DataTipSetTableField (
         int component,
         const char *TableName,                 
         const char *FieldName                  
         );

      ERRVALUE DataTipSetVisible (
         int component,
         bool visible
         );

      INT32 DbListElemNumToIndex (
         int component,
         ELEMNUM ElemNum
         ) { return (v_DbListElemNumToIndex(component,ElemNum)); }

      bool DbListIsIndexElemNum (
         ) const { return (m_DbListIsIndexElemNum); }

      void DestroyAllLayerViews (
         );

      void DisableControlPanel (
         ) { m_IsControlPanelDisabled = true; }

   #ifdef USE_MGUI
      void DlgDataTipSettings (
         MDLGPARENT dlgparent
         );
   #endif

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

      ERRVALUE Draw (
         LAYERDC& layerdc                       
         ) { return (v_Draw(layerdc)); }

      ERRVALUE DrawAllViews (
         GRE::DRAWCONDITION condition = GRE::DRAWCONDITION_Always
         );

      ERRVALUE DrawElement (
         GRE::VIEW *view,                       
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                          
         GRE::RENDERTARGET Target,              
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

      ERRVALUE DrawElement (
         GRE::VIEW *view,                       
         const RVC::ELEMENT& element,           
         GRE::RENDERTARGET Target,              
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         ) { return (DrawElement(view,element.GetType(),element.GetNumber(),Target,drawflags)); }

      ERRVALUE DrawElementLow (
         LAYERDC& layerdc,                      
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                          
         const void *style = 0                  
         ) { return (v_DrawElementLow(layerdc,ElemType,ElemNum,style)); }

      ERRVALUE DrawElements (
         GRE::VIEW *view,                       
         ELEMTYPE ElemType,                     
         const UNSIGNEDSET *pElemSet,           
         GRE::RENDERTARGET Target,              
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

      ERRVALUE DrawElementsLow (
         LAYERDC& layerdc,                      
         ELEMTYPE ElemType,                     
         const UNSIGNEDSET *pElemSet,           
         const void *style = 0                  
         ) { return (v_DrawElementsLow(layerdc,ElemType,pElemSet,style)); }

      ERRVALUE DrawElementSample (
         const GRE::ELEMSAMPLE_DC& sampledc,    
         const RVC::ELEMENT& element,           
         const LRECT2D& samplerect              
         ) { return (v_DrawElementSample(sampledc,element,samplerect)); }

      ERRVALUE DrawHighlighted (
         GRE::VIEW *view,                       
         GRE::DRAWFLAGS DrawFlags = GRE::DRAWFLAG_None
         );

      ERRVALUE DrawLabel (
         LAYERDC& layerdc,                      
         const GRE::LABELPLACE& place,
         const COLOR* ForegroundColor = 0       
         );

      ERRVALUE DrawLabels (
         LAYERDC& layerdc                       
         );

      ERRVALUE DrawOverlay (
         LAYERDC& layerdc                       
         ) { return (v_DrawOverlay(layerdc)); }

      void EditColors (
         MDLGPARENT dlgparent                   
         );

      void EnableDataTip (
         bool enable = true
         ) { m_DataTipEnabled = enable; return; }

      ERRVALUE EstimateRangeZ (
         const LAYERVIEW *pLayerView,           
         DOUBLE_RANGE& range                    
         ) const;

      ELEMNUM FindClosestElement (
         const DPOINT2D& point,                 
         double searchdist,                     
         double *distret,                       
         int component,                         
         const UNSIGNEDSET *pSearchSet,         
         GRE::FINDFLAGS findflags               
         ) { return (v_FindClosestElement(point,searchdist,distret,component,pSearchSet,findflags)); }

      INT64 FindElementsByQuery (
         ELEMTYPE ElemType,                     
         UNSIGNEDSET& ElemSet,                  
         const MIUNICODE *QueryScript,          
         SML::CONTEXT *pQueryContext = 0        
         );

      ERRVALUE FindElementsByQueryExt (
         ELEMTYPE ElemType,                     
         SIMPLE_ARRAY<UINT8>& Result,           
         const MIUNICODE *QueryScript,          
         SML::CONTEXT *pQueryContext = 0        
         );

      LAYER_SURFACE* FindSurfaceLayer (
         ) const;

   #ifndef GENERATING_DOXYGEN_OUTPUT
      // Make protected when possible.
      void FinishCreation (
         bool notify = true                     
         );

   #endif // GENERATING_DOXYGEN_OUTPUT

      const RVC::ELEMENT& GetActiveElement () const
         { return (m_ActiveElem); }

      bool GetActiveElement (
         RVC::ELEMENT& element                  
         ) const;

      ELEMNUM GetActiveElemNum (
         ) const { return (m_ActiveElem.GetNumber()); }

      ELEMTYPE GetActiveElemType (
         ) const { return (m_ActiveElem.GetType()); }

      const COLOR& GetColorPedestal (
         ) const;

      int GetComponent (
         ELEMTYPE ElemType                      
         ) const { return (v_GetComponent(ElemType)); }

      MICONSTRUCT* GetComponentIcon (
         int component                          
         ) const { return (v_GetComponentIcon(component)); }

      COMPINFO* GetComponentInfo (
         int component                          
         ) { return (v_GetComponentInfo(component)); }

      const COMPINFO* GetComponentInfo (
         int component
         ) const { return (const_cast<LAYER*>(this)->GetComponentInfo(component)); }

      COMPINFO* GetComponentInfoByType (
         ELEMTYPE elemtype                      
         );

      MISTRING GetComponentName (
         int component                          
         ) const { return (v_GetComponentName(component)); }

      DISPFLAGS GetDispFlags (
         ) const;

      RVC::DISPPARMUSAGE GetDispParmUsage (
         ) const { return ((layerflags & LAYERFLAG_Editable) ? RVC::DISPPARMUSAGE_Edit : RVC::DISPPARMUSAGE_Display); }

      const void* GetElemDefaultStyle (
         ELEMTYPE ElemType                      
         ) const { return (v_GetElemDefaultStyle(ElemType)); }

      UINT16 GetElemDrawSelectionMode (
         ELEMTYPE ElemType                      
         ) const { return (v_GetElemDrawSelectionMode(ElemType)); }

      UINT16 GetElemDrawStyleMode (
         ELEMTYPE ElemType                      
         ) const { return (v_GetElemDrawStyleMode(ElemType)); }

      ERRVALUE GetElemExtents (
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                          
         DRECT3D& Extents                       
         ) { return (v_GetElemExtents(ElemType,ElemNum,Extents)); }

      GRE::HIGHLIGHTMODE GetElemHighlightMode (
         ) const;

      UNSIGNEDSET* GetElemHighlightSet (
         ELEMTYPE ElemType = ELEMTYPE_All       
         );

      ERRVALUE GetElemSetExtents (
         ELEMTYPE ElemType,                     
         const UNSIGNEDSET& ElemSet,            
         DRECT3D& Extents                       
         );

      ELEMTYPE GetElemType (
         int component                          
         ) const { return (v_GetElemType(component)); }

      const DRECT3D& GetExtents (
         ) const { return (m_ObjRegion.GetExtents()); }

      GRE::GROUP * GetGroup (
         ) const { return (m_group); }

      bool GetGeorefName (
         RVC::OBJECTNAME& gname,
         int component = 0                      
         ) const { return (v_GetGeorefName(gname,component)); }

      LAYERDRAWFLAGS GetLayerDrawFlags (
         ) const { return (static_cast<LAYERDRAWFLAGS>(m_drawflags)); }

      LAYERFLAGS GetLayerFlags (
         ) const { return (static_cast<LAYERFLAGS>(layerflags)); }

      TYPE GetLayerType (
         ) const { return (m_layertype); }

      const GRE::LEGEND* GetLegend (
         ELEMTYPE ElemType = ELEMTYPE_Empty     
         ) { return (v_GetLegend(ElemType)); }

   #ifdef X_NATIVE
      GraphicTreeItemMsgHandler GetLegendMsgHandler (
         ) const { return (m_LegendMsgHandler); }
   #endif

      int GetListPos (
         );

      const SPATREF::COORDREFSYS& GetMapCoordRefSys (
         ) const { return (GetMapRegion().GetCoordRefSys()); }

      const REGION2D& GetMapRegion (
         ) const { return (m_MapRegion); }

      double GetMapScale (
         ) const;

      UINT8 GetMaskBlue (
         ) const { return (m_MaskBlue); }

      UINT8 GetMaskGreen (
         ) const { return (m_MaskGreen); }

      UINT8 GetMaskRed (
         ) const { return (m_MaskRed); }

      double GetMaxScaleVisible (
         bool IncludeGroup = false              
         ) const;

      double GetMinScaleVisible (
         bool IncludeGroup = false              
         ) const;

      UINT32 GetModifyStamp (
         ) const { return (m_ModifyStamp); }

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

   #ifndef NO_DEPRECATED
      DEPRECATED void GetName (
         MISTRING& retname
         ) { retname = m_Name; }
   #endif

      LAYER* GetNext (
         ) const { return (m_nextlayer); }

      int GetNumComponents (
         ) const;

      INT64 GetNumElements (
         ELEMTYPE ElemType                      
         ) { return (v_GetNumElements(ElemType)); }

      INT64 GetNumElementsDeleted (
         ELEMTYPE ElemType                      
         ) { return (v_GetNumElementsDeleted(ElemType)); }

      int GetNumObjects (
         ) const;

      const RVC::OBJITEM& GetObjItem (
         int component = 0                      
         ) const { return (v_GetObjItem(component)); }

      const REGION2D& GetObjRegion (
         ) const { return (m_ObjRegion); }

      LAYER* GetPrevious (
         ) const { return (m_prevlayer); }

      double GetScaleMaxDetail (
         const DPOINT2D& point,                 
         const SPATREF::COORDREFSYS& crs,       
         double DisplayPixelSizeMM              
         ) const;

      void GetSizeMeters (
         double& xsize,
         double& ysize
         ) const;

      ERRVALUE GetStyleInfo (
         ELEMTYPE ElemType,                     
         RVC::OBJITEM& ObjItem,                 
         RVC::OBJECTNAME& TableName             
         ) { return (v_GetStyleInfo(ElemType,ObjItem,TableName)); }

      void GetTransGroup (
         TRANS2D_MAPGEN& trans                  
         ) const;

      void GetTransMap (
         TRANS2D_MAPGEN& trans,                 
         bool setoutput                         
         ) const;

      const TYPEDEFN& GetTypeDefn (
         ) const { return (*GetTypeDefn(m_layertype)); }

      UINT32 GetUniqueID (
         ) const { return (m_UniqueID); }

      GRE::VIEWABLE* GetViewable (
         ) const;

      double GetViewMapScale (
         ) const;

      UINT32 GetVisibleGroup (
         ) const { return (m_VisibleViewGroup); }

      UINT32 GetVisibleLayout (
         ) const { return (m_VisibleViewLayout); }

      void GetVisibleScaleRange (
         double& MinScaleVisible,               
         double& MaxScaleVisible,               
         bool IncludeGroup = false              
         ) const;

      UINT32 GetVisibleViewable (
         ) const;

      const COLOR& GetWireframeColor (
         ) const;

      double GetZOffset (
         ) const;

      void GetZRangeScaled (
         DOUBLE_RANGE& zrange
         ) const;

      bool HasActiveElement ();

      bool HasColorMasks (
         ) const { return (m_MaskRed != 0 || m_MaskGreen != 0 || m_MaskBlue != 0); }

      bool HasDrawFilter (
         ) const { return (m_DrawFilter != 0); }

      bool HasDispParmSubObject () const
         { return (v_HasDispParmSubObject()); }

      bool HasHighlighted (
         ) const { return (v_HasHighlighted()); }

      bool HasLegend (
         ) const { return (v_HasLegend()); }

      bool HasNullImageCells (
         ) const { return (v_HasNullImageCells()); }

      bool HasValidExtents (
         ) const { return (m_HasExtents); }

      int HighlightElement (
         ELEMTYPE ElemType,
         ELEMNUM ElemNum,
         GRE::HIGHLIGHTMODE HighlightMode,
         GRE::VIEW *firstview = 0,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

      int HighlightElements (
         ELEMTYPE ElemType,
         const UNSIGNEDSET *pElemSet,                    
         GRE::HIGHLIGHTMODE HighlightMode,
         GRE::VIEW *firstview = 0,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

      int HighlightElementsByQuery (
         ELEMTYPE ElemType,
         SML::CONTEXT* QueryContext,
         int QuerySegment,
         const MIUNICODE* QueryScript,
         GRE::VIEW *firstview = 0,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

      int HighlightElementsByRegion (
         ELEMTYPE ElemType,
         const REGION2D& Region,
         TESTCRITERIA RegionTest,
         GRE::VIEW *firstview = 0,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

      void IncrementModifyStamp (
         ) { ++m_ModifyStamp; }

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

      bool IsAntialiased (
         ) { return (v_IsAntialiased()); }

      bool IsBeingCreated (
         ) const { return (m_IsBeingCreated); }

      bool IsComponentSelectable (
         int component
         ) const;

      bool IsEditable (
         ) const { return ((layerflags & LAYERFLAG_Editable) != 0); }

      bool IsExcludedFromGroupExtents () const;

      bool IsLineWidthHinted (
         ) const { return (v_IsLineWidthHinted()); }

      bool IsManagingPointSymbols () const;

      bool IsProportionVariable (
         DIMENSION dimension
         ) const { return (v_IsProportionVariable(dimension)); }

      bool IsRemote (
         ) const;

      bool IsSortLegendNatural (
         ) const;

      bool IsTableUsableForComponent (
         int component,
         const RVC::DBTABLE& table
         ) const { return (v_IsTableUsableForComponent(component,table)); }

      bool IsValid (
         ) const;

      bool IsVisibleAtScale (
         double scale
         ) const;

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

   #ifdef USE_MGUI
      void MenuAddElemTypeItems (
         MGUI::MENU& menu,                         
         ELEMTYPE ElemType                         
         ) { v_MenuAddElemTypeItems(menu,ElemType); }
   #endif

   #ifdef USE_MGUI
      void MenuAddLayerItems (
         MGUI::MENU& menu                          
         ) { v_MenuAddLayerItems(menu); }
   #endif

   #ifdef USE_MGUI
      void MenuAddRegionGenItems (
         MGUI::MENU& menu,                         
         ELEMTYPE ElemType                         
         ) { v_MenuAddRegionGenItems(menu,ElemType); }
   #endif

   #ifdef USE_MGUI
      void MenuAddViewPopupItems (
         MGUI::MENU& menu,                         
         const DPOINT2D *point,                    
         VIEW *view                                
         ) { v_MenuAddViewPopupItems(menu,point,view); }
   #endif

      void NotifySurfaceChanged (
         ) { v_OnNotifySurfaceChanged(); }

   #ifdef USE_MGUI
      int OpenControlPanel (
         MDLGPARENT dlgparent,
         bool AddingLayer = false
         );
   #endif

      int OpenObject (
         MDLGPARENT dlgparent = 0               
         ) { return (v_OpenObject(dlgparent)); }

      ERRVALUE PanViewToElement (
         GRE::VIEW *view,                       
         ELEMTYPE ElemType,
         ELEMNUM ElemNum,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None   
         );

   #ifdef USE_MGUI
      ERRVALUE PromptObject (
         bool OpenCtrlPanel = false,            
         MDLGPARENT dlgparent = 0               
         ) { return (v_PromptObject(OpenCtrlPanel,dlgparent)); }
   #endif

      ERRVALUE ReportRawElemInfo (
         MISTRING& infostr,                     
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum                           
         ) { return (v_ReportRawElemInfo(infostr,ElemType,ElemNum)); }

      ERRVALUE SaveDispParmSubObject (
         RVC::DISPPARMUSAGE usage = RVC::DISPPARMUSAGE_Unspecified
         ) { return (v_SaveDispParmSubObject(usage)); }

      ERRVALUE SaveDispParmSubObject (
         const RVC::OBJITEM& ParentObjItem,        
         RVC::DISPPARMUSAGE usage = RVC::DISPPARMUSAGE_Unspecified
         );

      void ScalePointZ (
         DPOINT3D& pt                     
         ) const;

      void ScalePointsZ (
         POLYLINE& polyline               
         ) const;

      ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         ) const { return (v_SerialWrite(serializer,tagname)); }

      int SetActiveElement (
         ELEMTYPE ElemType,
         ELEMNUM ElemNum,
         SETACTIVEFLAGS flags = SETACTIVEFLAG_None
         );

      void SetAntialiased (
         bool antialias
         ) { v_SetAntialiased(antialias); }

      bool SetColorActive (
         const COLOR& color
         );

      bool SetColorHighlight (
         const COLOR& color
         );

      void SetColorMasks (
         UINT8 MaskRed,
         UINT8 MaskGreen,
         UINT8 MaskBlue
         ) { m_MaskRed = MaskRed; m_MaskGreen = MaskGreen; m_MaskBlue = MaskBlue; }

      void SetColorPedestal (
         const COLOR& color
         );

      void SetComponentSelectable (
         int component,
         bool selectable = true
         );

      void SetDftName (
         bool ReplaceExisting = false           
         ) { v_SetDftName(ReplaceExisting); }

      void SetDispFlags (
         DISPFLAGS flags,
         DISPFLAGS mask
         );

      void SetDrawFilter (
         int (*DrawFilter)(LAYERDC*, ELEMTYPE, INT32, void*)
         ) { m_DrawFilter = DrawFilter; }

      void SetDrawFlags (
         LAYERDRAWFLAGS flags,                  
         LAYERDRAWFLAGS mask                    
         );

      void SetElemDrawSelectionMode (
         ELEMTYPE ElemType,                     
         UINT16 SelectMode                      
         ) { v_SetElemDrawSelectionMode(ElemType,SelectMode); }

      void SetElemDrawStyleMode (
         ELEMTYPE ElemType,                     
         UINT16 StyleMode                       
         ) { v_SetElemDrawStyleMode(ElemType,StyleMode); }

      void SetExcludedFromGroupExtents (
         bool excluded,
         bool notify = true
         );

      void SetExtentsChanged (
         ) { m_HasExtents = false; }

      void SetFlags (
         LAYERFLAGS flags,                      
         LAYERFLAGS mask,                       
         bool notify = true                     
         );

      void SetFuncRemoveCheck (
         int (*RemoveCheckFunc)(LAYER*,void*),
         void *RemoveCheckData
         ) { m_RemoveCheckFunc = RemoveCheckFunc; m_RemoveCheckData = RemoveCheckData; }

      void SetHintThinLines (
         bool hint
         ) { v_SetHintThinLines(hint); }

      void SetKeepOpen (
         bool KeepOpen = true
         ) { if (KeepOpen) this->layerflags |= LAYERFLAG_KeepOpen; else this->layerflags &= ~LAYERFLAG_KeepOpen; }

      void SetLegendChanged (
         bool notify = true                     
         ) {
         if (notify) CallbackInvoke(GRE::MSG::ACTION_ChangeBegin);
         m_LegendValid = false;
         if (notify) CallbackInvoke(GRE::MSG::ACTION_ChangeEnd);
         return;
         }

      void SetLegendSampleFlags (
         MGD::STYLESAMPLEFLAGS SampleFlags               
         ) { v_SetLegendSampleFlags(SampleFlags); }

      void SetListPos (
         GRE::LISTPOS listpos,                  
         LAYER *reflayer = 0                    
         );

      void SetListPos (
         int newpos                          
         );

      void SetModified (
         bool notify = true                  
         );

      void SetName (
         const MISTRING& name
         );

      void SetName (
         const RVC::OBJITEM& objitem
         );

      void SetNotifyGroup (
         bool notify = true
         ) { m_NoSetModGroup = !notify; }

      void SetObjectDescriptor (
         int component,
         const RVC::DESCRIPTOR& descriptor
         ) { v_SetObjectDescriptor(component,descriptor); }

      void SetRenderSize (
         DIMENSION dimension,
         double size
         ) { v_SetRenderSize(dimension, size); }

      ERRVALUE SetStyleObjItem (
         const RVC::OBJITEM& ObjItem            
         ) { return (v_SetStyleObjItem(ObjItem)); }

      void SetTransMap (
         const TRANS2D_MAPGEN& trans,           
         bool fromoutput = false                
         );

      void SetUniqueID (
         UINT32 UniqueID
         ) { m_UniqueID = UniqueID; }

      void SetVisibilityGroupFromLayout (
         ) { m_VisibleViewGroup = m_VisibleViewLayout; }

      void SetVisibleGroup (
         UINT32 flags,
         bool set
         );

      void SetVisibleLayout (
         UINT32 flags,
         bool set
         );

      void SetVisibleScaleRange (
         double MinScaleVisible,
         double MaxScaleVisible
         );

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

      void SetVisibleViewable (
         UINT32 flags,
         bool set
         );

      void SetZScaleOffset (
         double zscale,
         double zoffset
         );

      int SnapPoint (
         DPOINT3D& ptObject,                    
         SNAPTO SnapTo,                         
         double MaxDistance,                    
         VIEW *view = 0                         
         ) const { return (v_SnapPoint(ptObject,SnapTo,MaxDistance,view)); }

      bool SnapPointIsAllowed (
         SNAPTO SnapTo
         ) const { return (v_SnapPointIsAllowed(SnapTo)); }

      ERRVALUE TemplateRead (
         SERIALIZER& serializer
         ) { return (v_TemplateRead(serializer)); }

      int TestElementByRegion (
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                       
         const REGION2D& Region,                
         TESTCRITERIA TestMode,                 
         bool RegionInObjectCoords = true       
         );

   #ifdef USE_MGUI
      void TreeViewAddUpdateDetails (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndParent,
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter
         );
   #endif

   #ifdef USE_MGUI
      MGUI::CTRL_TREE::ITEMHND TreeViewAddUpdateLegend (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndParent,
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter
         );
   #endif

   #ifdef USE_MGUI
      MGUI::CTRL_TREE::ITEMHND TreeViewInsertItem (
         GRE::CTRL_TREEVIEW& TreeView,             
         MGUI::CTRL_TREE::ITEMHND hndParent,       
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter   
         );
   #endif

   #ifdef USE_MGUI
      void TreeViewSetStateImage (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndLayerItem = MGUI::CTRL_TREE::ITEMHND_None
         );
   #endif

   #ifdef USE_MGUI
      void TreeViewUpdateDetails (
         );
   #endif

      void UnhighlightAllElements (
         bool redraw                               
         );

      ERRVALUE UpdateExtents (
         bool forceupdate = false                  
         );

      bool UsesTransparency (
         const MGD::DEVICE *pDevice = 0      
         ) const { return (v_UsesTransparency(pDevice)); }

      ERRVALUE ZoomViewToSelectedElements (
         GRE::VIEW *view,                       
         bool activeonly = false
         );

   protected:

      static const SERIALIZERITEM* SerialGetItemDef (SERIALIZER& serializer);

      static void SMLGET_DispParmMember (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLGET_LayerDispFlag (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLGET_LayerFlag (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLGET_StyleObject (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);

      static void SMLSET_DispParmMember (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLSET_DispParmMemberExtChg (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLSET_LayerDispFlag (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLSET_LayerFlag (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLSET_StyleObject (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLSET_OldProj (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLSET_TextStyleMember (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);

      bool m_CanGetElemExtents;
      bool m_CanReportRawElemInfo;
      bool m_CanTestElementByRegion;
      bool m_HasExtents;
      bool m_LegendValid;
      bool m_DbListIsIndexElemNum;
      UINT8 m_CurPage;                       
      UINT32 layerflags;                     
      REGION2D m_ObjRegion;                  
      REGION2D m_MapRegion;                  
      TRANS2D_MAPGEN m_TransObjToMap;        
      RVC::ELEMENT m_ActiveElem;
      int (*m_DrawFilter)(LAYERDC*, ELEMTYPE, INT32, void*);
      GraphicTreeItemMsgHandler m_LegendMsgHandler;   

      RVC::DBTABLE* DataTipGetTable (
         int component                       
         ) const;

      ERRVALUE DataTipOpenTable (
         int component                       
         );

      void ResetAllElementSets (
         );

      const char* SerialGetTagName (
         ) const { return (v_SerialGetTagName()); }

      void SetCanViewIn2D (bool canview)
         { m_CanViewIn2D = canview; }

      void SetCanViewIn3D (bool canview)
         { m_CanViewIn3D = canview; }

      void SetCanViewStereo2D (bool canview)
         { m_CanViewStereo2D = canview; }

      void SetLayerType (
         TYPE layertype
         ) { m_layertype = layertype; }

   #ifdef USE_MGUI
      virtual void v_MenuAddElemTypeItems (MGUI::MENU& menu, ELEMTYPE ElemType);
      virtual void v_MenuAddLayerItems (MGUI::MENU& menu);
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static void InitStatic ();
      static ERRVALUE SerializerCB_MaxScaleVisible (SERIALIZER&, const SERIALIZERITEM *, void *, SERIALIZERITEM::ACTION);
      static ERRVALUE SerializerCB_MinScaleVisible (SERIALIZER&, const SERIALIZERITEM *, void *, SERIALIZERITEM::ACTION);
      static void SMLSET_ScaleRange (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);
      static void SMLFUNC_ShowDetails (SML::CONTEXT*, SML::CLASSMEMBER*, void*, SML::ARG*);

      static bool s_InitDone;
      static GLOBALOPTIONS s_GlobalOptions;
      static TYPEDEFN *s_TypeDefns[GRE_MAXLAYERTYPES];
      static UINT16 s_NumTypes;              // Number of layer types

      LAYER *m_prevlayer;                    // Previous layer in group
      LAYER *m_nextlayer;                    // Next layer in group
      GRE::GROUP *m_group;                   // Pointer to group for this layer
      TYPE m_layertype;                      // Layer type
      MISTRING m_Name;                       // Layer name
      UINT32 m_drawflags;                    // LAYERDRAWFLAG_xxxxx (saved with layout)
      UINT32 m_VisibleViewGroup;             // Bits for whether layer is visible in group views
      UINT32 m_VisibleViewLayout;            // Bits for whether layer is visible in layout views
      bool m_IsControlPanelDisabled;
      bool m_IsBeingCreated;
      bool m_NoSetModGroup;                  // Don't set group as "modified" when changes made to layer
      bool m_CanViewIn2D;
      bool m_CanViewIn3D;
      bool m_CanViewStereo2D;
      CREATEFLAGS m_CreationFlags;           // Flags specified in constructor
      UINT8 m_MaskRed;                       // Color masks used for specialized displays (eg. anaglyphs)
      UINT8 m_MaskGreen;
      UINT8 m_MaskBlue;
      UINT8 m_DataTipDftPage;
      bool m_DataTipEnabled;
      DISPPARM *m_pDispParm;                 // Layer object display parameters, points to subclass member
      int (*m_RemoveCheckFunc)(LAYER*,void*);
      void *m_RemoveCheckData;
      UINT32 m_UniqueID;                     // Unique layer ID
      UINT32 m_ModifyStamp;
      RVC::DBTABLE *m_pObjTableDataTip[5];

      ERRVALUE CheckUserRemove ();
      bool HasDenseDetail () const
         { return (v_HasDenseDetail()); }
      void RestoreViewsFromBuffers (GRE::DRAWFLAGS drawflags, GRE::VIEW *view = 0);
   #ifdef USE_MGUI
      unsigned int TreeViewComputeStateIdx (GRE::VIEW*, bool skiplocator = false) const;
      void TreeViewOnChangePosition (GRE::CTRL_TREEVIEW& TreeView, MGUI::CTRL_TREE::ITEMHND hndLayerItem);
      bool TreeViewOnChildVisibilityChanging (GRE::CTRL_TREEVIEW& TreeView, MGUI::CTRL_TREE::ITEMHND hndLayerItem, MGUI::CTRL_TREE::CHILDVISIBILITY visibility);
      MGUI::CUSTOMDRAW::RETVALUE TreeViewOnCustomDraw (GRE::CTRL_TREEVIEW& TreeView, MGUI::CUSTOMDRAW_TREE& CustomDraw);
      void TreeViewOnGetItemInfo (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMVALUES, MGUI::CTRL_TREE::ITEMINFO&);
      bool TreeViewOnPointerButton (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, MGUI::CTRL_TREE::HITRESULT, const LPOINT2D&, MGUI::POINTERBUTTON, MGUI::KEYSTATE);
      bool TreeViewOnToolTipRequest (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, MGUI::CTRL_TREE::HITRESULT, const LPOINT2D&, MGUI::CTRL_TOOLTIP&);
      void TreeViewPopupMenu (GRE::CTRL_TREEVIEW&, const LPOINT2D& MousePoint);
   #endif
      void UpdateMapRegion ();

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

      // LAYER overridables.

   #ifdef X_NATIVE
      virtual void v_AppendPopupMenuItems (Widget widget, const DPOINT2D *point, MENUITEMARRAY& menuitems);
   #endif
      virtual ERRVALUE v_AssignObject (const RVC::OBJITEM& objitem, MDLGPARENT dlgparent);
      virtual bool v_CanRender () const;
      virtual bool v_CanShowDetails () const;
      virtual void v_CloseObject ();
      virtual double v_ComputeDftMaxVisibleScale () const;
      virtual void v_ComputeMargins (double& tmargin, double& bmargin, double& lmargin, double& rmargin);
   #ifdef USE_MGUI
      virtual int v_ControlPanel (MDLGPARENT dlgparent, UINT32 flags = 0) = 0;
   #endif
      virtual GRE::LAYERSECTION* v_ConstructLayerSection (GRE::VIEW *view);
      virtual GRE::LAYERVIEW* v_ConstructLayerView (GRE::VIEW *view);
      virtual LAYER* v_Copy (GRE::GROUP *NewGroup) const = 0;
      virtual void v_DataTipGetDefaultPrefix (int component, DATATIPPARMS& DataTipParms) const;
      virtual void v_DataTipGetObjectNamesString (const DPOINT2D& point, MISTRING& string, int indent, GRE::VIEW *view) const;
      virtual const DATATIPPARMS* v_DataTipGetParms (int component) const;
      virtual int v_DataTipGetString (ELEMTYPE ElemType, ELEMNUM ElemNum, MISTRING& string, SPATMOD::IMAGE::STAGE_ARRAY& images);
      virtual int v_DataTipGetString (const DPOINT2D& point, MISTRING& string, SPATMOD::IMAGE::STAGE_ARRAY& images, GRE::VIEW* view);
      virtual bool v_DataTipHasAvailable () const;
      virtual bool v_DataTipHasEnabled () const;
      virtual void v_DataTipSetDefault (int component, bool force);
      virtual ERRVALUE v_DataTipSetParms (int component, const DATATIPPARMS& DataTipParms);
      virtual INT32 v_DbListElemNumToIndex (int component, ELEMNUM ElemNum);
      virtual ERRVALUE v_Draw (LAYERDC& layerdc) = 0;
      virtual ERRVALUE v_DrawElementLow (LAYERDC& layerdc, ELEMTYPE ElemType, ELEMNUM ElemNum, const void *style);
      virtual ERRVALUE v_DrawElementsLow (LAYERDC& layerdc, ELEMTYPE ElemType, const UNSIGNEDSET *pElemSet, const void *style);
      virtual ERRVALUE v_DrawElementSample (const GRE::ELEMSAMPLE_DC& sampledc, const RVC::ELEMENT& element, const LRECT2D& samplerect);
      virtual ERRVALUE v_DrawOverlay (LAYERDC& layerdc);
      virtual ERRVALUE v_EstimateRangeZ (const LAYERVIEW *pLayerView, DOUBLE_RANGE& range) const;
      virtual ELEMNUM v_FindClosestElement (const DPOINT2D& point, double searchdist, double *distret, int component, const UNSIGNEDSET *pSearchSet, GRE::FINDFLAGS findflags);
      virtual int v_GetComponent (ELEMTYPE ElemType) const;
      virtual MICONSTRUCT* v_GetComponentIcon (int component) const;
      virtual COMPINFO* v_GetComponentInfo (int component);
      virtual MISTRING v_GetComponentName (int component) const;
      virtual const void* v_GetElemDefaultStyle (ELEMTYPE ElemType) const;
      virtual UINT16 v_GetElemDrawSelectionMode (ELEMTYPE ElemType) const;
      virtual UINT16 v_GetElemDrawStyleMode (ELEMTYPE ElemType) const;
      virtual ERRVALUE v_GetElemExtents (ELEMTYPE ElemType, ELEMNUM ElemNum, DRECT3D& Extents);
      virtual ERRVALUE v_GetElemSetByExtent (ELEMTYPE ElemType, const DRECT2D& Extent, UNSIGNEDSET& ElemSet);
      virtual ELEMTYPE v_GetElemType (int component) const;
      virtual bool v_GetGeorefName (RVC::OBJECTNAME& name, int component = 0) const;
      virtual bool v_GetLabelColor(LAYERDC& dc, const GRE::LABELPLACE& label, COLOR& color);
      virtual const GRE::LEGEND* v_GetLegend (ELEMTYPE ElemType);
      virtual INT64 v_GetNumElements (ELEMTYPE ElemType);
      virtual INT64 v_GetNumElementsDeleted (ELEMTYPE ElemType);
      virtual const RVC::OBJITEM& v_GetObjItem (int component) const;
      virtual double v_GetScaleMaxDetail (const DPOINT2D& point, const SPATREF::COORDREFSYS& crs, double DisplayPixelSizeMM) const;
      virtual ERRVALUE v_GetStyleInfo (ELEMTYPE ElemType, RVC::OBJITEM& ObjItem, RVC::OBJECTNAME& TableName);
      virtual bool v_HasDenseDetail () const;
      virtual bool v_HasDispParmSubObject () const;
      virtual bool v_HasHighlighted () const;
      virtual bool v_HasLegend () const;
      virtual bool v_HasNullImageCells () const;
      virtual int v_HighlightElementsByRegion (ELEMTYPE ElemType, const REGION2D& Region, TESTCRITERIA RegionTest, GRE::VIEW *firstview, GRE::DRAWFLAGS drawflags);
      virtual bool v_IsAntialiased () const;   
      virtual bool v_IsLineWidthHinted () const;
      virtual bool v_IsProportionVariable (DIMENSION dimension) const;
      virtual bool v_IsTableUsableForComponent (int component, const RVC::DBTABLE& table) const;
   #ifdef USE_MGUI
      virtual void v_MenuAddRegionGenItems (MGUI::MENU& menu, ELEMTYPE ElemType);
      virtual void v_MenuAddViewPopupItems (MGUI::MENU& menu, const DPOINT2D *point, VIEW *view);
   #endif

      virtual void v_OnNotifySurfaceChanged ();
      virtual int v_OpenObject (MDLGPARENT dlgparent);
   #ifdef USE_MGUI
      virtual ERRVALUE v_PromptObject (bool OpenCtrlPanel, MDLGPARENT dlgparent);
   #endif
      virtual ERRVALUE v_ReportRawElemInfo (MISTRING& infostr, ELEMTYPE ElemType, ELEMNUM ElemNum);
      virtual ERRVALUE v_SaveDispParmSubObject (RVC::DISPPARMUSAGE usage);
      virtual const char* v_SerialGetTagName () const = 0;
      virtual ERRVALUE v_SerialRead (SERIALIZER& serializer);
      virtual ERRVALUE v_SerialWrite (SERIALIZER& serializer, const char *tagname) const;
      virtual void v_SetAntialiased (bool antialias);
      virtual void v_SetDftName (bool ReplaceExisting);
      virtual void v_SetElemDrawSelectionMode (ELEMTYPE ElemType, UINT16 SelectMode);
      virtual void v_SetElemDrawStyleMode (ELEMTYPE ElemType, UINT16 StyleMode);
      virtual void v_SetHintThinLines (bool hint);
      virtual void v_SetLegendSampleFlags (MGD::STYLESAMPLEFLAGS SampleFlags);
      virtual void v_SetObjectDescriptor (int component, const RVC::DESCRIPTOR& descriptor);
      virtual void v_SetRenderSize (DIMENSION dimension, double size);
      virtual ERRVALUE v_SetStyleObjItem (const RVC::OBJITEM& ObjItem);
      virtual int v_SnapPoint (DPOINT3D& ptObject, SNAPTO SnapTo, double MaxDistance, VIEW *view) const;
      virtual bool v_SnapPointIsAllowed (SNAPTO SnapTo) const;
      virtual ERRVALUE v_TemplateRead (SERIALIZER& serializer);
      virtual int v_TestElementByRegion (ELEMTYPE ElemType, ELEMNUM ElemNum, const REGION2D& Region, TESTCRITERIA TestMode);
   #ifdef USE_MGUI
      virtual MGUI::CTRL_TREE::ITEMHND v_TreeViewAddUpdateLegend (GRE::CTRL_TREEVIEW& TreeView, MGUI::CTRL_TREE::ITEMHND hndParent, MGUI::CTRL_TREE::ITEMHND hndInsertAfter);
      virtual void v_TreeViewAddUpdateDetails (GRE::CTRL_TREEVIEW& TreeView, MGUI::CTRL_TREE::ITEMHND hndParent, MGUI::CTRL_TREE::ITEMHND hndInsertAfter);
   #endif
      virtual int v_UpdateExtents (bool forceupdate);
      virtual bool v_UsesTransparency (const MGD::DEVICE *pDevice = 0) const;


      #ifndef GENERATING_DOXYGEN_OUTPUT

      LAYER (const LAYER&);
      LAYER& operator= (const LAYER&);

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

#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(LAYER::CREATEFLAGS)
DEFINE_ENUM_OP_BITWISE(LAYER::SETACTIVEFLAGS)
DEFINE_ENUM_OP_INCREMENT(LAYER::TYPE)
#endif

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

class LAYER::DISPPARM : public SERIALIZABLE {
   public:

      UINT32 dispflags;                   
      UINT8 NumObjects;                   
      UINT8 NumComponents;                
      UINT8 NoGeoreference;               
      UINT8 DataTipSearchDist;            
      double zinit;                       
      double zlast;                       
      double zscale;                      
      double zoffset;                     
      COLOR ActiveColor;                  
      COLOR HighlightColor;               
      COLOR WireframeColor;               
      COLOR BaseColor;                    
      double MinScaleVisible;             
      double MaxScaleVisible;             
      double m_MaxScaleRegion;            
      POLYSTYLE m_RegionStyle;            
      bool m_ShowRegionZoomedOut;         
      bool m_bManageTextLabels;           
      bool m_bManagePointSymbols;         

      // This should be 'protected' but compiler doesn't like it.
      DISPPARM& operator= (const DISPPARM& rhs) {
         if (this != &rhs) Copy(rhs);
         return (*this);
         }

      int LoadSubObject (
         const RVC::OBJECT& ParentObj,             
         RVC::DISPPARMUSAGE usage = RVC::DISPPARMUSAGE_Unspecified   
         );

      void SetMayUseTransparency (
         ) { dispflags |= DISPFLAG_MayUseTransparency; dispflags &= ~DISPFLAG_UsesTransparency; }

      ERRVALUE Validate ();

      bool IsPedestalSet (
         ) { return (BaseColor.GetTransparency() != 255); }

      void SetPedestal (
         const bool pedestal
         ) { BaseColor.SetTransparency(pedestal ? 0 : 255 );  }

   protected:

      DISPPARM ();

      DISPPARM (const DISPPARM& rhs) : SERIALIZABLE(rhs) { Copy(rhs); }

      virtual ~DISPPARM ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      void Copy (const DISPPARM& rhs);

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

      #endif // GENERATING_DOXYGEN_OUTPUT

      virtual const SERIALIZERITEM* SerialGetItemDef (SERIALIZER& serializer) const = 0;
      virtual ERRVALUE v_SetObjItem (const RVC::OBJITEM& objitem, bool replace);
      virtual ERRVALUE v_Validate ();

   }; // End of LAYER::DISPPARM

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

class LAYER::COMMONPARM {
   public:

      enum STATE {
         STATE_False =     0,
         STATE_True =      1,
         STATE_ByLayer =   2
         };

   #ifdef USE_MGUI
      class FORM {
         public:

            FORM ();

            virtual ~FORM () = 0;

            void Create (
               MGUI::LAYOUT_PANE& ParentPane,
               const COMMONPARM *pValues     
               ) { v_Create(ParentPane,pValues); }

            void GetValues (
               COMMONPARM *pValues           
               ) { v_GetValues(pValues); }

            void SetDelegateOnChanged (
               DELEGATE_VOID_NOPARMS delegate
               ) { m_DelegateOnChanged = delegate; }

            void SetValues (
               const COMMONPARM *pValues     
               ) { v_SetValues(pValues); }

         protected:

            void NotifyChanged (
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            DELEGATE_VOID_NOPARMS m_DelegateOnChanged;

            #endif

            // Overridables.

            virtual void v_Create (
               MGUI::LAYOUT_PANE& ParentPane,
               const COMMONPARM *pValues     
               ) = 0;

            virtual void v_GetValues (
               COMMONPARM *pValues           
               ) = 0;

            virtual void v_SetValues (
               const COMMONPARM *pValues     
               ) = 0;

         };
   #endif

      virtual ~COMMONPARM () = 0;

   #ifdef USE_MGUI
      FORM* ConstructForm (
         ) const { return (v_ConstructForm()); }
   #endif

   #ifdef USE_MGUI
      bool DlgEditValues (
         MDLGPARENT dlgparent
         ) { return (v_DlgEditValues(dlgparent)); }
   #endif

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

      LAYER::TYPE GetLayerType (
         ) const { return (m_LayerType); }

      bool HasUI (
         ) const { return (m_HasUI); }

      const SERIALIZERITEM* SerialGetItemDef (
         ) const { return (v_SerialGetItemDef()); }

      const char* SerialGetTagName (
         ) const { return (v_SerialGetTagName()); }

      ERRVALUE SerialRead (
         SERIALIZER& serializer
         ) { return (v_SerialRead(serializer)); }

      ERRVALUE SerialWrite (
         SERIALIZER& serializer
         ) const { return (v_SerialWrite(serializer)); }

   protected:

      explicit COMMONPARM (
         GROUP *group,
         LAYER::TYPE layertype,
         bool HasUI = true
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      GROUP *m_group;
      LAYER::TYPE m_LayerType;
      bool m_HasUI;

      // Unimplemented
      COMMONPARM (const COMMONPARM& rhs);
      COMMONPARM& operator= (const COMMONPARM& rhs);

      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables.

   #ifdef USE_MGUI
      virtual FORM* v_ConstructForm () const;
   #endif

   #ifdef USE_MGUI
      virtual bool v_DlgEditValues (MDLGPARENT dlgparent);
   #endif

      virtual const SERIALIZERITEM* v_SerialGetItemDef () const = 0;

      virtual const char* v_SerialGetTagName () const = 0;

      virtual ERRVALUE v_SerialRead (SERIALIZER& serializer);

      virtual ERRVALUE v_SerialWrite (SERIALIZER& serializer) const;

   }; // End of LAYER::COMMONPARM

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

class LAYER::TYPEDEFN {
   public:

      enum FLAGS {
         FLAG_None =                   0,
         FLAG_NotEditable =            0x0001,  
         FLAG_OnePerGroup =            0x0002,  
         FLAG_NoHighlightColors =      0x0010,  
         FLAG_CanQuickAdd =            0x0020,  
         FLAG_CanShowDataTip =         0x0040,  
         FLAG_IsRemote =               0x0080,  
         FLAG_CanShowRegionZoomedOut = 0x0100,  
         FLAG_HasPossibleOverlay =     0x0200,  
         };

      void AddTypesToFilter (
         MGUI::DLG_GETOBJECT_FILTER& filter
         ) const;

      bool CanQuickAdd (
         ) const { return ((m_flags & FLAG_CanQuickAdd)!=0); }

      bool CanShowDataTip (
         ) const { return ((m_flags & FLAG_CanShowDataTip)!=0); }

      bool CanShowRegionZoomedOut (
         ) const { return ((m_flags & FLAG_CanShowRegionZoomedOut)!=0); }

   #ifdef USE_MGUI
      bool CreateMenuAdd (
         MGUI::MENU& menuret                       
         ) const { return (v_CreateMenuAdd(menuret)); }
   #endif

      ERRVALUE Construct (
         GRE::GROUP *group,                           
         LAYER **retlayer = 0,                        
         CREATEFLAGS createflags = CREATEFLAG_None,   
         GRE::LISTPOS listpos = GRE::LISTPOS_Last,    
         LAYER *reflayer = 0                          
         ) const;

      const char* GetFileExtns (
         ) const { return (m_FileExtns); }

      ICONID GetIconID (
         ) const { return (m_IconID); }

      TYPE GetLayerType (
         ) const { return (m_LayerType); }

   #if defined(X_NATIVE) && !defined(DEPRECATE_ALL)
      DEPRECATED MENUITEM* GetMenuItemCreate (
         ) const { return (v_GetMenuItemCreate()); }
   #endif

      const RVC::OBJTYPESET& GetObjTypeSet (
         ) const { return (m_ObjTypeSet); }

      const char* GetSerializeTagCommonParm (
         ) const { return (m_SerializeTagCommonParm); }

      const char* GetSerializeTagLayer (
         ) const { return (m_SerializeTagLayer); }

      const char* GetSerializeTagTemplate (
         ) const { return (m_SerializeTagTemplate); }

      int GetTreeViewImageIdx (
         ) const { return (m_TreeViewImageIdx); }

      int GetTreeViewImageIdxEdit (
         ) const { return (m_TreeViewImageIdxEdit); }

      TEXTID GetTypeNameTextID (
         ) const { return (m_TypeNameTextID); }

      bool HasPossibleOverlay () const
         { return ((m_flags & FLAG_HasPossibleOverlay) != 0); }

      bool IsEditable (
         ) const { return (!(m_flags & FLAG_NotEditable)); }

      int IsFileSelectable (
         const FILEPATH& filepath,
         MISTRING& msg,
         int position = -1
         ) const;

      int IsObjectSelectable (
         const RVC::OBJITEM& objitem,
         MISTRING& msg,
         int position = -1
         ) const;

      bool IsOnePerGroup (
         ) const { return ((m_flags & FLAG_OnePerGroup)!=0); }

      bool IsRemote (
         ) const { return ((m_flags & FLAG_IsRemote)!=0); }

      void SetupTreeViewShared (
         );

      bool UsesHighlightColors (
         ) const { return (!(m_flags & FLAG_NoHighlightColors)); }

   protected:

      TYPEDEFN (
         TYPE LayerType,
         TEXTID TypeNameTextID,
         const char *SerializeTagLayer,
         const char *SerializeTagTemplate,
         ICONID IconID,
         FLAGS flags,
         const char *SerializeTagCommonParm = 0
         );

      TYPEDEFN (
         TYPE LayerType,
         TEXTID TypeNameTextID,
         const RVC::OBJTYPESET& ObjTypeSet,
         const char *SerializeTagLayer,
         const char *SerializeTagTemplate,
         ICONID IconID,
         FLAGS flags,
         const char *SerializeTagCommonParm = 0
         );

      TYPEDEFN (
         TYPE LayerType,
         TEXTID TypeNameTextID,
         const char *FileExtns,
         const char *SerializeTagLayer,
         const char *SerializeTagTemplate,
         ICONID IconID,
         FLAGS flags,
         const char *SerializeTagCommonParm = 0
         );

      TYPEDEFN (
         TYPE LayerType,
         TEXTID TypeNameTextID,
         const RVC::OBJTYPESET& ObjTypeSet,
         const char *FileExtns,
         const char *SerializeTagLayer,
         const char *SerializeTagTemplate,
         ICONID IconID,
         FLAGS flags,
         const char *SerializeTagCommonParm = 0
         );

      virtual ~TYPEDEFN () = 0;

      void SetIconIdEdit (
         ICONID iconid
         ) { m_IconIdEdit = iconid; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      TYPE m_LayerType;                      
      TEXTID m_TypeNameTextID;
      FLAGS m_flags;
      RVC::OBJTYPESET m_ObjTypeSet;
      const char *m_FileExtns;
      const char *m_SerializeTagLayer;
      const char *m_SerializeTagTemplate;
      const char *m_SerializeTagCommonParm;
      ICONID m_IconID;
      int m_TreeViewImageIdx;
      ICONID m_IconIdEdit;
      int m_TreeViewImageIdxEdit;

      virtual void v_Construct (
         GRE::GROUP *group,               
         LAYER **retlayer,       
         CREATEFLAGS createflags,      
         GRE::LISTPOS listpos,         
         LAYER *reflayer            
         ) const = 0;

   #ifdef USE_MGUI
      virtual bool v_CreateMenuAdd (
         MGUI::MENU& menuret                       
         ) const;
   #endif

   #ifdef X_NATIVE
      virtual MENUITEM* v_GetMenuItemCreate () const;
   #endif

      virtual int v_IsFileSelectable (
         const FILEPATH& filepath,
         MISTRING& msg,
         int position
         ) const;

      virtual int v_IsObjectSelectable (
         const RVC::OBJITEM& objitem,
         MISTRING& msg,
         int position
         ) const;

   #ifdef USE_MGUI
      virtual void v_SetupTreeViewShared ();
   #endif

      #endif // GENERATING_DOXYGEN_OUTPUT
   }; // End of LAYER::TYPEDEFN
#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(LAYER::TYPEDEFN::FLAGS);
#endif

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

class LAYER::COMPINFO {
   public:

   #if defined(USE_MGUI)
      class TABLEINFO {
         public:

            enum TYPE {
               TYPE_None =       0,
               TYPE_User =       1,
               TYPE_Form =       2,
               TYPE_System =  3
               };

            TABLEINFO (
               COMPINFO& CompInfo
               );

            TABLEINFO (
               const TABLEINFO& rhs
               );

            ~TABLEINFO (
               );

            ERRVALUE HideTable (
               );

            bool IsForm (
               ) const { return (m_Type == TYPE_Form); }

            bool IsSystemTable (
               ) const { return (m_Type == TYPE_System); }

            bool IsOpen (
               ) const;

            bool IsUser (
               ) const { return (m_Type == TYPE_User); }

            const RVC::OBJITEM* GetObjItemForm (
               ) const { return (m_pObjItemForm); }

            bool SetForm (
               const RVC::OBJITEM& ObjItemForm
               );

            bool SetTable (
               INT32 TableNum
               );

            ERRVALUE ShowTable (
               );

            MGUI::CTRL_TREE::ITEMHND TreeViewAddItem (
               GRE::CTRL_TREEVIEW& TreeView,
               MGUI::CTRL_TREE::ITEMHND hndParent,
               MGUI::CTRL_TREE::ITEMHND hndInsertAfter
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            COMPINFO& m_CompInfo;
            TYPE m_Type;
            INT32 m_TableNum;             
            RVC::OBJITEM *m_pObjItemForm; 
            bool m_IsTableViewable;

            bool TreeViewOnPointerButton (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, MGUI::CTRL_TREE::HITRESULT, const LPOINT2D&, MGUI::POINTERBUTTON, MGUI::KEYSTATE);
            bool TreeViewOnToolTipRequest (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, MGUI::CTRL_TREE::HITRESULT, const LPOINT2D&, MGUI::CTRL_TOOLTIP&);
            void TreeViewPopupMenu (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, const LPOINT2D& MousePoint);

            TABLEINFO& operator= (const TABLEINFO& rhs); // Not implemented

            friend class COMPINFO;
            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of LAYER::COMPINFO::TABLEINFO

      typedef MILIST<TABLEINFO> TABLEINFOLIST;

   #endif

      class DLG_RECLASSIFY;

      COMPINFO (
         );

      COMPINFO (
         LAYER *layer,
         int component,
         ELEMTYPE ElemType,
         bool AllowDatabase = true,
         bool AllowQuery = true
         );

      ~COMPINFO (
         );

   #ifdef USE_MGUI
      void ActivateNextSelected (
         );
   #endif

   #ifdef USE_MGUI
      void ActivatePrevSelected (
         );
   #endif

   #ifdef USE_MGUI
      ERRVALUE ApplyReclassify (DLG_RECLASSIFY*);
   #endif

   #ifdef USE_MGUI
      ERRVALUE CreateDbEdit (
         );
   #endif

      void Destroy (
         );

   #ifdef USE_MGUI
      ERRVALUE DlgHighlightByQuery ();
   #endif

   #ifdef USE_MGUI
      void DropForm (
         const RVC::OBJITEM& ObjItemForm
         );
   #endif

   #ifdef USE_MGUI
      void DropTable (
         INT32 TableNum                      
         );
   #endif

   #ifdef USE_MGUI
      TABLEINFO* FindFormInfo (
         const RVC::OBJITEM& ObjItemForm
         );
   #endif

   #ifdef USE_MGUI
      TABLEINFO* FindTableInfo (
         INT32 TableNum                      
         );
   #endif

      ELEMNUM GetActiveElemNum (
         ) const { return (m_ActiveElemNum); }

      bool GetAllowQuery () const
         { return (m_AllowQuery); }

      INT32 GetBaseTableNum (
         ) const { return (m_BaseTableNum); }

      int GetComponent (
         ) const { return (m_component); }

   #ifdef USE_MGUI
      DBEDIT* GetDbEdit (
         );
   #endif

      ELEMTYPE GetElemType (
         ) const { return (m_ElemType); }

      const UNSIGNEDSET& GetHighlightSet (
         ) const { return (m_HighlightSet); }

      UNSIGNEDSET& GetHighlightSet (
         ) { return (m_HighlightSet); }

      LAYER* GetLayer (
         ) const { return (m_layer); }

      bool GetShowSystemTables (
         ) const { return (m_ShowSystemTables); }

   #ifdef USE_MGUI
      TABLEINFOLIST& GetTableInfoList (
         ) { return (m_TableInfoList); }
   #endif

   #ifdef USE_MGUI
      bool HasDbEdit (
         ) const { return (m_pDbEdit != 0); }
   #endif

      void Init (
         LAYER *layer,
         int component,
         ELEMTYPE ElemType,
         bool AllowDatabase,
         bool AllowQuery = true
         );

      bool IsElemSelectable (
         ) const { return (m_ElemSelectable); }

      void NotifyElementSelected (
         );

   #ifdef USE_MGUI
      void OnMenuRegionGen (MGUI::ID, bool);
   #endif

   #ifdef USE_MGUI
      ERRVALUE OpenDlgReclassify (
         INT32 TableNum,                     
         INT32 FieldNum,                     
         INT32 RelFieldDisplay = -1,         
         INT32 RelFieldSortBy = -1           
         );
   #endif

   #ifdef USE_MGUI
      void SelectTableElements (
         MDLGPARENT dlgparent,
         INT32 TableNum,                     
         int mode                   
         );
   #endif

      void SetActiveElemNum (
         ELEMNUM ElemNum
         ) { m_ActiveElemNum = ElemNum; }

      void SetAllowShowDefaultTable (
         bool AllowShowDefaultTable
         ) { m_AllowShowDefaultTable = AllowShowDefaultTable; }

      void SetBaseTableNum (
         INT32 BaseTableNum
         ) { m_BaseTableNum = BaseTableNum; }

   #ifdef USE_MGUI
      void SetDbEditStyleObject (
         );
   #endif

      void SetElemSelectable (
         bool ElemSelectable
         );

      void SetElemType (
         ELEMTYPE ElemType
         ) { m_ElemType = ElemType; }

   #ifdef USE_MGUI
      void ShowDefaultTable (
         );
   #endif

   #ifdef USE_MGUI
      MGUI::CTRL_TREE::ITEMHND TreeViewAddUpdateItem (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndParent,
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter,
         int ImageIdx
         );
   #endif

   #ifdef USE_MGUI
      MGUI::CTRL_TREE::ITEMHND TreeViewAddUpdateItem (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndParent,
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter,
         const MISTRING& label,
         int ImageIdx
         );
   #endif

   #ifdef USE_MGUI
      void TreeViewAddTables (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndParent,
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter
         );
   #endif

   #ifdef USE_MGUI
      void TreeViewDeleteItem (
         GRE::CTRL_TREEVIEW& TreeView
         );
   #endif

   #ifdef USE_MGUI
      void TreeViewShowTableList (
         bool show
         );
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      enum SELGROUP {
         SELGROUP_Select,
         SELGROUP_Clear,
         SELGROUP_Invert
         };

      class DBOBSERVER;
      friend class COMPINFO::DBOBSERVER;

      LAYER *m_layer;                        // Layer this applies to
      int m_component;                       // Component index in layer
      ELEMTYPE m_ElemType;                   // Component element type
      UNSIGNEDSET m_HighlightSet;
      bool m_AllowDatabase;                  // Element type supports database views
      bool m_AllowQuery;                     // Element type supports selection by query
      bool m_AllowShowDefaultTable;          // Can automatically show default table
   #if defined(USE_MGUI)
      DBEDIT *m_pDbEdit;                     // Database 'editor'
      RVC::DBASE_ELEMENT *m_pObjDbElem;      // Database for element
      DBOBSERVER *m_pObsDbElem;              // Observer on the database
      TABLEINFOLIST m_TableInfoList;         // Information about each table
      MGUI::DLGSHELL *m_pDlgMarkByQuery;     // Dialog for 'mark by query'
      SIMPLE_ARRAY<DLG_RECLASSIFY*> m_DlgReclassifyPtrs;
   #endif
      ELEMNUM m_ActiveElemNum;               // Active element for this component
      bool m_ElemSelectable;                 // Element is selectable
      bool m_ShowSystemTables;               // Show internal tables in list
      INT32 m_BaseTableNum;                  // Base table for component

   #ifdef X_NATIVE
      MXDHANDLE m_SelQueryDlgHandle;         // Handle for select-by-query dialog
   #endif

   #ifdef USE_MGUI
      static void CB_NotifyDbEdit (const DBEDIT_MSG *cbs, void *vpCompInfo);
      TABLEINFO* AddTableInfo (const TABLEINFO& NewTableInfo);
      bool HasNonSystemTables ();
      ERRVALUE MarkAttachedElements (const DBEDIT_MSG *msg);
      void OnCmdAddTable ();
      void OnCmdEditRelations ();
      void OnCmdLinkToDataSource ();
      void OnCmdMakeForm ();
      void OnCmdMakeTable ();
      void OnNotifyDbEdit (const DBEDIT_MSG *cbs);
      void OnTableFormRemoved (TABLEINFO*);
      void OnTableNameChanged (INT32 TableNum);
      void ShowSelectedRecords (INT32 TableNum, bool force=false);
      bool TreeViewOnChildVisibilityChanging (GRE::CTRL_TREEVIEW& TreeView, MGUI::CTRL_TREE::ITEMHND hndCompItem, MGUI::CTRL_TREE::CHILDVISIBILITY visibility);
      bool TreeViewOnPointerButton (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, MGUI::CTRL_TREE::HITRESULT, const LPOINT2D&, MGUI::POINTERBUTTON, MGUI::KEYSTATE);
      bool TreeViewOnToolTipRequest (GRE::CTRL_TREEVIEW&, MGUI::CTRL_TREE::ITEMHND, MGUI::CTRL_TREE::HITRESULT, const LPOINT2D&, MGUI::CTRL_TOOLTIP&);
      void TreeViewPopupMenu (GRE::CTRL_TREEVIEW& TreeView, MGUI::CTRL_TREE::ITEMHND hndItem, const LPOINT2D& MousePoint);
   #endif

      COMPINFO (const COMPINFO&);
      COMPINFO& operator= (const COMPINFO&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   }; // End of LAYER::COMPINFO


#define SMLMEMBER_LAYERDISPFLAG(name,invert,flag,desc) {name, STYPE_Num, LAYER::SMLGET_LayerDispFlag, LAYER::SMLSET_LayerDispFlag, 0, 0, invert, flag, 0,0,0,0, desc}


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

class LAYER::FILTER {
   public:
      bool Filter (
         const LAYER *layer
         ) { return (v_Filter(layer)); }
   private:
      virtual bool v_Filter (
         const LAYER *layer
         ) = 0;
   };

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

class LAYER::FILTER_EXCLUDE : public LAYER::FILTER {
   public:

      FILTER_EXCLUDE (
         const LAYER *exlayer       
         ) : m_exlayer(exlayer) { }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const LAYER *m_exlayer;
      virtual bool v_Filter (const LAYER *layer);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

#endif   // INC_GRE_LAYER_H

---