lrlegnd2.h

Go to the documentation of this file.

/**
 * \file lrlegnd2.h <gre/lrlegnd2.h>
 * \brief GRE_LAYER_LEGEND2 class definitions
 *
 * \if NODOC
 * $Id: lrlegnd2.h_v 1.8 2005/03/31 16:57:06 fileserver!dwilliss Exp $
 *
 * $Log: lrlegnd2.h_v $
 * Revision 1.8  2005/03/31 16:57:06  fileserver!dwilliss
 * Rename one of our types to MIUNICODE because it conflicted with a Microsoft #define
 *
 * Revision 1.7  2005/02/28 18:26:00  scowan
 * Support layer copy virtual method.
 *
 * Revision 1.6  2005/02/14 21:39:44  mju
 * Use device in usesTransparency.
 *
 * Revision 1.5  2005/01/20 16:56:45  mju
 * Redesign layer type registration.
 *
 * Revision 1.4  2004/03/05 18:53:49  mju
 * Use virtual dtor if virtual fns.
 *
 * Revision 1.3  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.2  2003/07/30 15:23:21  mju
 * Ignore private sections.
 *
 * Revision 1.1  2002/09/20 17:37:36  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_GRE_LRLEGND2_H
#define  INC_GRE_LRLEGND2_H

#ifndef  INC_MI32_GRE_H
#include <mi32/gre.h>
#endif

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

class GRE_LAYER_LEGEND2 : public GRE_LAYER {
   public:

      //! Class used internally to keep track of which layers the legend refers to
      class LAYERREF  {
         public:
            MIUNICODE *m_name;   //!< Can't use MISTRING.  We MmAllocC() an array of LAYRREFs.
            //! Our DISPPARM's destructor worrys about freeing stuff.
            GRE_LAYER* m_layer;
            ELEMTYPE m_ElemType;
            UINT32 m_ID;

            LAYERREF (
               ) :
               m_name(0),
               m_layer(0),
               m_ID(0),
               m_ElemType(ELEMTYPE_Empty)
               {
               }

            LAYERREF (
               GRE_LAYER* lyr,
               ELEMTYPE et
               );

            LAYERREF(const LAYERREF& rhs) :
               m_ID(rhs.m_ID),
               m_layer(rhs.m_layer),
               m_ElemType(rhs.m_ElemType) 
               {
                  m_name = rhs.m_name ? ucstrdup(rhs.m_name) : 0;
               }

            ~LAYERREF() {
               MmFree(m_name);
               }

            LAYERREF& operator= (const LAYERREF& rhs) {
               if (this != &rhs) {
                  m_name = rhs.m_name ? ucstrdup(rhs.m_name) : 0;
                  m_ID = rhs.m_ID;
                  m_layer = rhs.m_layer;
                  m_ElemType = rhs.m_ElemType;
                  }
               return (*this);
               }

            //! Also sets m_name
            void SetLayer (
               GRE_LAYER* layer
               );

         };
         
      // GRE_LAYER_LEGEND2::DISPPARM
      class DISPPARM : public GRE_LAYER::DISPPARM {
         public:

            class DLG;

         /*=================This stuff must be saved/loaded by mdlegend.c=============*/
            GRAPHICLAYOUT m_grlayout;
            UINT32 m_NumLayers;
            LAYERREF* m_layers;

         /*=================This stuff is just internal=========================*/

            DISPPARM ();
            DISPPARM (const DISPPARM& rhs) {
               Copy(rhs);
               }
            virtual ~DISPPARM () {
               Free();
               }

            DISPPARM& operator= (const DISPPARM& rhs) {
               if (this != &rhs) {
                  Free();
                  Copy(rhs);
                  }
               return (*this);
               }

            static void GRECB_LayerCallback (
               const GRE_CALLBACK_MSG* msg,
               void* cbdata
               );

            static int SerializerCB_GRLayout (
               SERIALIZER& serializer,
               const SERIALIZER::ITEMDEF *itemdef,
               void* cbdata,
               SERIALIZER::ITEMDEF::ACTION action
               );


            //! Returns index into m_layers array for given layer/elemtype
            //! Return -1 if not found, < -1 if error.
            INT32 GetLayerRefNum (
               GRE_LAYER* layer,
               ELEMTYPE ElemType,
               bool bAllocIfNotFound = false
               );

            void OnLayerChange (
               INT32 LayerRefNum,
               bool deleting
               );

            void OnLayoutLoaded (
               GRE_VIEWABLE* viewable
               );

         protected:
            virtual const SERIALIZER::ITEMDEF* SerialGetItemDef (SERIALIZER& serializer) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            GRE_LAYER_LEGEND2* m_layer;      //!< Need it in a callback that only gets the DISPPARM
            void Copy (const DISPPARM&);
            void Free ();
            friend class GRE_LAYER_LEGEND2;
            #endif //!< GENERATING_DOXYGEN_OUTPUT
         };

      //! Callback for the "Add Legend" menu of GRE_LAYER_LEGEND.
   #ifndef WIN32_NATIVE
      static void CB_NewLegend2 (
         Widget w,
         void *vsubtype,
         void *
         );
   #endif

      //! Register this layer type
      static void RegisterType (
         );

      //! Construct layer and insert into list
      explicit GRE_LAYER_LEGEND2 (
         GRE_GROUP *group,                            //!< Group to contain layer
         CREATEFLAGS createflags = CREATEFLAG_None,   //!< Creation flags
         GRE::LISTPOS listpos = GRE::LISTPOS_Last,    //!< Position in list
         GRE_LAYER *reflayer = 0                      //!< Reference layer for insertion
         );

      virtual ~GRE_LAYER_LEGEND2 ();

      //! Retrieve layer-specific display parameters.
      const DISPPARM& GetDispParm (
         ) const { return (m_dispparm); }

      //! Return scale factor between legend's layout units and output "ground meters"
      double GetScaleFactor (
         ) const;

      //! Set layer-specific display parameters.
      //! This is the recommended method for changing how an existing layer is to be
      //! rendered.  Validation will be performed on the specified parameters and
      //! adjustments made to the layer's copy if necessary.  Use of this method
      //! usually result in a ChangeBegin / ChangeEnd message pair, and will also
      //! generate a ChangeObject message if the spatial object used in the layer
      //! is changed.
      ERRVALUE SetDispParm (
         const DISPPARM& dispparm               //!< Parameters to set
         );

      void SetLayout (
         const GRAPHICLAYOUT& grlayout
         );

   #if defined(X_NATIVE) && !defined(GENERATING_DOXYGEN_OUTPUT)
      static void CB_CreateDialog (Widget, void*, void*);
   #endif

   protected:

      DISPPARM m_dispparm;                      //!< Layer-specific display parameters

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static void GRECB_LayoutLoaded (const GRE_CALLBACK_MSG* msg, void* cbdata);

      //! Overrides from GRE_LAYER.
   #if defined(X_NATIVE) || defined(WIN32_MFC)
      virtual int v_ControlPanel (MDLGPARENT dlgparent,UINT32 flags = 0);
   #endif
      virtual GRE_LAYER* v_Copy (GRE_GROUP *group) const;
      virtual ERRVALUE v_Draw (GRE_LAYERDC& layerdc);
      virtual const char* v_SerialGetTagName () const;
      virtual void v_SetDftName (bool ReplaceExisting);
      virtual ERRVALUE v_TemplateRead (SERIALIZER& serializer);
      virtual int v_UpdateExtents (bool forceupdate);
      virtual bool v_UsesTransparency (const MGD::DEVICE *pDevice = 0) const;

      friend class GRE_LAYER_LEGEND2::DISPPARM; //!< Need access to private static GRECB_LayoutLoaded()

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };

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


#endif   //!< INC_GRE_LRLEGND2_H

---