style.h

Go to the documentation of this file.

/**
 * \file rvc/style.h 
 * \brief interface for the RVC::STYLE class.
 *
 * \if NODOC
 * $Id: style.h_v 1.61 2004/12/14 17:50:39 mju Exp $
 *
 * $Log: style.h_v $
 * Revision 1.61  2004/12/14 17:50:39  mju
 * Add parm to getobjfilter for saving to allow navigate under geometric.
 *
 * Revision 1.60  2004/11/19 17:54:27  mju
 * Add basepattern.isEqualDef.
 *
 * Revision 1.59  2004/11/19 14:45:52  mju
 * Add TYPE_First for more intuitive looping.
 *
 * Revision 1.58  2004/09/03 16:02:34  scowan
 * Removed text font name typedef.
 *
 * Revision 1.57  2004/06/16 17:29:08  scowan
 * Added style edit for multi style.
 *
 * Revision 1.56  2003/10/31 15:41:35  mju
 * Change DlgGetPattern to just have const mistring& for prompt.
 *
 * Revision 1.55  2003/10/15 16:27:50  scowan
 * Added more standard filters.
 *
 * Revision 1.54  2003/10/14 21:52:50  scowan
 * Added is selectable filter.
 *
 * Revision 1.53  2003/10/08 22:18:13  scowan
 * Doxygen.
 *
 * Revision 1.52  2003/10/07 17:30:20  scowan
 * Object virtual method changes.
 *
 * Revision 1.51  2003/10/03 20:15:16  linux32build!build
 * Don't capitalize enum any more. Genitor needed it, Doxygen doesn't like it.
 *
 * Revision 1.50  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.49  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.48  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.47  2003/09/08 20:25:57  dwilliss
 * Added doxygen tags for function groups
 *
 * Revision 1.46  2003/07/15 15:40:13  dwilliss
 * Gave HATCHPATTERN, BITMAPPATTERN and SYMBOLPATTERN copy constructors and
 * assignment operators.
 *
 * Revision 1.45  2003/03/19 22:38:56  scowan
 * Added unique filters for styles and patterns.
 *
 * Revision 1.44  2003/03/13 22:11:54  mju
 * Move pattern element offset array to base class protected so can clear on read.
 *
 * Revision 1.43  2003/03/04 16:53:45  scowan
 * Added write pattern name.
 *
 * Revision 1.42  2003/03/03 15:21:24  mju
 * nc.
 *
 * Revision 1.41  2003/02/27 18:53:58  mju
 * Make bitmappattern::create non-inline and remove unimplemented DeleteUnusedColors.
 *
 * Revision 1.40  2003/02/24 17:29:51  mju
 * Had comparison reversed in setOffsetAside.
 *
 * Revision 1.39  2003/02/24 15:02:24  mju
 * In line pattern get/set OffsetAside flip sign for non-line elements so consistent.
 *
 * Revision 1.38  2003/02/20 19:02:20  mju
 * Add linepattern iterator dtor.
 *
 * Revision 1.37  2003/02/06 21:33:46  scowan
 * nc.
 *
 * Revision 1.36  2003/01/31 18:48:30  mju
 * Add parm to TableEditStyleAssignment for optional dft style obj item.
 *
 * Revision 1.35  2003/01/30 23:04:33  mju
 * Allow dft ctor/op= for linepattern::element_shared since behavior would be correct.
 *
 * Revision 1.34  2003/01/30 22:36:55  mju
 * In style editor allow return of modified dftstyle.
 *
 * Revision 1.33  2003/01/30 18:27:18  mju
 * Use explicit on element_shared ctor.
 *
 * Revision 1.32  2003/01/24 17:20:37  mju
 * *** empty log message ***
 *
 * Revision 1.31  2003/01/24 16:42:41  mju
 * Try again to fix for Unix.
 *
 * Revision 1.30  2003/01/24 14:09:58  mju
 * Attempt to fix Unix compile problem.
 *
 * Revision 1.29  2003/01/23 22:37:48  mju
 * Add LINEPATTERN element stuff, iterator, etc.
 *
 * Revision 1.28  2002/10/14 16:28:01  mju
 * Fix EDITSTYLEFLAGS.
 *
 * Revision 1.27  2002/10/14 15:06:16  mju
 * Reorganize EDITSTYLEFLAGS.
 *
 * Revision 1.26  2002/10/04 17:50:46  mju
 * Add Dlg for editing cad style by attrib.
 *
 * Revision 1.25  2002/08/22 14:24:47  scowan
 * nc.
 *
 * Revision 1.24  2002/08/21 20:39:16  scowan
 * Deprecate old object name define.
 *
 * Revision 1.23  2002/08/13 13:28:59  mju
 * Change dlggetpatterns naming.
 *
 * Revision 1.22  2002/08/12 13:29:36  mju
 * Add DlgStyleEdit and DlgTableEdit... fns.
 *
 * Revision 1.21  2002/05/24 16:30:50  scowan
 * Fixed base pattern allocations.
 *
 * Revision 1.20  2002/05/23 22:28:37  scowan
 * Added more pattern methods.
 *
 * Revision 1.19  2002/05/23 20:44:16  scowan
 * Added multiple methods.
 *
 * Revision 1.18  2002/04/11 19:24:31  scowan
 * Added multiple methods dealing with in-memory style structures.
 *
 * Revision 1.17  2001/10/24 16:18:49  scowan
 * Changed return types of delete methods.
 *
 * Revision 1.14  2001/09/04 17:10:28  mju
 * Add DlgEditPattern/PatternSet method defns.
 *
 * Revision 1.13  2001/08/31 20:04:22  scowan
 * Nothing.
 *
 * Revision 1.12  2001/08/31 19:26:31  mju
 * Add WriteStyleName() method defn.
 *
 * Revision 1.11  2001/08/31 15:57:05  mju
 * Use const in FindFontName().
 *
 * Revision 1.10  2001/08/28 14:56:39  mju
 * Change StyleAdd to return style number.
 *
 * Revision 1.9  2001/08/27 14:53:28  mju
 * Use DEFINE_ENUM_OP_INCREMENT on style type.
 * Fix inclusion guard name.
 *
 * Revision 1.8  2001/06/14 16:13:02  scowan
 * Changed source type.
 *
 * Revision 1.7  2001/06/13 22:11:43  scowan
 * Added to RVC namespace.
 *
 * Revision 1.6  2001/06/13 15:04:20  scowan
 * Added new make method.
 *
 * Revision 1.5  2001/06/13 15:02:03  scowan
 * Changed enum value.
 *
 * Revision 1.4  2000/12/01 16:01:45  scowan
 * Fixed MAC errors.
 *
 * Revision 1.3  2000/11/16 17:55:51  scowan
 * Different inclusion guards for this file.
 *
 * Revision 1.1  2000/09/29 15:49:58  scowan
 * Initial revision
 * \endif
**/

