layerview.h

Go to the documentation of this file.

/**
 * \file gre/layerview.h
 * \brief GRE::LAYERVIEW class definition
 * 
 * \if NODOC
 * $Id: layerview.h_v 1.8 2005/05/24 21:29:36 mju Exp $
 *
 * $Log: layerview.h_v $
 * Revision 1.8  2005/05/24 21:29:36  mju
 * Make cliprect optional for overlayBufferIfRendered.
 *
 * Revision 1.7  2005/05/24 17:55:04  mju
 * Add OverlayIfRendered.
 *
 * Revision 1.6  2005/04/29 17:49:36  mju
 * Support rendertarget.
 *
 * Revision 1.5  2005/04/27 15:31:30  mju
 * Add docs for getElemDrawnSet.
 *
 * Revision 1.4  2005/04/22 17:35:44  mju
 * Use renderbuffer class.
 *
 * Revision 1.3  2005/03/22 21:59:50  mju
 * Reset overlay rendering and clear label placement in resetRendered.
 *
 * Revision 1.2  2005/03/01 14:21:31  mju
 * Add layerview_geometric to manage drawn sets.
 *
 * Revision 1.1  2005/02/25 18:54:42  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_GRE_LAYERVIEW_H
#define  INC_GRE_LAYERVIEW_H

#ifndef  INC_GRE_BASE_H
   #include <gre/base.h>
#endif

#ifndef  INC_GRE_LABELPLACEMENT_H
   #include <gre/labelplacement.h>
#endif

#ifndef  INC_MI32_RENDERBUFFER_H
   #include <mi32/renderbuffer.h>
#endif

#ifndef  INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif


namespace GRE {

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

//! Container for layer information retained for each view.
class LAYERVIEW {
   public:

      //! Rendering buffer types.
      enum RENDERTYPE {
         RENDERTYPE_Layer =      0,
         RENDERTYPE_Labels =     1,
         RENDERTYPE_Highlight =  2
         };

      virtual ~LAYERVIEW ();

      //! Check if existing renderings are still valid.
      void CheckRendered (
         );

      //! Clear all 'drawn element' sets.
      //! Does not resize the sets.
      void ClearAllDrawnSets (
         bool UseHighlighted
         );

      //! Clear label placement if any.
      void ClearLabelPlacement (
         );

      //! Compute all transformations.
      ERRVALUE ComputeTrans (
         );

      //! Draw single element to specified rendering buffer.
      ERRVALUE DrawElementToBuffer (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         GRE::LAYERVIEW::RENDERTYPE RenderType,
         GRE::DRAWFLAGS drawflags
         );

      //! Draw single element to specified rendering device.
      ERRVALUE DrawElementToDevice (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         MGD::DEVICE *pDevice,
         GRE::DRAWFLAGS drawflags
         );

      //! Draw set of elements to specified rendering buffer.
      ERRVALUE DrawElementsToBuffer (
         ELEMTYPE ElemType,
         const UINT8 *ElemSet,
         GRE::LAYERVIEW::RENDERTYPE RenderType,
         GRE::DRAWFLAGS drawflags
         );

      //! Draw set of elements to specified rendering device.
      ERRVALUE DrawElementsToDevice (
         ELEMTYPE ElemType,
         const UINT8 *ElemSet,
         MGD::DEVICE *pDevice,
         GRE::DRAWFLAGS drawflags
         );

      //! Get depth scaling, multiplied by depth to get drawing scale.
      double Get3dDepthScale (
         ) const { return (m_3dDepthScale); }

      //! Get increment in layer relative to once cell in surface layer.
      double Get3dSurfaceIncrement (
         ) const { return (m_3dSurfaceIncrement); }

      //! Get 3D viewpoint.
      const GRE_VIEWPOINT3D* Get3dViewPoint (
         ) const { return (m_pViewPoint3D); }

      //! Get 3D Z scaling.
      double Get3dZScale (
         ) const { return (m_3dZScale); }

      //! Get design scale.
      double GetDesignScale (
         ) const { return (m_DesignScale); }

      //! Get device rectangle used for rendering.
      //! This is a nominal rectangle based on layer extents and may not account for
      //! symbology and marginalia.  Returned rectangle may not be suitable for clipping
      //! during drawing, but will be suitable for selection of source object elements.
      const LRECT2D& GetDeviceRectUsed (
         ) const { return (m_CurDevRectUsed); }

      //! Get set for elements drawn in view (const).
      //! @return NULL if no elements of specified type supported by layer.
      //! The set returned by this method only contains the elements which are actually visible in the view.
      //! Normally when checking for highlighted elements, the GRE_LAYER::GetElemHighlightSet method should be used.
      const BITSET* GetElemDrawnSet (
         ELEMTYPE ElemType,                              //! Element type
         bool UseHighlighted                             //! True to return set for visible elements drawn as 'highlighted'
         ) const { return (const_cast<LAYERVIEW*>(this)->v_GetElemDrawnSet(ElemType,UseHighlighted)); }

      //! Get set for elements drawn in view (non-const).
      //! @return NULL if no elements of specified type supported by layer.
      //! The set returned by this method should only contain the elements which are actually visible in the view.
      //! Normally when checking for highlighted elements, the GRE_LAYER::GetElemHighlightSet method should be used.
      BITSET* GetElemDrawnSet (
         ELEMTYPE ElemType,                              //! Element type
         bool UseHighlighted                             //! True to return set for visible elements drawn as 'highlighted'
         ) { return (v_GetElemDrawnSet(ElemType,UseHighlighted)); }

      //! Get pointer to label placement instance.
      //! @return LABELPLACEMENT pointer or NULL if not supported.
      LABELPLACEMENT* GetLabelPlacement (
         bool ReturnNullIfEmpty = true                   //!< Return NULL pointer if no labels
         );

      //! Get associated GRE_LAYER.
      GRE_LAYER* GetLayer (
         ) const { return (m_layer); }

      //! Get rendering buffer for specified rendering type (const).
      const RENDERBUFFER& GetRenderBuffer (
         RENDERTYPE RenderType                           //!< Rendering type
         ) const { return (m_RenderBuffer[RenderType]); }

      //! Get rendering buffer for specified rendering type (non-const).
      RENDERBUFFER& GetRenderBuffer (
         RENDERTYPE RenderType                           //!< Rendering type
         ) { return (m_RenderBuffer[RenderType]); }

      //! Get surface layer for 3D draping.
      GRE_LAYER_SURFACE* GetSurfaceLayer (
         ) const { return (m_pSurfaceLayer); }

      //! Get transformation from layer to device coordinates.
      const TRANS2D_MAPGEN& GetTransLayerDevice (
         ) const { return (m_TransLayerDevice); }

      //! Get transformation from 'layer' to 'surface' coordinates.
      const TRANS2D_MAPGEN& GetTransLayerSurface (
         ) const { return (m_TransLayerSurface); }

      //! Get transformation from layer to view coordinates.
      const TRANS2D_MAPGEN& GetTransLayerView (
         ) const { return (m_TransLayerView); }

      //! Get associated GRE_VIEW.
      GRE_VIEW* GetView (
         ) const { return (m_view); }

      //! Determine if surface has nulls.
      bool HasSurfaceNulls (
         ) const { return (m_HasSurfaceNulls); }

      //! Determine if drawing in 3D.
      bool Is3D (
         ) const { return (m_Is3D); }

      //! Determine if drawing 3D in stereo.
      bool Is3dStereo (
         ) const;

      //! Determine if surface (layer or flat) is being used.
      bool IsSurfaceUsed (
         ) const { return (m_IsSurfaceUsed); }

      //! Determine if layer overlaps view device display area.
      bool IsLayerOverlappedDevice (
         ) const { return (m_LayerOverlapsDevice); }

      //! Overlay rendering buffer on device if it has been rendered.
      //! @return true if did overlay, false if not.
      bool OverlayBufferIfRendered (
         RENDERTYPE RenderType,                          //!< Render type
         MGD::DEVICE *pDevTarget,                        //!< Target device
         const LRECT2D *pClipRect = 0                    //!< Optional clip rectangle
         );

      //! Reset all 'drawn element' sets to have no entries.
      void ResetAllDrawnSets (
         );

      //! Reset rendered status so redraws.
      void ResetRendered (
         GRE::RENDERTARGET target = GRE::RENDERTARGET_LayerAll
         );

   protected:

      //! Constructor.
      LAYERVIEW (
         GRE_LAYER *layer,
         GRE_VIEW *view
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GRE_LAYER *m_layer;
      GRE_VIEW *m_view;
      RENDERBUFFER m_RenderBuffer[3];
      TRANS2D_MAPGEN m_TransLayerView;
      TRANS2D_MAPGEN m_TransLayerDevice;
      TRANS2D_MAPGEN m_TransLayerSurface;
      GRE_VIEWPOINT3D *m_pViewPoint3D;          // 3D viewpoint
      GRE_LAYER_SURFACE *m_pSurfaceLayer;       // Surface layer in 3D
      DRECT2D m_NewTgtRectFull;                 // New full rectangle in target device coordinates, based on transformation
      DRECT2D m_CurTgtRectFull;                 // Current full rectangle in target device coordinates used by layer
      LRECT2D m_NewDevRectUsed;                 // New clipped rectangle on device used, based on transformation
      LRECT2D m_CurDevRectUsed;                 // Current clipped rectangle on device used
      double m_DesignScale;                     // Design scale of layout/group for relative size
      double m_3dSurfaceIncrement;              // Increment in layer corresponding to one cell in surface raster
      double m_3dDepthScale;                    // Map scale factor for 3D (multiply by depth to get actual scale)
      double m_3dZScale;
      bool m_Is3D;                              // Set if drawing in 3D
      bool m_IsSurfaceUsed;                     // Use surface layer for Z value
      bool m_HasSurfaceNulls;                   // Surface layer has null cells
      bool m_LayerOverlapsDevice;

      void DestroyRenderDevices (
         );

      void SetTransLayerDevice (
         const TRANS2D_MAPGEN& TransLayerDevice
         ) { m_TransLayerDevice = TransLayerDevice; }

      LAYERVIEW (const LAYERVIEW&);
      LAYERVIEW& operator= (const LAYERVIEW&);

      friend class GRE_LAYER;
      friend class GRE_LAYERDC;
      #endif // GENERATING_DOXYGEN_OUTPUT

      // LAYERVIEW Overridables.

      //! Get set for elements drawn in view.
      //! @return NULL if no elements of specified type supported by layer.
      virtual BITSET* v_GetElemDrawnSet (
         ELEMTYPE ElemType,
         bool UseHighlighted
         );

      //! Get pointer label placement manager.
      //! @return NULL if labels not supported.
      virtual LABELPLACEMENT* v_GetLabelPlacement (
         );

   };


//! Derived class supporting geometric element drawn sets.
class LAYERVIEW_GEOMETRIC : public LAYERVIEW {
   public:

      //! Constructor.
      LAYERVIEW_GEOMETRIC (
         GRE_LAYER *layer,
         GRE_VIEW *view
         );

      virtual ~LAYERVIEW_GEOMETRIC ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      unsigned m_NumComponents;
      BITSET *m_ElemDrawnSetsNormal;
      BITSET *m_ElemDrawnSetsHighlighted;

      virtual BITSET* v_GetElemDrawnSet (
         ELEMTYPE ElemType,
         bool UseHighlighted
         );

      LAYERVIEW_GEOMETRIC (const LAYERVIEW_GEOMETRIC&);
      LAYERVIEW_GEOMETRIC& operator= (const LAYERVIEW_GEOMETRIC&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };



//! Derived class supporting label placement.
class LAYERVIEW_LABELED : public LAYERVIEW_GEOMETRIC {
   public:

      //! Constructor.
      LAYERVIEW_LABELED (
         GRE_LAYER *layer,
         GRE_VIEW *view
         );

      virtual ~LAYERVIEW_LABELED ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      LABELPLACEMENT m_LabelPlacement;

      virtual LABELPLACEMENT* v_GetLabelPlacement (
         );

      LAYERVIEW_LABELED (const LAYERVIEW_LABELED&);
      LAYERVIEW_LABELED& operator= (const LAYERVIEW_LABELED&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

#endif   // INC_GRE_LAYERVIEW_H

---