gre/labelplacement.h

Go to the documentation of this file.

/******************************************************************************
 *
 * \file gre/labelplacement.h
 * \brief GRE::LABELPLACEMENT class definition
 *
 * \if NODOC
 * $Log: labelplacement.h_v $
 * Revision 1.29  2012/05/21 15:53:30  mju
 * Add labelplacelist typedef.
 *
 * Revision 1.28  2011/10/10 14:55:37  mju
 * Change setPointSymbol to use stylepattern_base.
 *
 * Revision 1.27  2006/10/05 20:04:41  mju
 * Fwd declare color.
 *
 * Revision 1.26  2006/09/19 20:30:23  scowan
 * More fwd decl's.
 *
 * Revision 1.25  2006/09/19 16:09:04  scowan
 * More include file changes.
 *
 * Revision 1.24  2006/09/19 15:45:28  scowan
 * Removed unused include files.
 *
 * Revision 1.23  2006/09/19 15:40:46  scowan
 * Uses new header for symbol definition.
 *
 * Revision 1.22  2005/10/14 17:30:16  mju
 * GRE namespace.
 *
 * Revision 1.21  2005/03/31 16:57:06  fileserver!dwilliss
 * Rename one of our types to MIUNICODE because it conflicted with a Microsoft #define
 *
 * Revision 1.19  2004/09/17 17:40:09  dwilliss
 * Added a couple private methods
 * Added a Detach method
 *
 * Revision 1.18  2004/09/09 20:06:03  dwilliss
 * Added Zoom
 *
 * Revision 1.17  2004/09/08 22:47:26  dwilliss
 * Implement CopyOnWrite and ComputeLabelExtents
 *
 * Revision 1.16  2004/09/08 16:50:44  dwilliss
 * Added SetPointSymbol version that takes RVC::STYLE::SYMBOLPATTERN
 *
 * Revision 1.15  2004/09/03 22:49:39  dwilliss
 * Added Draw methods
 *
 * Revision 1.10  2004/07/22 22:16:54  dwilliss
 * Keep track of the layer
 * Allow labels to be deleted
 *
 * Revision 1.7  2004/07/20 17:43:29  dwilliss
 * Fixed End() to compile with gcc
 *
 * Revision 1.2  2004/04/15 20:51:44  dwilliss
 * LABELPLACE's data is now kept in a refcounted private data structure so
 * copy and assignment are faster.
 *
 * Revision 1.1  2004/04/14 22:47:08  dwilliss
 * Initial revision
 *
 * \endif
 *
 *****************************************************************************/

#ifndef INC_GRE_LABELPLACEMENT_H
#define INC_GRE_LABELPLACEMENT_H

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

#ifndef INC_MI32_TEXTBASE_H
#include <mi32/textbase.h>
#endif

#ifndef INC_MI32_POLYLINE_H
#include <mi32/polyline.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class LABELSTYLE;
class QUADTREE;
class REGION2D;
struct COLOR;
struct LINESTYLE;
struct POINTSTYLE;
namespace MGD {
   class CONTEXT;
   }
namespace RVC {
   class STYLEPATTERN_BASE;
   }
namespace GRE {
   class LAYER;
   class LAYERDC;
   class VIEW;
   class LABELPLACEMENT;
   }
#endif


namespace GRE {

class LABELATTACHMENT {
   public:
      LABELATTACHMENT (
         ) { }

      LABELATTACHMENT (
         const RVC::ELEMENT& elem
         ) :
         m_elem(elem)
         { }

      LABELATTACHMENT (
         const LABELATTACHMENT& rhs
         ) :
         m_elem(rhs.m_elem),
         m_leader(rhs.m_leader)
         { }

      LABELATTACHMENT (
         const RVC::ELEMENT& elem,
         const POLYLINE& leader
         ) :
         m_elem(elem),
         m_leader(leader)
         { }

      ~LABELATTACHMENT()
         { }

      const RVC::ELEMENT& GetElement (
         ) const { return (m_elem); }

      const POLYLINE& GetLeader (
         ) const { return (m_leader); }

      void SetElement (
         const RVC::ELEMENT& elem
         ) { m_elem = elem; }

      void SetLeader (
         const POLYLINE& leader
         ) { m_leader = leader; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RVC::ELEMENT m_elem;
      POLYLINE m_leader;
      #endif
   };

class LABELPLACE {
   public:
      LABELPLACE();

      LABELPLACE (
         const LABELPLACE& rhs
         );

      // dtor
      ~LABELPLACE();

      LABELPLACE& operator=(
         const LABELPLACE& rhs
         );

      // Compute the extents region of the label for a given GC
      // This computes the text label region (including frame) for a
      // given graphics context.
      void ComputeLabelExtents (
         MGD::CONTEXT* gc,
         REGION2D& region,
         bool bIgnoreLeaders = false
         ) const;