#ifndef INC_RVC_STYLE_H
#define INC_RVC_STYLE_H

#ifndef INC_RVC_OBJECT_H
   #include <rvc/object.h>
#endif

#ifndef INC_MI32_RVCSTYLE_H
   #include <mi32/rvcstyle.h>
#endif

#ifndef INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

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

#ifndef INC_MI32_MGD2_H
   #include <mi32/mgd2.h>
#endif

#ifndef INC_RVC_GETOBJF_H
   #include <rvc/getobjf.h>
#endif

namespace RVC {

//!   \class STYLE rvc/style.h
//!   \brief Manages RVC::OBJTYPE_Style RVC objects.
//!   
//!   RVC Object Types that this class supports: RVC::OBJTYPE_Style.
//!
//!   Default RVC Object Type for this class: RVC::OBJTYPE_Style.
//!
//!   Valid parents for this class:
//!      - RVC::OBJTYPE_File
//!      - RVC::OBJTYPE_Folder
//!      - RVC::OBJTYPE_Vector
//!      - RVC::OBJTYPE_TIN
//!      - RVC::OBJTYPE_CAD
//!      - RVC::OBJTYPE_Table
//!      - RVC::OBJTYPE_Raster
//!      - RVC::OBJTYPE_Hyperspectral
//!      - RVC::OBJTYPE_Script_SML
//!      - RVC::OBJTYPE_Script_Query
//!      - RVC::OBJTYPE_Theme

class STYLE : public RVC::OBJECT {
   public:
   
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class BASEPATTERN;
      class BITMAPPATTERN;
      class HATCHPATTERN;
      class GETOBJFILTER_ISSELECTABLE;
      class GETOBJFILTER_HASPATTERNTYPE;
      class GETOBJFILTER_HASSTYLETYPE;
      class LINEPATTERN;
      class SYMBOLPATTERN;
      class UNIQUEPATTERNNAMEFILTER;
      class UNIQUESTYLENAMEFILTER;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      //! Style type.
      enum TYPE {
         TYPE_First =      0,
         TYPE_Point =      0,
         TYPE_Line =       1,
         TYPE_Polygon =    2,
         TYPE_Text =       3,
         TYPE_NumTypes =   4
         };

      //! Pattern type.
      enum PATTERN {
         PATTERN_Symbol = 0,
         PATTERN_Line,
         PATTERN_Bitmap,
         PATTERN_Hatch,
         PATTERN_NumTypes
         };

      //! Default constructor
      STYLE (
         );

      //! Copy constructor
      STYLE (
         const RVC::STYLE& obj
         );

      //! Destructor
      virtual ~STYLE (
         );

      //! Assignment.  Will close if necessary and reopen if 'rhs' is open
      RVC::STYLE& operator= (
         const RVC::STYLE& rhs
         );

      //! Add pattern to rvc style object
      //! @return New pattern number
      INT32 AddPattern (
         PATTERN PattType,             //!< Type of pattern to add
         void *Pattern                 //!< Pattern to add
         );
                              
      //! Add pattern to rvc style object
      //! @return New pattern number
      INT32 AddPattern (
         PATTERN PattType,          //!< Type of pattern to add
         const BASEPATTERN& Pattern             //!< Pattern to add
         );
         
      //! Add pattern to rvc style object
      //! @return New pattern number
      INT32 AddPattern (
         const BITMAPPATTERN& Pattern              //!< Pattern to add
         );
         
      //! Add pattern to rvc style object
      //! @return New pattern number
      INT32 AddPattern (
         const HATCHPATTERN& Pattern               //!< Pattern to add
         );
         
      //! Add pattern to rvc style object
      //! @return New pattern number
      INT32 AddPattern (
         const LINEPATTERN& Pattern             //!< Pattern to add
         );
         
      //! Add pattern to rvc style object
      //! @return New pattern number
      INT32 AddPattern (
         const SYMBOLPATTERN& Pattern              //!< Pattern to add
         );
         
      //! Add point style to rvc style object   
      //! @return New style number or error < 0.
      INT32 AddStyle (           
         RVCPOINTSTYLE& style          //!< Point style to add
         );
                              
      //! Add point style to rvc style object   
      //! @return New style number or error < 0.
      INT32 AddStyle (
         const RVC::OBJECTNAME& name,
         const POINTSTYLE& style          //!< Point style to add
         );
                              
      //! Add polygon style to rvc style object 
      //! @return New style number or error < 0.
      INT32 AddStyle (           
         RVCPOLYSTYLE& style           //!< Polygon style to add
         );
                              
      //! Add polygon style to rvc style object 
      //! @return New style number or error < 0.
      INT32 AddStyle (
         const RVC::OBJECTNAME& name,
         const POLYSTYLE& style           //!< Polygon style to add
         );
                              
      //! Add line style to rvc style object    
      //! @return New style number or error < 0.
      INT32 AddStyle (           
         RVCLINESTYLE& style           //!< Line style to add
         );
                              
      //! Add line style to rvc style object 
      //! @return New style number or error < 0.
      INT32 AddStyle (
         const RVC::OBJECTNAME& name,
         const LINESTYLE& style           //!< Line style to add
         );
                              
      //! Add text style to rvc style object    
      //! @return New style number or error < 0.
      INT32 AddStyle (           
         RVCTEXTSTYLE& style           //!< Text style to add
         );

      //! Add text style to rvc style object 
      //! @return New style number or error < 0.
      INT32 AddStyle (
         const RVC::OBJECTNAME& name,
         const TEXTSTYLE& style           //!< Text style to add
         );

      //! Combine two style objects together using 'this' as the source and either findint or making
      //! the destination style object.  The destination style object is returned in 'DestStyleObj'.
      ERRVALUE Combine (
         const RVC::OBJECT& DestParentObj,            //!< Parent object to combine / copy to
         RVC::STYLE& DestStyleObj,                    //!< Destination object created or found
         SIMPLE_ARRAY<INT32>& FontTrans,
         SIMPLE_ARRAY<INT32> PattTrans[PATTERN_NumTypes]
         );
         
      //! Combine two style objects together using 'this' as the source and either findint or making
      //! the destination style object.  The destination style object is returned in 'DestStyleObj'.
      ERRVALUE Combine (
         const RVC::OBJECT& DestParentObj,            //!< Parent object to combine / copy to
         RVC::STYLE& DestStyleObj                     //!< Destination object created or found
         );
         
      //! Convert between memory and rvc line styles        
      void ConvertStyle (
         RVCLINESTYLE& rvcstyle,
         const LINESTYLE& linestyle
         ) const;
         
      //! Convert between memory and rvc line styles        
      void ConvertStyle (
         LINESTYLE& linestyle,
         const RVCLINESTYLE& rvcstyle
         ) const;
         
      //! Convert between memory and rvc point styles       
      void ConvertStyle (
         RVCPOINTSTYLE& rvcstyle,
         const POINTSTYLE& pointstyle
         ) const;
         
      //! Convert between memory and rvc point styles       
      void ConvertStyle (
         POINTSTYLE& pointstyle,
         const RVCPOINTSTYLE& rvcstyle
         ) const;
         
      //! Convert between memory and rvc polygon styles        
      void ConvertStyle (
         RVCPOLYSTYLE& rvcstyle,
         const POLYSTYLE& polystyle
         ) const;
         
      //! Convert between memory and rvc polygon styles        
      void ConvertStyle (
         POLYSTYLE& polystyle,
         const RVCPOLYSTYLE& rvcstyle
         ) const;
         
      //! Convert between memory and rvc text styles        
      void ConvertStyle (
         RVCTEXTSTYLE& rvcstyle,
         const TEXTSTYLE& textstyle
         );             //! Not const, can change object
         
      //! Convert between memory and rvc text styles        
      void ConvertStyle (
         TEXTSTYLE& textstyle,
         const RVCTEXTSTYLE& rvcstyle
         ) const;
         
      //! Delete pattern from rvc style object, modifies styles that referenced the pattern
      //! @return Pattern number that replaced the deleted pattern or <0 if error
      INT32 DeletePattern (
         PATTERN PattType,             //!< Type of pattern to delete
         INT32 PattNum                 //!< Pattern index to delete
         );

      //! Delete style from rvc style object
      //! @return Style number that replaced the deleted style or <0 if error
      INT32 DeleteStyle (
         TYPE StyleType,               //!< Type of style to delete
         INT32 StyleNum                //!< Style index to delete
         );

      //! Delete all styles of a specified type from rvc style object
      ERRVALUE DeleteStyleType (
         TYPE StyleType                //!< Type of style to delete
         );

      //! Locate a font based on a font name and initial position
      //! @return Index of font name if found, -1 if none found, < -1 error code
      INT32 FindFontName (
         INT32 start,                  //!< Best guess of initial font location
         const MISTRING& name          //!< Font to search for
         ) const;

      //! Add a font name to the font name list
      //! @return Index of added font name or error if < 0
      INT32 FontTransAdd (
         const MISTRING& name          //!< Name of font to add
         );

      //! Obtain font handle from a font index
      //! @return font handle of error if < 0
      INT32 FontTransIndexToHandle (
         INT32 FontNum                 //!< Font index to translate into a font handle
         );

      //! Obtain font index from a font name
      //! @return font index of error if < 0
      ERRVALUE FontTransIndexToName (
         INT32 FontNum,          
         MISTRING& name                //!< Name of font to translate into an index
         ) const;

      //! Find a pattern given a name and the pattern type
      //! @return -1 if pattern not found, >= 0 Pattern index if found, < -1 error
      INT32 FindPattern (
         PATTERN PattType,             //!< Type of pattern to search for
         INT32 StartPattNum,           //!< Best guess of initial pattern location
         const RVC::OBJECTNAME& name   //!< Name of pattern to find
         ) const;

      //! Find a style given a name and the style type
      //! @return -1 if style not found, >= 0 Style index if found, < -1 error
      INT32 FindStyle (
         TYPE StyleType,               //!< Type of style to search for
         INT32 StartStyleNum,          //!< Best guess of initial style location
         const RVC::OBJECTNAME& name   //!< Name of style to find
         ) const;

      //! Obtain the number of font names in the list
      //! @return Number of font names
      INT32 GetFontNameCount (
         ) const;

      //! Obtain the number of patterns of a specific pattern type
      //! @return Number of patterns of the requested pattern type or < 0 if error
      INT32 GetPatternCount (
         PATTERN PattType              //!< Type of pattern to get count of
         ) const;