      void DeleteAttachment (
         const RVC::ELEMENT& element
         );

      // Detach the LABELPLACE from the LABELPLACEMENT.
      // Normally, a LABELPLACE is only a pointer to data owned by the
      // LABELPLACEMENT that's managing it.  Detach() copies the data
      // so that any changes made do not effect the master copy.
      void Detach (
         );

      ERRVALUE Draw (
         LAYERDC* pDC,   
         const COLOR* ForegroundColor = 0 
         ) const;

      ERRVALUE DrawSample (
         MGD::CONTEXT& gc,
         const COLOR* ForegroundColor = 0, 
         bool bDrawLeaders = true
         ) const;

      const MILIST<LABELATTACHMENT>& GetAttachments (
         ) const;

      double GetBaseAngle () const;

      const POLYLINE& GetBaseLine () const;

      TEXTBASEORIGIN GetBaseOrigin () const;

      const DPOINT2D& GetBasePoint () const;

      bool GetDrawBaseLine () const;
      
      bool GetBaseLineStyle (
         LINESTYLE&
         ) const;

      LAYER* GetLayer (
         ) const;

      const DPOINT2D& GetOffset (
         ) const;
      
      const DPOINT2D& GetSymbolPoint (
         ) const;

      const POINTSTYLE& GetPointStyle (
         ) const;

      const SIMPLE_ARRAY<UINT8>& GetPointSymbol (
         ) const;

      double GetPriority (
         ) const;

      const REGION2D& GetRegion (
         ) const;

      const LABELSTYLE& GetStyle (
         ) const;

      const MISTRING& GetText (
         ) const;

      bool HasPoint (
         ) const;

      bool HasText (
         ) const;

      bool IsAttached (
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) const;

      bool IsAttached (
         const RVC::ELEMENT& elem
         ) const;

      bool IsLocked (
         ) const;

      void LockPosition (
         bool locked = true
         );

      void Move (
         const DPOINT2D& delta
         );

      void AddAttachment (
         const LABELATTACHMENT& attachment
         );

      void AddAttachment (
         const RVC::ELEMENT& element
         );

      void SetBaseLine (
         const POLYLINE& baseline
         );

      void SetBaseLine (
         const DPOINT2D& pt,
         double angle,
         TEXTBASEORIGIN origin
         );

      // Set CopyOnWrite for this instance.
      // LABELPLACE is implemented as a refcounted private data pointer
      // but by default does not do Copy-On-Write.  If you get a
      // label place through an iterator and mofify it, you usually want
      // to modify the original anyway.  In the rare case that you don't
      // call this method first.
      // Note that the CONST_ITERATOR sets CopyOnWrite to true, The
      // non-const ITERATOR sets it to false
      void SetCopyOnWrite (
         bool bCopyOnWrite = true
         ) {
         m_bCopyOnWrite = bCopyOnWrite;
         }

      void SetDrawBaseLine (
         bool draw = true
         );

      void SetBaseLineStyle (
         const LINESTYLE& style
         );

      void SetPoint (
         const DPOINT2D& location
         );

      void SetPointStyle (
         const POINTSTYLE& style
         );

      void SetPointSymbol (
         const SIMPLE_ARRAY<UINT8>& symbol
         );

      void SetPointSymbol (
         const RVC::STYLEPATTERN_BASE& symbol
         );

      void SetPriority (
         double priority
         );

      void SetRegion (
         const REGION2D& region
         );

      void SetStyle (
         const LABELSTYLE& style
         );

      void SetText (
         const MISTRING& str
         );

      // Used by LABELPLACEMENT::Add()
      void SetParent (
         GRE::LABELPLACEMENT* parent
         );

      GRE::LABELPLACEMENT* GetParent (
         ) const;
      
      // For SML script access.
      // Retrieves the string attached by SetUserString.
      // note, returning const MIUNICODE* instead of MISTRING& for SML
      // implemention convenience.  SML has to construct an SMLSTRING
      // out of it anyway
      const MIUNICODE* GetUserString (
         ) const;
   
      void SetUserString (
         const MISTRING& str
         );

      void Zoom (
         double scale
         );
   
      void SetID (
         INT32 id
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;    // Actual data is a refcounted private structure
      PRIV *m_priv;  // so that copy constructor and assignment are fast
      bool m_bCopyOnWrite;
      #endif
   };

typedef MILIST<LABELPLACE> LABELPLACELIST;


class LABELPLACEMENT {
   public:
      class ITERATOR;
      class CONST_ITERATOR;
      friend class CONST_ITERATOR;

      class CONST_ITERATOR {
         public:

            CONST_ITERATOR (
               ) :
               m_placement(0),
               m_num(-1)
               { }

            virtual ~CONST_ITERATOR() {};