      //! Obtain the maximum pattern size of a specific pattern type
      //! @return Maximum pattern size of the requested pattern type or < 0 if error
      INT32 GetPatternMaxSize (
         PATTERN PattType              //!< Type of pattern to get the maximum size of
         ) const;

      //! Obtain the pattern size of a specific pattern type
      //! @return Pattern size of the requested pattern type or < 0 if error
      INT32 GetPatternSize (
         PATTERN PattType,             //!< Type of pattern to get the size of
         INT32 PattNum                 //!< Pattern index to get the size of
         ) const;

      //! Obtain the number of styles of a specific style type
      //! @return Number of styles of the requested style type or < 0 if error
      INT32 GetStyleCount (
         TYPE StyleType                //!< Type of style to get count of
         ) const;

      //! Create a new rvc style object under a specified parent rvc object with name, description, and source
      ERRVALUE Make (
         const RVC::OBJECT& parent,    //!< Parent object to create style object under
         const RVC::OBJECTNAME& name,  //!< Name of new style object
         const RVC::OBJECTDESC& desc,  //!< Description of new style object
         const char* Source = 0        //!< Source of new style object, default is application name
         );

      //! Create a new rvc style object under a specified parent rvc object with name, description, and source
      ERRVALUE Make (
         const RVC::OBJITEM& ObjItem,  //!< Name, Desc of object to create 
         const char* Source = 0        //!< Source of new style object, default is application name
         );

      //! Read a pattern into a buffer.  The format of the pattern is pattern type specific
      ERRVALUE ReadPattern (
         PATTERN PattType,             //!< Type of pattern to read
         INT32 PatternNum,             //!< Index of pattern to read
         void *Pattern                 //!< Pattern buffer to read into
         ) const;
      
      //! Read a pattern into a buffer.  The format of the pattern is pattern type specific
      ERRVALUE ReadPattern (
         PATTERN PattType,             //!< Type of pattern to read
         INT32 PatternNum,             //!< Index of pattern to read
         BASEPATTERN& Pattern          //!< Pattern buffer to read into
         ) const;
      
      //! Read a pattern into a buffer.  The format of the pattern is pattern type specific
      ERRVALUE ReadPattern (
         INT32 PatternNum,             //!< Index of pattern to read
         BITMAPPATTERN& Pattern           //!< Pattern buffer to read into
         ) const;
      
      //! Read a pattern into a buffer.  The format of the pattern is pattern type specific
      ERRVALUE ReadPattern (
         INT32 PatternNum,             //!< Index of pattern to read
         HATCHPATTERN& Pattern            //!< Pattern buffer to read into
         ) const;
      
      //! Read a pattern into a buffer.  The format of the pattern is pattern type specific
      ERRVALUE ReadPattern (
         INT32 PatternNum,             //!< Index of pattern to read
         LINEPATTERN& Pattern          //!< Pattern buffer to read into
         ) const;
      
      //! Read a pattern into a buffer.  The format of the pattern is pattern type specific
      ERRVALUE ReadPattern (
         INT32 PatternNum,             //!< Index of pattern to read
         SYMBOLPATTERN& Pattern           //!< Pattern buffer to read into
         ) const;
      
      //! Read a pattern header into a buffer.
      ERRVALUE ReadPatternHdr (
         PATTERN PattType,             //!< Type of pattern to read
         INT32 PatternNum,             //!< Index of pattern to read
         void *PattHdr                 //!< Pattern header buffer to read into
         ) const;

      //! Read a pattern name
      ERRVALUE ReadPatternName (
         PATTERN PattType,             //!< Type of pattern to read
         INT32 PattNum,                //!< Index of pattern to read
         RVC::OBJECTNAME& name         //!< Place to store pattern name
         ) const;

      //! Read a point style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of point style to read
         RVCPOINTSTYLE& style          //!< Point style instance to read into
         ) const;

      //! Read a point style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of point style to read
         POINTSTYLE& style          //!< Point style instance to read into
         ) const;

      //! Read a polygon style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of polygon style to read
         RVCPOLYSTYLE& style           //!< Polygon style instance to read into
         ) const;

      //! Read a polygon style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of polygon style to read
         POLYSTYLE& style           //!< Polygon style instance to read into
         ) const;

      //! Read a line style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of line style to read
         RVCLINESTYLE& style           //!< Line style instance to read into
         ) const;

      //! Read a line style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of line style to read
         LINESTYLE& style           //!< Line style instance to read into
         ) const;

      //! Read a text style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of text style to read
         RVCTEXTSTYLE& style           //!< Tezt style instance to read into
         ) const;

      //! Read a text style item
      ERRVALUE ReadStyle (
         INT32 StyleNum,               //!< Index of text style to read
         TEXTSTYLE& style           //!< Tezt style instance to read into
         ) const;

      //! Read style name given a style type
      ERRVALUE ReadStyleName (
         TYPE StyleType,               //!< Type of style to get the name of
         INT32 StyleNum,               //!< Index of style to get the name of
         RVC::OBJECTNAME& name         //!< Place to store style name
         ) const;

      //! Write pattern out to rvc style object
      ERRVALUE WritePattern (
         PATTERN PattType,             //!< Type of pattern to write
         INT32 PatternNum,             //!< Index of pattern to write, Use AddPattern() to write out a new pattern
         void *Pattern                 //!< Pattern to write
         );

      //! Write pattern out to rvc style object
      ERRVALUE WritePattern (
         PATTERN PattType,             //!< Type of pattern to write
         INT32 PatternNum,             //!< Index of pattern to write, Use AddPattern() to write out a new pattern
         const BASEPATTERN& Pattern                //!< Pattern to write
         );

      //! Write pattern out to rvc style object
      ERRVALUE WritePattern (
         INT32 PatternNum,             //!< Index of pattern to write, Use AddPattern() to write out a new pattern
         const BITMAPPATTERN& Pattern                 //!< Pattern to write
         );

      //! Write pattern out to rvc style object
      ERRVALUE WritePattern (
         INT32 PatternNum,             //!< Index of pattern to write, Use AddPattern() to write out a new pattern
         const HATCHPATTERN& Pattern                  //!< Pattern to write
         );

      //! Write pattern out to rvc style object
      ERRVALUE WritePattern (
         INT32 PatternNum,             //!< Index of pattern to write, Use AddPattern() to write out a new pattern
         const LINEPATTERN& Pattern                //!< Pattern to write
         );

      //! Write pattern out to rvc style object
      ERRVALUE WritePattern (
         INT32 PatternNum,             //!< Index of pattern to write, Use AddPattern() to write out a new pattern
         const SYMBOLPATTERN& Pattern                 //!< Pattern to write
         );

      //! Write pattern name given a pattern type.
      ERRVALUE WritePatternName (
         PATTERN PattType,             //!< Type of pattern to write name
         INT32 PatternNum,             //!< Index of pattern to write name
         const OBJECTNAME& name        //!< New name of pattern
         );
   
      //! Write point style to rvc style object
      ERRVALUE WriteStyle (
         INT32 StyleNum,               //!< Index of point style to write.  Use AddStyle() to add a style
         RVCPOINTSTYLE& style          //!< Point style to write
         );

      //! Write point style to rvc style object
      ERRVALUE WriteStyle (
         INT32 StyleNum,               //!< Index of point style to write.  Use AddStyle() to add a style
         const RVC::OBJECTNAME& name,
         const POINTSTYLE& style          //!< Point style to write
         );

      //! Write polygon style to rvc style object
      ERRVALUE WriteStyle (            
         INT32 StyleNum,               //!< Index of polygon style to write.  Use AddStyle() to add a style.
         RVCPOLYSTYLE& style           //!< Polygon style to write
         );

      //! Write polygon style to rvc style object
      ERRVALUE WriteStyle (            
         INT32 StyleNum,               //!< Index of polygon style to write.  Use AddStyle() to add a style.
         const RVC::OBJECTNAME& name,
         const POLYSTYLE& style           //!< Polygon style to write
         );

      //! Write line style to rvc style object
      ERRVALUE WriteStyle (
         INT32 StyleNum,               //!< Index of line style to write.  Use AddStyle() to add a style.
         RVCLINESTYLE& style           //!< Line style to write
         );

      //! Write line style to rvc style object
      ERRVALUE WriteStyle (
         INT32 StyleNum,               //!< Index of line style to write.  Use AddStyle() to add a style.
         const RVC::OBJECTNAME& name,
         const LINESTYLE& style           //!< Line style to write
         );

      //! Write text style to rvc style object.
      ERRVALUE WriteStyle (
         INT32 StyleNum,               //!< Index of text style to write.  Use AddStyle() to add a style.
         RVCTEXTSTYLE& style           //!< Text style to write
         );

      //! Write text style to rvc style object.
      ERRVALUE WriteStyle (
         INT32 StyleNum,               //!< Index of text style to write.  Use AddStyle() to add a style.
         const RVC::OBJECTNAME& name,
         const TEXTSTYLE& style           //!< Text style to write
         );

      //! Write style name given a style type.
      ERRVALUE WriteStyleName (
         TYPE StyleType,               //!< Type of style
         INT32 StyleNum,               //!< Index of style
         const RVC::OBJECTNAME& name   //!< Style name to write
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent);

      int m_StyleID;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


//! Base pattern class.
class STYLE::BASEPATTERN {
   public:

      //! Default constructor used by style object.
      BASEPATTERN (
         ) : m_PattBuff(0), m_PattHdrSize(sizeof(RVCPATTHDR)), m_PattBuffSize(sizeof(RVCPATTHDR)), m_BuffSizeAlloc(sizeof(RVCPATTHDR))
         { MmAllocCExc((void**)&m_PattBuff, m_PattBuffSize); }
         
      //! Destructor.
      ~BASEPATTERN (
         ) { MmFree(m_PattBuff); }

      //! Append color to end of palette.
      //! Note, this will invalidate all derived class ITERATORs.
      ERRVALUE AppendColor (
         const COLOR& color
         );

      //! Clear pattern contents.
      void Clear (
         ) { m_PattBuffSize = m_PattHdrSize; memset(m_PattBuff,0,m_PattHdrSize); }

      //! Get pattern name.         
      const RVC::OBJECTNAME& GetName (
         ) const { return (*reinterpret_cast<const RVC::OBJECTNAME*>(m_PattBuff)); }

      //! Get color at specified palette index.
      const COLOR& GetColor (
         UINT8 idx
         ) const { return (GetColors()[idx]); }

      //! Get color palette.
      const COLOR* GetColors (
         ) const { return (reinterpret_cast<COLOR*>(m_PattBuff + m_PattHdrSize)); }
         
      //! Get number of colors in pattern palette.
      INT32 GetNumColors (
         ) const { return (reinterpret_cast<const RVCPATTHDR*>(m_PattBuff)->numcolors); }

      //! Get number of pattern elements.
      INT32 GetNumElements (
         ) const { return (reinterpret_cast<const RVCPATTHDR*>(m_PattBuff)->numelements); }

      //! Get pattern buffer size.
      // XXX make protected when possible.
      INT32 GetSize (
         ) const { return (m_PattBuffSize); }