            CONST_ITERATOR (
               const CONST_ITERATOR& rhs
               ) :
               m_placement(rhs.m_placement),
               m_place(rhs.m_place),
               m_num(rhs.m_num)
               { }
            
            CONST_ITERATOR (
               LABELPLACEMENT* placement
               ) :
               m_placement(placement),
               m_num(-1)
               { ReadNext(true); }

            const LABELPLACE& operator* (
               ) const { return (m_place); }

            const LABELPLACE* operator-> (
               ) const { return (&**this); }

            CONST_ITERATOR& operator++ (
               ) { ReadNext(true); return *this; } 

            CONST_ITERATOR operator++ (int
               ) {
               CONST_ITERATOR temp = *this;
               ++*this;
               return(temp);
               }

            CONST_ITERATOR& operator-- (
               ) {
               ReadPrev(true);
               return *this;
               }

            CONST_ITERATOR operator--(int
               ) {
               CONST_ITERATOR temp = *this;
               --*this;
               return(temp);
               }

            bool operator== (
               const CONST_ITERATOR& rhs
               ) const {
               if (m_num == -1 && rhs.m_num == -1) return (true);
               return (m_num == rhs.m_num && m_placement == rhs.m_placement);
               }

            bool operator!= (
               const CONST_ITERATOR& rhs
               ) const { return (!(*this == rhs)); }

         protected:  // non-const iterator can access all this
            #ifndef GENERATING_DOXYGEN_OUTPUT
            LABELPLACEMENT* m_placement;
            LABELPLACE m_place;
            int m_num;
            void ReadPrev (bool bIsConst);
            void ReadNext (bool bIsConst);
            #endif
         };

      friend class ITERATOR;
      class ITERATOR : public CONST_ITERATOR {
         public:
            ITERATOR();
            
            ITERATOR(LABELPLACEMENT* placement) :
               CONST_ITERATOR(placement) 
               { }

            LABELPLACE& operator* (
               ) { return (m_place); }

            LABELPLACE* operator-> (
               ) { return (&**this); }

            ITERATOR& operator++() {
               ReadNext(false);
               return (*this);
               }

            ITERATOR operator++(int
               ) {
               ITERATOR temp = *this;
               ++*this;
               return(temp);
               }

            ITERATOR& operator--() {
               ReadPrev(false);
               return (*this);
               };

            ITERATOR operator--(int
               ) {
               ITERATOR temp = *this;
               --*this;
               return(temp);
               }

            bool operator== (
               const ITERATOR& rhs
               ) const;

            bool operator!= (
               const ITERATOR& rhs
               ) const { return (!(*this == rhs)); }
         };

      static ERRVALUE Deconflict (
         SIMPLE_ARRAY<LABELPLACEMENT*>& LabelSets
         );

      LABELPLACEMENT (
         LAYER* layer,
         VIEW* view
         );

      virtual ~LABELPLACEMENT ();

      ERRVALUE Add (
         const LABELPLACE& place
         );

      CONST_ITERATOR Begin (
         ) const { return (CONST_ITERATOR(const_cast<LABELPLACEMENT*>(this))); }

      void Clear ();

      void DeleteLabels (
         const RVC::ELEMENT& element
         );

      CONST_ITERATOR End (
         ) const { return (CONST_ITERATOR(0)); }

      INT32 Find (
         const DPOINT2D& pt,
         GRE::LABELPLACE& place,
         int maxdist = 0
         ) const;

      INT32 Find (
         const DPOINT2D& pt,
         MILIST<GRE::LABELPLACE*>& list,
         int maxdist = 0
         ) const;

      INT32 Find (
         const DRECT2D& rect,
         MILIST<GRE::LABELPLACE*>& list
         ) const;

      INT32 Find (
         const REGION2D& region,
         MILIST<GRE::LABELPLACE*>& list
         ) const;

      ERRVALUE GetCombinedRegion (
         REGION2D& region,
         bool bClear = true      
         ) const;

      bool GetLabelPlace (
         const RVC::ELEMENT& elem,
         GRE::LABELPLACE& place
         ) const;

      bool GetLabelPlaces (
         const RVC::ELEMENT& elem,
         LABELPLACELIST& places
         ) const;

      LAYER* GetLayer () const;

      int GetNumItems () const;

      VIEW* GetView () const;

   private:

      virtual bool v_CompareLabels (
         const RVC::ELEMENT& elem1,
         const RVC::ELEMENT& elem2
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV *m_priv;

   protected:
      // Used by the iterator and by SML implementation
      GRE::LABELPLACE* GetItem (
         int num
         );
   public:
      // Used by LABELPLACE::Move
      QUADTREE& GetQuadTree();

      #endif   // GENERATING_DOXYGEN_OUTPUT
   };


}  // End namespace GRE


#endif // INC_GRE_LABELPLACEMENT_H

---