      //! Determine if pattern definitions equal, excluding name.
      bool IsEqualDef (
         const BASEPATTERN& rhs
         ) const {
         if (m_PattBuffSize != rhs.m_PattBuffSize) return (false);
         return (memcmp(m_PattBuff+sizeof(RVC::OBJECTNAME),rhs.m_PattBuff+sizeof(RVC::OBJECTNAME),m_PattBuffSize-sizeof(RVC::OBJECTNAME))==0);
         }

      //! Set color at specified palette index.
      void SetColor (
         UINT8 idx,
         const COLOR& color
         ) { if (idx < GetNumColors()) reinterpret_cast<COLOR*>(m_PattBuff + m_PattHdrSize)[idx] = color; }

      //! Set pattern name.
      void SetName (
         const OBJECTNAME& name
         ) { *reinterpret_cast<RVC::OBJECTNAME*>(m_PattBuff) = name; }

      //! To support legacy code, for now.
      // XXX delete when drawing code updated.
      operator const void* (
         ) const { return (m_PattBuff); }
         
   protected:

      //! Constructor used by derived classes.
      BASEPATTERN (
         int PattHdrSize
         ) : m_PattBuff(0), m_PattHdrSize(PattHdrSize), m_PattBuffSize(PattHdrSize), m_BuffSizeAlloc(PattHdrSize)
         { MmAllocCExc((void**)&m_PattBuff, m_PattBuffSize); }
         
      //! Copy constructor.
      BASEPATTERN (const BASEPATTERN& rhs);

      //! Assignment.
      BASEPATTERN& operator= (const BASEPATTERN& rhs);
      
      //! Delete colors in specified set.
      void DeleteColorSet (
         const UINT8 *set              //!< Byte array with entries set to non-zero to delete, zero to retain
         );

      //! Delete from pattern buffer at specified location.
      void DeleteFromBuffer (
         INT32 offset,
         INT32 numbytes
         );

      //! Get const pointer to pattern buffer.
      const UINT8* GetPattBuffer (
         ) const { return (m_PattBuff); }

      //! Get non-const pointer to pattern buffer.
      UINT8* GetPattBuffer (
         ) { return (m_PattBuff); }

      //! Get const pointer to first pattern 'element'.
      const UINT8* GetFirstElemPtr (
         ) const { return (m_PattBuff+m_PattHdrSize+GetNumColors()*sizeof(COLOR)); }

      //! Get non-const pointer to first pattern 'element'.
      UINT8* GetFirstElemPtr (
         ) { return (m_PattBuff+m_PattHdrSize+GetNumColors()*sizeof(COLOR)); }

      //! Insert space into pattern buffer at specified location
      ERRVALUE InsertIntoBuffer (
         INT32 offset,
         INT32 numbytes,
         const void *data = 0
         );
         
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT8* m_PattBuff;
      INT32 m_PattHdrSize;
      INT32 m_PattBuffSize;
      mutable SIMPLE_ARRAY<UINT32> m_OffsetArray;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      INT32 m_BuffSizeAlloc;

      friend class STYLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Bitmap pattern class.  
class STYLE::BITMAPPATTERN : public STYLE::BASEPATTERN {
   public:

      //! Default constructor.
      BITMAPPATTERN (
         ) : BASEPATTERN(sizeof(BITMAPPATTHDR)) {}

      //! Copy constructor.
      BITMAPPATTERN (
         const BITMAPPATTERN& rhs
         ) : BASEPATTERN(rhs) {}

      //! Destructor.
      ~BITMAPPATTERN (
         ) { }

      //! Assignment.
      BITMAPPATTERN& operator= (
         const BITMAPPATTERN& rhs
         ) { if (this != &rhs) { BASEPATTERN::operator=(rhs); } return (*this); }
         
      ERRVALUE Create (
         INT16 xsize,
         INT16 ysize
         );
         
      UINT8 GetCell (
         INT16 x,
         INT16 y
         ) const { return (GetFirstElemPtr()[y*GetSizeX()+x]); }

      INT16 GetHotSpotX (
         ) const { return (reinterpret_cast<const BITMAPPATTHDR*>(m_PattBuff)->xhot); }

      INT16 GetHotSpotY (
         ) const { return (reinterpret_cast<const BITMAPPATTHDR*>(m_PattBuff)->yhot); }

      INT16 GetIntervalX (
         ) const { return (reinterpret_cast<const BITMAPPATTHDR*>(m_PattBuff)->xspace); }

      INT16 GetIntervalY (
         ) const { return (reinterpret_cast<const BITMAPPATTHDR*>(m_PattBuff)->yspace); }

      INT16 GetSizeX (
         ) const { return (reinterpret_cast<const BITMAPPATTHDR*>(m_PattBuff)->xsize); }

      INT16 GetSizeY (
         ) const { return (reinterpret_cast<const BITMAPPATTHDR*>(m_PattBuff)->ysize); }

      void SetCell (
         INT16 x,
         INT16 y,
         UINT8 value
         ) { GetFirstElemPtr()[y*GetSizeX()+x] = value; }

      void SetHotSpotX (
         INT16 hotspotx
         ) { reinterpret_cast<BITMAPPATTHDR*>(m_PattBuff)->xhot = hotspotx; }

      void SetHotSpotY (
         INT16 hotspoty
         ) { reinterpret_cast<BITMAPPATTHDR*>(m_PattBuff)->yhot = hotspoty; }

      void SetIntervalX (
         INT16 intervalx
         ) { reinterpret_cast<BITMAPPATTHDR*>(m_PattBuff)->xspace = intervalx; }

      void SetIntervalY (
         INT16 intervaly
         ) { reinterpret_cast<BITMAPPATTHDR*>(m_PattBuff)->yspace = intervaly; }

   };
   

//! Hatch pattern class.
class STYLE::HATCHPATTERN : public STYLE::BASEPATTERN {
   public:
      HATCHPATTERN (
         ) : BASEPATTERN(sizeof(HATCHPATTHDR)) {}
      
      //! Copy constructor.
      HATCHPATTERN (
         const HATCHPATTERN& rhs
         ) : BASEPATTERN(rhs) {}

      //! Destructor.
      ~HATCHPATTERN (
         ) { }

      //! Assignment.
      HATCHPATTERN& operator= (
         const HATCHPATTERN& rhs
         ) { if (this != &rhs) { BASEPATTERN::operator=(rhs); } return (*this); }
         
   };


//! Line pattern class. 
class STYLE::LINEPATTERN : public STYLE::BASEPATTERN {
   public:

      enum ELEMENT_TYPE {
         ELEMENT_TYPE_Line =        0,
         ELEMENT_TYPE_CrossLine =   1,
         ELEMENT_TYPE_Circle =      2,
         ELEMENT_TYPE_Polyline =    3,
         ELEMENT_TYPE_Polygon =     4,
         ELEMENT_TYPE_Text =        5,
         ELEMENT_TYPE_Symbol =      6,
         ELEMENT_TYPE_COUNT
         };

      class ITERATOR;
      class ELEMENT;

      //! Pattern element referencing shared memory buffer.
      //! Primarily used by ITERATOR.
      class ELEMENT_SHARED {
         public:

            //! Get cap style.
            //! @return Line cap style.
            MGD::LINECAP GetCapStyle (
               ) const { return ((m_pData->flags & LINEPATTFLAG_CapRound) ? MGD::LINECAP_Round : MGD::LINECAP_Butt); }

            //! Get color index.
            //! @return Index into color array.
            UINT8 GetColorIndex (
               ) const { return (m_pData->colornum); }

            //! Get interval between repeated elements.
            //! @return Interval in 1/100 millimeter.
            INT16 GetInterval (
               ) const { return (m_pData->xspacing); }
               
            MGD::LINEJOIN GetJoinStyle (
               ) const { return ((m_pData->flags & LINEPATTFLAG_JoinMiter) ? MGD::LINEJOIN_Miter : (m_pData->flags & LINEPATTFLAG_JoinBevel) ? MGD::LINEJOIN_Bevel : MGD::LINEJOIN_Round); }

            //! Get offset to start of element along line from beginning.
            //! @return Offset in 1/100 millimeter.
            INT16 GetOffsetAlong (
               ) const { return (m_pData->xoffset); }

            //! Get offset aside line (left -, right +).
            //! @return Offset in 1/100 millimeter.
            INT16 GetOffsetAside (
               ) const { return ((m_pData->type != ELEMENT_TYPE_Line) ? -m_pData->yoffset : m_pData->yoffset); }

            //! Get size/length of element.
            //! @return Size in 1/100 millimeter.
            INT16 GetSize (
               ) const { return (m_pData->xsize); }

            //! Get element line thickness.
            //! @return Thickness in 1/100 millimeter.
            INT16 GetThickness (
               ) const { return (m_pData->thickness); }

            //! Get element type.
            //! @return Element type.
            ELEMENT_TYPE GetType (
               ) const { return (static_cast<ELEMENT_TYPE>(m_pData->type)); }

            //! Determine if element is 'filled'.
            //! @return 'true' if filled, 'false' if not.
            bool IsFilled (
               ) const { return ((m_pData->flags & LINEPATTFLAG_Filled) != 0); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            const LINEPATTELEM *m_pData;
            void *m_pExtra;

            //! Default constructor.
            ELEMENT_SHARED (
               ): m_pData(0), m_pExtra(0) { }

            explicit ELEMENT_SHARED (const void *pElemData)
               : m_pData(static_cast<const LINEPATTELEM*>(pElemData)), m_pExtra(static_cast<UINT8*>(const_cast<void*>(pElemData)) + sizeof(LINEPATTELEM))
               { }

            //! Destructor.
            ~ELEMENT_SHARED (
               ) { }

            friend class RVC::STYLE::LINEPATTERN;
            friend class ELEMENT;
            friend class ITERATOR;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      //! Pattern element.
      class ELEMENT : public ELEMENT_SHARED {
         public:

            //! Default constructor.
            ELEMENT (
               ) { memset(&m_MyData,0,sizeof(m_MyData)); m_pData = &m_MyData; }

            //! Copy constructor.
            ELEMENT (
               const ELEMENT& rhs
               );

            //! Construct from ELEMENT_SHARED.
            ELEMENT (
               const ELEMENT_SHARED& rhs
               );

            //! Construct element of specified type.
            explicit ELEMENT (
               ELEMENT_TYPE type
               );

            //! Destructor.
            ~ELEMENT (
               ) { if (m_pExtra != 0) free(m_pExtra); }

            //! Assignment from ELEMENT.
            ELEMENT& operator= (
               const ELEMENT& rhs
               );

            //! Assignment from ELEMENT_SHARED.
            ELEMENT& operator= (
               const ELEMENT_SHARED& rhs
               );

            //! Set line 'cap style' for dashed and crossing lines.
            void SetCapStyle (
               MGD::LINECAP linecap
               ) { if (linecap == MGD::LINECAP_Round) m_MyData.flags |= LINEPATTFLAG_CapRound; else m_MyData.flags &= ~LINEPATTFLAG_CapRound; }

            //! Set element color index.
            void SetColorIndex (
               UINT8 idx
               ) { m_MyData.colornum = idx; }

            void SetFilled (
               bool filled
               ) { if (filled) m_MyData.flags |= LINEPATTFLAG_Filled; else m_MyData.flags &= ~LINEPATTFLAG_Filled; }

            void SetInterval (
               INT16 interval
               ) { m_MyData.xspacing = interval; }

            void SetJoinStyle (
               MGD::LINEJOIN linejoin
               ) {
               m_MyData.flags &= ~(LINEPATTFLAG_JoinMiter|LINEPATTFLAG_JoinBevel);
               if (linejoin == MGD::LINEJOIN_Miter) m_MyData.flags |= LINEPATTFLAG_JoinMiter;
               else if (linejoin == MGD::LINEJOIN_Bevel) m_MyData.flags |= LINEPATTFLAG_JoinBevel;
               }

            void SetOffsetAlong (
               INT16 offset
               ) { m_MyData.xoffset = offset; }

            void SetOffsetAside (
               INT16 offset
               ) { m_MyData.yoffset = (m_MyData.type != ELEMENT_TYPE_Line) ? -offset : offset; }

            void SetSize (
               INT16 size
               ) { m_MyData.xsize = size; }

            void SetThickness (
               INT16 thickness
               ) { m_MyData.thickness = thickness; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            LINEPATTELEM m_MyData;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      //! Iterator to process pattern elements.
      class ITERATOR {
         public:

            //! Default constructor.
            ITERATOR (
               ): m_pEnd(0) { }

            //! Destructor.
            ~ITERATOR (
               ) { }

            //! Dereference operator, returns reference to ELEMENT_SHARED.
            const ELEMENT_SHARED& operator* (
               ) const { return (m_element); }

            //! Dereference operator, returns pointer to ELEMENT_SHARED.
            const ELEMENT_SHARED* operator-> (
               ) const { return (&m_element); }

            //! Pre-increment operator.
            ITERATOR& operator++ ();

            //! Equality operator
            bool operator== (
               const ITERATOR& rhs
               ) const { return ((m_pEnd == 0 && rhs.m_pEnd == 0) || m_element.m_pData == rhs.m_element.m_pData); }

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

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            ELEMENT_SHARED m_element;
            const void *m_pEnd;

            ITERATOR (const void *pData, const void *pEnd)
               : m_element(pData), m_pEnd(pEnd)
               { }

            friend class RVC::STYLE::LINEPATTERN;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      //! Default constructor.
      LINEPATTERN (
         ) : BASEPATTERN(sizeof(LINEPATTHDR)) {}

      //! Copy constructor.
      LINEPATTERN (
         const LINEPATTERN& rhs
         ) : BASEPATTERN(rhs) {}

      //! Destructor.
      ~LINEPATTERN (
         ) { }

      //! Assignment.
      LINEPATTERN& operator= (
         const LINEPATTERN& rhs
         ) { if (this != &rhs) { BASEPATTERN::operator=(rhs); } return (*this); }

      //! Get iterator for beginning element.
      ITERATOR Begin (
         ) const { return (ITERATOR(GetFirstElemPtr(),GetPattBuffer()+GetSize())); }

      //! Delete element at specified index.
      //! This will invalidate all ITERATORs.
      ERRVALUE DeleteElement (
         unsigned idx
         );

      //! Delete unused colors from pattern palette.
      //! This will invalidate all ITERATORs.
      void DeleteUnusedColors (
         );

      //! Get iterator for end comparison.
      ITERATOR End (
      #ifdef WIN32
         ) const { return (ITERATOR()); }
      #else
         ) const { ITERATOR it; return (it); }
      #endif

      //! Get element at specified index.
      //! Note, this is less efficient than using iterator.
      ELEMENT GetElement (
         unsigned idx
         ) const;

      //! Get extent of pattern to 'left' as drawn (not including 'crossing' elements).
      INT16 GetExtentLeft (
         ) const { return (reinterpret_cast<LINEPATTHDR*>(m_PattBuff)->extentsa); }

      //! Get extent of pattern to 'right' as drawn (not including 'crossing' elements).
      INT16 GetExtentRight (
         ) const { return (reinterpret_cast<LINEPATTHDR*>(m_PattBuff)->extentsb); }

      //! Insert element at specified index.
      //! This will invalidate all ITERATORs.
      ERRVALUE InsertElement (
         unsigned idx,
         const ELEMENT& element
         );

      //! Set (replace) element at specified index.
      //! If element size changes this will invalidate all ITERATORs.
      ERRVALUE SetElement (
         unsigned idx,
         const ELEMENT& element
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      ERRVALUE BuildOffsetIndex () const;
      INT32 GetOffset (unsigned idx) const;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


//! Point symbol pattern class.
class STYLE::SYMBOLPATTERN : public STYLE::BASEPATTERN {
   public:
      SYMBOLPATTERN (
         ) : BASEPATTERN(sizeof(SYMBOLHDR)) {}
      
      //! Copy constructor.
      SYMBOLPATTERN (
         const SYMBOLPATTERN& rhs
         ) : BASEPATTERN(rhs) {}

      //! Destructor.
      ~SYMBOLPATTERN (
         ) { }

      //! Assignment.
      SYMBOLPATTERN& operator= (
         const SYMBOLPATTERN& rhs
         ) { if (this != &rhs) { BASEPATTERN::operator=(rhs); } return (*this); }
   };

   
DEFINE_ENUM_OP_INCREMENT(RVC::STYLE::TYPE);
DEFINE_ENUM_OP_INCREMENT(RVC::STYLE::PATTERN);


//! Style object selection filter to disallow selection of non style objects
class STYLE::GETOBJFILTER_ISSELECTABLE : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISSELECTABLE (
         bool IsSaving = false      //!< Set if saving to allow navigation under geometric objects.
         );
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      bool m_IsSaving;
      virtual bool v_HasSelectableSubObjects (const RVC::OBJITEM& objitem);
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Style object selection filter to disallow selection of non style objects 
//! or style objects that do not have the requested pattern type
class STYLE::GETOBJFILTER_HASPATTERNTYPE : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASPATTERNTYPE (
         STYLE::PATTERN PatternType
         ) : m_PatternType(PatternType) {}
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      STYLE::PATTERN m_PatternType;
      
      virtual bool v_HasSele