CgmObj.h

// CgmObj.h - interface for CCgmBaseObj and derivatives
//

#ifdef WIN32
#pragma warning(4: 4640)
#endif

#ifndef __DRAWOBJ_H__
#define __DRAWOBJ_H__

#define _USE_MATH_DEFINES
#include <cmath>

#include "Utility/wstring.h"


        #define TX_NIST                 7
        #define TX_IGNORE               8

        #ifdef WIN32
        #       define MAXPATHLEN      _MAX_PATH
        #else
        #       define MAXPATHLEN      1024
        #endif

        #define RGB2ULONG(r,g,b)                (0x00000000 | \
                        (((r) & 0xFF) << 24) | (((g) & 0xFF) << 16) | (((b) & 0xFF) << 8))


        #define  GINDIVIDUAL         0     /* Aspect Source Flag                */
        #define  GBUNDLED            1

        #define GDI_VC_FRACTION 0
        #define GDI_VC_MM       1
        #define GDI_VC_PDC      2

        #define DM_CLEAR      0x0    /* d' = 0 */
        #define DM_AND        0x1    /* d' = d AND s */
        #define DM_NDAND      0x2    /* d' = s AND (NOT d) */
        #define DM_REPLACE    0x3    /* d' = s */
        #define DM_NSAND      0x4    /* d' = (NOT s) AND d */
        #define DM_NOP        0x5    /* d' = d */
        #define DM_XOR        0x6    /* d' = s XOR d */
        #define DM_OR         0x7    /* d' = s OR d */
        #define DM_NOR        0x8    /* d' = NOT (s OR d) */
        #define DM_NXOR       0x9    /* d' = NOT (s XOR d) */
        #define DM_FLIP       0xA    /* d' = NOT d */
        #define DM_NDOR       0xB    /* d' = s OR (NOT d) */
        #define DM_MIRROR     0xC    /* d' = NOT s */
        #define DM_NSOR       0xD    /* d' = (NOT s) OR d */
        #define DM_NAND       0xE    /* d' = NOT (s AND d) */
        #define DM_SET        0xF    /* d' = 1 */
        #define DM_BM1        0x10   /* d' = min(s,d) - blending method #1 */

        #define DM_ALPHA      0x11   /* alpha blending */

/* nearest integer function */
#ifndef NINT
#define NINT(i) ( (long)(i + ((i < 0.)? -0.5: 0.5) ) )
#endif
#ifndef ININT
#define ININT(i) ( (int)(i + ((i < 0.)? -0.5: 0.5) ) )
#endif


#define GREGION_RECTANGLE       1
#define GREGION_ELLIPSE 2
#define GREGION_POLYGON 3
#define GREGION_POLYBEZIER      4
#define GREGION_POLYLINE        5       // not a registered WebCGM region type

//              Edge flags bits
#define PGS_VISIBLE                     0x01
#define PGS_CLOSE                       0x02
#define PGS_NEW_REGION          0x04
#define PGS_CONNECT                     0x08

#define PGS_IS_VISIBLE(k) (k & PGS_VISIBLE)
#define PGS_IS_CLOSE(k)   (k & PGS_CLOSE)

#define CGM_PI  3.14159265358979323846264338327950288
#define degree_to_radian(deg) (CGM_PI * deg / 180.0)
#define radian_to_degree(rad) (180.0 * rad / CGM_PI)
#define Cvt2PosAngle(a) while (a < 0) a += CGM_PI * 2;

#define vectorLength(vec) ( sqrt(vec.x * vec.x + vec.y * vec.y) )

#include "Utility/DPoint.h"
#include "Utility/LPoint.h"
#include "Utility/FPoint.h"
#include "Figure.h"
#include "Path.h"
#include "Clipping.h"
#include "TextExtent.h"
#include "CgmObjects.h"
#include "HatchStyles.h"
#include "Matrix.h"
#include "PolyPolylineData.h"
#include "InterpInteriorParams.h"


typedef void* CGMLIB2_HANDLE;

namespace Larson {

#define BwRasterCompressionNone 0 
#define BwRasterCompressionGroup4 1

#define ColorRasterCompressionNone 0 
#define ColorRasterCompressionRLE 1 
#define ColorRasterCompressionPNG 2 
#define ColorRasterCompressionJPEG 3


// CCgmBaseObj - base class for all 'graphical elelments and attributtes'

class CCgmBaseObj
{
protected:
        CCgmBaseObj() {};

public:

// Begin Enums

        enum Shape {
                polyline                        = 0x00000000,
                disjointPolyline        = 0x00000001,
                polyMarker                      = 0x00000002,
                text                            = 0x00000004,
                restrictedText          = 0x00000008,
                appendText                      = 0x00000010,
                polygon                         = 0x00000020,
                polygonSet                      = 0x00000040,
                cellArray                       = 0x00000080,
                rectangle                       = 0x00000100,
                circle                          = 0x00000200,
                arc3Pt                          = 0x00000400,
                arc3PtClose                     = 0x00000800,
                arcCenter                       = 0x00001000,
                arcCenterClose          = 0x00002000,
                ellipse                         = 0x00004000,
                ellipticalArc           = 0x00008000,
                ellipticalArcClose      = 0x00010000,
                arcCenterRev            = 0x00020000,
                nub                                     = 0x00040000,
                nurb                            = 0x00080000,
                polybezier                      = 0x00100000,
                tile                            = 0x00200000,
                compoundLine            = 0x00400000,
                figure                          = 0x00800000,
                trace                           = 0x01000000,
                arrow                           = 0x02000000,
                callout                         = 0x04000000,
                hyperbolicArc           = 0x08000000,
                parabolicArc            = 0x10000000,
                copySegment                     = 0x20000000,
                polySymbol                      = 0x40000000,
                compoundText            = 0x80000000,
                gdp                                     = 0x00000003,
                message                         = 0x00000007,
                applicationData         = 0x0000000F
        };

        enum CellPathDirection {
                cellPathDir0    = 0,
                cellPathDir90   = 1,
                cellPathDir180  = 2,
                cellPathDir270  = 3
        };

        enum LineProgressionDirection {
                lineProgressionDir90    = 0,
                lineProgressionDir270   = 1
        };

        enum InheritanceFlags {
                inhFlagStateList        = 0,
                inhFlagAppStruct        = 1
        };

        enum CharSetType {
                charSet94G                      = 0,
                charSet96G                      = 1,
                charSet94MultiByteG     = 2,
                charSet96MultiByteG     = 3,
                charSetComplete         = 4
        };

        enum LocationDataTypeSelector {
                locDataTypeSelUI8       = 0,
                locDataTypeSelUI16      = 1,
                locDataTypeSelUI32      = 2
        };

        enum ColourSelectionMode {
                colourSelectIndexed     = 0,
                colourSelectDirect      = 1
        };

        enum SpecMode {
                specModeAbsolute        = 0,
                specModeScaled          = 1,
                specModeFractional      = 2,
                specModeMM                      = 3
        };

        enum DevViewportSpecMode {
                devViewSpecFraction             = 0,
                devViewSpecMM                   = 1,
                devViewSpecPhysical             = 2
        };

        enum DevViewportIsotropy {
                devViewIsotropyNotForced        = 0,
                devViewIsotropyForced           = 1
        };

        enum DevViewportHorAlign {
                devViewHorAlignLeft             = 0,
                devViewHorAlignCentre   = 1,
                devViewHorAlignRight    = 2
        };

        enum DevViewportVertAlign {
                devViewVertAlignBottom          = 0,
                devViewVertAlignCentre          = 1,
                devViewVertAlignTop                     = 2
        };

        enum TextPrecision      {
                textPrecString          = 0,
                textPrecChar            = 1,
                textPrecStroke          = 2
        };

        enum InteriorStyle {
                interiorStyleHollow             = 0,
                interiorStyleSolid              = 1,
                interiorStylePattern    = 2,
                interiorStyleHatch              = 3,
                interiorStyleEmpty              = 4,
                interiorStyleGeoPatt    = 5,
                interiorStyleInterp             = 6
        };

        enum HatchIndex {
                hatchIndexHorizontal    = 1,
                hatchIndexVertical              = 2,
                hatchIndexPosSlope              = 3,
                hatchIndexNegSlope              = 4,
                hatchIndexHorVertCross  = 5,
                hatchIndexPosNegCross   = 6
        };

        enum InterpolatedInteriorStyle {
                interpolatedInteriorStyleParallel = 1,
                interpolatedInteriorStyleElliptical = 2,
                interpolatedInteriorStyleTriangular = 3
        };

        enum LineType {
                lineTypeNotVisible      = 0,
                lineTypeSolid           = 1,
                lineTypeDash            = 2,
                lineTypeDot                     = 3,
                lineTypeDashDot         = 4,
                lineTypeDashDotDot      = 5,
                lineTypeArrowTail    = 6,       // extended line style - trailing arrow 
                lineTypeCircleHead   = 7,   // ditto - leading circle       
                lineTypeArrowHeadTail = 8,  // ditto - leading and trailing arrow
                lineTypeStyleStich       = 9,   // ditto - stitch
                lineTypeStyleChain       = 10,  // ditto - chain
                lineTypeStyleCenter      = 11,  // ditto - center
                lineTypeStyleHidden      = 12,  // ditto - hidden
                lineTypeStylePhantom = 13,      // ditto - phantom
                lineTypeStyleWavy        = 14,
                lineTypeStyleZBroke      = 15
        };

        enum HatchStyle {
                hatchStyleParallel              = 0,
                hatchStyleCrossHatch    = 1
        };

        enum Transparency {
                transparencyOff = 0,
                transparencyOn  = 1
        };

        enum ClipIndicator {
                clipIndicatorOff        = 0,
                clipIndicatorOn         = 1
        };

        enum ClippingMode {
                clipModeLocus                   = 0,
                clipModeShape                   = 1,
                clipModeLocusThenShape  = 2
        };

        enum ProtectionRegionIndicator {
                protRegionIndUnknown = 0,
                protRegionIndOff        = 1,
                protRegionIndClip       = 2,
                protRegionIndShield = 3
        };

        enum TextPathMode {
                textPathModeOff                 = 0,
                textPathModeNonTang             = 1,
                textPathModeAxisTang    = 2
        };

        enum TextFinalityFlag {
                textFinalFalse          = 0,
                textFinalTrue           = 1
        };

        enum EdgeFlags {
                edgeFlagInvisible = 0,
                edgeFlagVisible = 1,
                edgeFlagClose = 2,
                edgeFlagVisibleClose = 3,
                edgeFlagAttrChanged = 4
        };

        enum CellRepresentationMode {
                cellRepRunLength        = 0,
                cellRepPackedList       = 1
        };

        enum ArcClosureType {
                arcCloseNone    = -1,
                arcClosePie             = 0,
                arcCloseChord   = 1
        };

        enum ContinuityIndicator {
                contIndicatorDisc       = 1,
                contIndicatorCont       = 2
        };

        enum TileCompressionType {
                tileCompressNullBack            = 0,
                tileCompressNullFore            = 1,
                tileCompressT6                          = 2,
                tileCompress1Dimensional        = 3,
                tileCompressT42Dimensional      = 4,
                tileCompressBitmap                      = 5,
                tileCompressRunLength           = 6,
                tileCompressJPEG                        = 7,
                tileCompressLZW                         = 8,
                tileCompressPNG                         = 9
        };

        enum MarkerType {
                markerTypeDot           = 1,
                markerTypePlus          = 2,
                markerTypeAsterisk      = 3,
                markerTypeCircle        = 4,
                markerTypeCross         = 5
        };

        enum TextPath {
                textPathRight           = 0,
                textPathLeft            = 1,
                textPathUp                      = 2,
                textPathDown            = 3
        };

        enum TextAlignmentHorizontal {
                textHorAlignNormal              = 0,
                textHorAlignLeft                = 1,
                textHorAlignCentre              = 2,
                textHorAlignRight               = 3,
                textHorAlignContHor             = 4
        };

        enum TextAlignmentVertical {
                textVertAlignNormal             = 0,
                textVertAlignTop                = 1,
                textVertAlignCap                = 2,
                textVertAlignHalf               = 3,
                textVertAlignBase               = 4,
                textVertAlignBottom             = 5,
                textVertAlignContVert   = 6
        };

        enum EdgeVisibility     {
                edgeVisibleOff  = 0,
                edgeVisibleOn   = 1
        };

        enum AspectSourceFlags {
                asfLineType                     = 0,
                asfLineWidth            = 1,
                asfLineColour           = 2,
                asfMarkerType           = 3,
                asfMarkerSize           = 4,
                asfMarkerColour         = 5,
                asfTextFontIndex        = 6,
                asfTextPrecision        = 7,
                asfCharExpFactor        = 8,
                asfCharSpacing          = 9,
                asfTextColour           = 10,
                asfInteriorStyle        = 11,
                asfFillColour           = 12,
                asfHatchIndex           = 13,
                asfPatternIndex         = 14,
                asfEdgeType                     = 15,
                asfEdgeWidth            = 16,
                asfEdgeColour           = 17
        };

        enum AspectSourceFlagValue {
                asfValueIndividual      = 0,
                asfValueBundled         = 1
        };

        enum LineCapIndicator {
                lineCapUnspecified      = 1,
                lineCapButt                     = 2,
                lineCapRound            = 3,
                lineCapProjSquare       = 4,
                lineCapTriangle         = 5
        };

        enum DashCapIndicator {
                dashCapUnspecified      = 1,
                dashCapButt                     = 2,
                dashCapMatch            = 3
        };

        enum LineJoinIndicator {
                lineJoinUnspecified = 1,
                lineJoinMitre           = 2,
                lineJoinRound           = 3,
                lineJoinBevel           = 4
        };

        enum LineTypeContinuation {
                lineContUnspecified             = 1,
                lineContContinue                = 2,
                lineContRestart                 = 3,
                lineContAdaptiveCont    = 4
        };

        enum TextScoreType {
                textScoreRight          = 1,
                textScoreLeft           = 2,
                textScoreThrough        = 3,
                textScoreKendot         = 4
        };

        enum TextScoreIndicator {
                textScoreIndOff         = 0,
                textScoreIndOn          = 1
        };

        enum RestrTextType {
                restrTextNone           = 0,
                restrTextBasic          = 1,
                restrTextBoxedCap               = 2,
                restrTextBoxedAll               = 3,
                restrTextIsotropicCap   = 4,
                restrTextIsotropicAll = 5,
                restrTextJustified      = 6
        };

        enum SymbolSize {
                symbolSizeHeight        = 0,
                symbolSizeWidth         = 1,
                symbolSizeBoth          = 2
        };

        enum MessageAction {
                messageActionRequiredFalse      = 0,
                messageActionRequiredTrue       = 1
        };

        enum SegmentTransformationApplication {
                segTransAppNo   = 0,
                segTransAppYes  = 1
        };

        enum InheritanceFilter {
                inhFilterLineBundleIndex                        = 0,
                inhFilterLineType                                       = 1,
                inhFilterLineWidth                                      = 2,
                inhFilterLineColour                                     = 3,
                inhFilterLineClippingMode                       = 4,
                inhFilterMarkerBundleIndex                      = 5,
                inhFilterMarkerType                                     = 6,
                inhFilterMarkerSize                                     = 7,
                inhFilterMarkerColour                           = 8,
                inhFilterMarkerClippingMode                     = 9,
                inhFilterTextBundleIndex                        = 10,
                inhFilterTextFontIndex                          = 11,
                inhFilterTextPrecision                          = 12,
                inhFilterCharExpFactor                          = 13,
                inhFilterCharSpacing                            = 14,
                inhFilterTextColour                                     = 15,
                inhFilterCharHeight                                     = 16,
                inhFilterCharOrientation                        = 17,
                inhFilterTextPath                                       = 18,
                inhFilterTextAlignment                          = 19,
                inhFilterFillBundleIndex                        = 20,
                inhFilterInteriorStyle                          = 21,
                inhFilterFillColour                                     = 22,
                inhFilterHatchIndex                                     = 23,
                inhFilterPatternIndex                           = 24,
                inhFilterEdgeBundleIndex                        = 25,
                inhFilterEdgeType                                       = 26,
                inhFilterEdgeWidth                                      = 27,
                inhFilterEdgeColour                                     = 28,
                inhFilterEdgeVisibility                         = 29,
                inhFilterEdgeClippingMode                       = 30,
                inhFilterFillRefPoint                           = 31,
                inhFilterPatternSize                            = 32,
                inhFilterAuxColour                                      = 33,
                inhFilterTransparency                           = 34,
                inhFilterLineAttributes                         = 35,
                inhFilterMarkerAttributes                       = 36,
                inhFilterTextPresAndPlaceAttr           = 37,
                inhFilterTextPlaceAndOrientAttr         = 38,
                inhFilterFillAttributes                         = 39,
                inhFilterEdgeAttributes                         = 40,
                inhFilterPatternAttr                            = 41,
                inhFilterOutputControl                          = 42,
                inhFilterPickIdentifier                         = 43,
                inhFilterAllAttrAndControl                      = 44,
                inhFilterAll                                            = 45,
                inhFilterLineTypeASF                            = 46,
                inhFilterLineWidthASF                           = 47,
                inhFilterLineColorASF                           = 48,
                inhFilterMarkerTypeASF                          = 49,
                inhFilterMarkerSizeASF                          = 50,
                inhFilterMarkerColourASF                        = 51,
                inhFilterTextFontIndexASF                       = 52,
                inhFilterTextPrecisionASF                       = 53,
                inhFilterCharExpFactorASF                       = 54,
                inhFilterCharSpacingASF                         = 55,
                inhFilterTextColourASF                          = 56,
                inhFilterInteriorStyleASF                       = 57,
                inhFilterFillColourASF                          = 58,
                inhFilterHatchIndexASF                          = 59,
                inhFilterPatternIndexASF                        = 60,
                inhFilterEdgeTypeASF                            = 61,
                inhFilterEdgeWidthASF                           = 62,
                inhFilterEdgeColourASF                          = 63,
                inhFilterLineASFs                                       = 64,
                inhFilterMarkerASFs                                     = 65,
                inhFilterTextASFs                                       = 66,
                inhFilterFillASFs                                       = 67,
                inhFilterEdgeASFs                                       = 68,
                inhFilterAllASFs                                        = 69,
                inhFilterMitreLimit                                     = 70,
                inhFilterLineCap                                        = 71,
                inhFilterLineJoin                                       = 72,
                inhFilterLineTypeCont                           = 73,
                inhFilterLineTypeInitOffset                     = 74,
                inhFilterTextScoreType                          = 75,
                inhFilterRestrTextType                          = 76,
                inhFilterInterpolatedInterior           = 77,
                inhFilterEdgeCap                                        = 78,
                inhFilterEdgeJoin                                       = 79,
                inhFilterEdgeTypeCont                           = 80,
                inhFilterEdgeTypeInitOffset                     = 81,
                inhFilterSymbolLibraryIndex                     = 82,
                inhFilterSymbolColour                           = 83,
                inhFilterSymbolSize                                     = 84,
                inhFilterSymbolOrientation                      = 85,
                inhFilterSymbolAttr                                     = 86
        };

        enum InheritanceFilterSetting {
                inhFilterSettingStateList               = 0,
                inhFilterSettingSegment                 = 1
        };

        enum ClipInheritance {
                clipInhStateList                = 0,
                clipInhIntersection             = 1
        };

        enum SegmentHighlighting {
                segHighlightNormal              = 0,
                segHighlightHigh                = 1
        };

        enum PolygonType {
                polygonTypeNotAPolygon  = 0,
                polygonTypeComplex              = 1,
                polygonTypeConvex               = 2,
                polygonTypeNonconvex    = 3
        };


// End Enums

        CCgmBaseObj(CCgmObjects* pOwner, enum Shape nShape);
        
        virtual ~CCgmBaseObj();

        void CopyBase(CCgmBaseObj* p);

// Operations

        virtual PolyPolylineData* ConvertToPoints(double step = 0); 
        virtual CCgmBaseObj* Clone();
        virtual void Draw(CDrawBase* pDB);
        virtual void Restore(CCgmBaseObj* pObj);
        virtual bool IsFill();
        virtual bool IsClosed();
        virtual bool IsText();
        DRect GetBounds(bool locus = false);
        virtual long GetHandleCount();
        virtual DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        virtual void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        virtual bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        virtual void ReCalcBounds();
        virtual void TransformBy(CMatrix* pXForm);
        virtual void ConvertColors(int monoEnhance, int colorConvert);

        const CCgmBaseObj& operator=( const CCgmBaseObj& a );

// Implementation
public:
        DRect BoundsFromPts(DPoint *pts, long nPts);
        void DrawPath(CDrawBase *pDB, Path* path, bool fill);
        virtual long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression = BwRasterCompressionNone, 
                int colorCompression = ColorRasterCompressionNone, bool unicode = false, bool bRGBa = false, int vdcPrecision = 0);
        virtual bool IsRaster();        
        void RotatePts(DPoint center, double angle, DPoint *points, long nPoints);
        DRect GetClipRect();

        DRect m_bounds;
        CColor  m_auxColor;
        CColor  m_fillColor;
        CColor  m_lineColor;
        unsigned char m_transparency;
        unsigned char m_lineCap;
        unsigned char m_lineDashCap;
        unsigned char m_lineJoin;
        unsigned char m_lineWidthSpecMode;
        unsigned char m_fillInteriorStyle;
        unsigned char m_interiorStyleSpecMode;
        char m_lineTypeCont;
        char m_polygonType;
        short m_lineType;
        short m_ataLayerNumber;
        float m_mitreLimit;
        float   m_lineTypeInitOff;
        long m_hatchPatternIndex;
        CInterpInteriorParams* m_interpInterior;
        ClippingPath*   m_clippingPath;
        ClipRectangle*  m_clipRectangle;
        enum Shape      m_nShape;
        CCgmObjects* m_pOwner;
        CPatternTables::PatternBundle* m_patternBundle;

        double m_lineWidth;

        DPoint m_patternHeight;   // valid when
        DPoint m_patternWidth;    // pattern fill
    DPoint m_patternRefPoint; // with pattern

        // implementation data
protected:
#ifndef CGMOBJECTS_NO_SAVE
        long SaveLineAttr(CGMLIB2_HANDLE hCGMLIB2);
        long SaveFillAttr(CGMLIB2_HANDLE hCGMLIB2);
        long SaveClipping(CGMLIB2_HANDLE hCGMLIB2);
#endif
        DRect IntersectClip(DRect rect);

public:
        static DPoint* beziertoPts(DPoint& p0, DPoint& p1, DPoint& p2, DPoint& p3, double step, long* nPts);
        double DefaultStep();
        static PolyPolylineData* PolyBezierToPoints(long type, DPoint* pPts, long count, double step,
                DRect* pRect = NULL, DRect* pBounds = NULL);
        void dbgShapeInfo(int i, std::wstring *pID);
        DPoint *arcToBeziers(DPoint center, double radius, double a1, double a2, long *cnt);
        void arcSmallToBeziers(double radius, double a1, double a2, DPoint *polyBez);
        char polygonType(DPoint *pts, long count);
        wchar_t map2unichar(wchar_t wcin);
};


class CCgmPoly;
class CCgmRect : public CCgmBaseObj
{
protected:
        CCgmRect() {};

public:
        CCgmRect(CCgmObjects* pParent, enum Shape nShape = rectangle);
        virtual ~CCgmRect();

// Implementation
public:
        void ReCalcBounds();
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        bool IsFill();
        virtual CCgmBaseObj* Clone();
        void Draw(CDrawBase *pDB);
        PolyPolylineData* ConvertToPoints(double step = 1);
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void Restore(CCgmBaseObj* pObj) { *this = *((CCgmRect*)pObj); };
        void SetPts(DPoint ll, DPoint ur);
        void TransformBy(CMatrix* pXForm);

private:
        DPoint m_Pts[2];        

        DPoint m_altPts[2];

public:
        DPoint Pt(int i) { DPoint d = m_Pts[i]; return d; };
    DPoint altPt(int i) { DPoint d = m_altPts[i]; return d; };

        const CCgmRect& operator=( const CCgmRect& a );

protected:
};


class CCgmText : public CCgmBaseObj
{
protected:
        CCgmText() {};

public:
        CCgmText(CCgmObjects* pParent, enum Shape nShape);
        virtual ~CCgmText();

// Implementation
public:
        void AddPath(Path *path);
        void CalcTotalExtent(CCgmText *pCgmText, CTextExtent& total_te, double rotation = 0);
        void CalcExtent();
        virtual CCgmBaseObj* Clone();
        virtual PolyPolylineData* ConvertToPoints(double step = 1);
        virtual void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int* pType, double handleOffset = 0);
        long GetHandleCount() { return 8; };
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        CCgmText* HitTestFragment(DPoint point);
        virtual bool IsText();
        virtual void ReCalcBounds();
        virtual void Restore(CCgmBaseObj* pObj) { *this = *((CCgmText*)pObj);};
#ifndef CGMOBJECTS_NO_SAVE
        virtual long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        DPoint StartPos(DPoint* bounds);
        virtual void TransformBy(CMatrix* pXForm);
        const CCgmText& operator=( const CCgmText& a );


        double  m_characterExpFactor;   

        double  m_characterHeight;      
        struct {
                DPoint up;
                DPoint base;
        } m_characterOrientation;       

        double  m_characterSpacing;     

        double  m_restrictedTextWidth;  

        double  m_restrictedTextHeight; 

        std::wstring m_text;    

        CTextExtent m_textExtent;       

    struct {
                float hor, ver;
        } m_textAlignmentCont;

        CCgmText* m_pAppendParent;      

        Path *m_path;   

        long    m_textFontIndex;        

        struct {
                unsigned char hor, ver;
        } m_textAlignment;      

        unsigned char m_final;

        unsigned char   m_textPath;     

        unsigned char   m_textPrecision;        

        unsigned char m_restrictedTextType;     

        unsigned char m_generalizedTextPathMode;

        unsigned char m_characterSetIndex;      

        unsigned char m_altCharacterSetIndex;   

protected:
#ifndef CGMOBJECTS_NO_SAVE
        long  SaveFirstText(CGMLIB2_HANDLE hCGMLIB2, CCgmText* pFirst, bool unicode);
#endif

};


class CCgmPoly : public CCgmBaseObj
{
protected:
        CCgmPoly() {};

public:
        CCgmPoly(CCgmObjects* pParent, enum Shape nShape = polyline);
        virtual ~CCgmPoly();

// Operations
        const CCgmPoly& operator=( const CCgmPoly& a );

// Implementation
public:
        DPoint* m_pts;
        long m_nPts;
        unsigned char* m_edges;
        long m_contIndicator;
        long GetNumberPolygons();

        void AddPoint(DPoint point, long index);
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 0);
        void DeletePoint(long index);
        virtual void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        long GetHandleCount();
        bool IsFill();
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void ReCalcBounds();
        void Restore(CCgmBaseObj* pObj);
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        void TransformBy(CMatrix* pXForm);

protected:
};
class CCgmTileArray;

class CCgmCellArray : public CCgmBaseObj
{
protected:
        CCgmCellArray() {};

public:
        virtual ~CCgmCellArray();
        CCgmCellArray(CCgmObjects* pParent, enum Shape nShape);

// Implementation
public:
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 1);
        CCgmTileArray* ConvertTo1BPPTileArray();
        void ConvertColors(int monoEnhance, int colorConvert);
        void Draw(CDrawBase *pDB);
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        bool IsRaster();
        bool IsSkewed();
        void ReCalcBounds();
        void Restore(CCgmBaseObj* pObj);
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision = false);
#endif
        void TransformBy(CMatrix* pXForm);
        int     LengthCellColors();
        int GetBytesPerLine();
        bool Compress(unsigned char* pRaw);
        unsigned char* UnCompress();

        const CCgmCellArray& operator=( const CCgmCellArray& a );


        unsigned char* m_cellColors;
        int m_compressedLength;
        long    m_bytesPerLine;
        struct {
                long nx, ny;
        } m_nCells;
        DPoint  m_Pts[3];
        long    m_precision;
        bool m_transpCellColorFlag;
        CColor m_transpCellColor;
        unsigned char m_monoChromatic;
};


class CCgmTileArray : public CCgmBaseObj
{
protected:
        CCgmTileArray() {};

public:

        CCgmTileArray(CCgmObjects* pParent, enum Shape nShape);
        virtual ~CCgmTileArray();
        const CCgmTileArray& operator=( const CCgmTileArray& a );

        virtual CCgmBaseObj* Clone();
        void ConvertColors(int monoEnhance, int colorConvert);
        void Draw(CDrawBase *pDB);
        int GetBytesPerLine(int nTile);
        DPoint* GetPQRPts();
        void GetXForm(double m[2][2]);
        bool IsRaster();
        void ReCalcBounds();
        void Restore(CCgmBaseObj* pObj);
        void TransformBy(CMatrix* pXForm);
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision = false);
#endif

        bool m_transpCellColorFlag;
        CColor m_transpCellColor;


        typedef struct {
                unsigned char* colors;
                long    nCellsPerLine;
                long    nLines;
                TileCompressionType     compressionType;
                long    precision;
                int             compressedLength;
                CColor  biFgc;
                CColor  biBgc;
                long    biTonal;
        } tiles;
        tiles* m_tiles;

        struct {
                long    path;
                long    line;
        } m_nTiles;

        struct {
                long    path;
                long    line;
        } m_nCells;

        struct {
                double path;
                double line;
        } m_cellSize;

        struct {
                long path; 
                long line; 
        } m_imageOffset;

        struct {
                long    path;
                long    line;
        } m_imageCells;

        long    m_cellPathDir;
        long    m_lineProgressionDir;
        DPoint  m_Pt;

        // set tile array paramters
        int SetTileArray(int cellPathDir, int lineProgressionDir, int pathCellsPerTile, int lineCellsPerTile, 
                        double pathCellSize, double lineCellSize, int pathCellsImage, int lineCellsImage, 
                        int pathNumberOfTiles, int lineNumberOfTiles);

        // set single tile cell data
        int SetTileCells(int pathTileNumber, int lineTileNumber, unsigned char* pData, int dataSize);

protected:
        CCgmCellArray* m_pCellDraw;
};


class CCgmFigure : public CCgmBaseObj
{
protected:
        CCgmFigure() {};

public:
        CCgmFigure(CCgmObjects* pParent, enum Shape nShape);
        virtual ~CCgmFigure();

// Operations
        void AddPath(CFigure::figureData *figure);

// Implementation
public:
        CFigure::figureData *m_figureData;
        long    m_nPaths;

#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        bool IsFill();
        virtual CCgmBaseObj* Clone();
        virtual PolyPolylineData* ConvertToPoints(double step = 0);
        virtual PolyPolylineData* ConvertToPoints(double step, DRect* pRect);
        void Draw(CDrawBase *pDB);
        void Restore(CCgmBaseObj* pObj);
        void TransformBy(CMatrix* pXForm);
        const CCgmFigure& operator=( const CCgmFigure& a );

protected:
};


class CCgmTrace : public CCgmBaseObj
{
protected:
        CCgmTrace() { };

public:
        CCgmTrace(CCgmObjects* pParent, enum Shape nShape);
        virtual ~CCgmTrace();

// Implementation
public:
        virtual CCgmBaseObj* Clone();
        void Draw(CDrawBase *pDB);
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        void ReCalcBounds();
        void Restore(CCgmBaseObj* pObj);
        void TransformBy(CMatrix* pXForm);

        CCgmTrace *m_pPrevTrace;
        CCgmTrace *m_pNextTrace;

        long    m_group_identifier;
        DPoint m_start;
        float   m_sample_normalization_extent;
        float   m[2][2];
        struct  {
                long n;
                float *list;
        } m_samples;
        struct {
                long n, type;
                unsigned long *list;
        } m_VA_fill_colors;
        struct {
                long n, type;
                unsigned long *list;
        } m_background_fill_colors;

        char    m_positive_lobe_display_priority,
                m_negative_lobe_display_priority,
                        m_positive_lobe_pixel_drawing_mode,
                        m_negative_lobe_pixel_drawing_mode;
        float   m_data_complete_coordinate;
        long    m_data_complete_flag;
        long    m_rendering_direction;

        // Trace Attributes
        FPoint  m_orientation_baseline,
                        m_orientation_amplitude;
        float   m_baseline_scale,
                        m_amplitude_scale;
        char    m_display_mode_wiggle,
                        m_display_mode_positive_va_fill,
                        m_display_mode_negative_va_fill,
                        m_display_mode_background_fill;
        long    m_maximum_number_of_samples;
        struct {
                float pos, neg;
        } m_wiggle_amplitude_limit;
        struct {
                float min, max;
        } m_positive_va_fill_boundaries;
        struct {
                float min, max;
        } m_negative_va_fill_boundaries;
        char    m_rectified_va_fill_mode;
        char    m_va_fill_style;
        struct {
                CColor pos, neg;
        } m_va_fill_constant_colour;
        struct {
                long pos, neg;
        } m_va_fill_constant_pattern;
        char    m_va_fill_alignment,
                        m_va_fill_var_colour_selection;
        struct  {
                float factor, bias;
                long min, max;
        } m_va_fill_var_linear;
        struct {
                float pos, neg;
        } m_background_fill_boundaries;
        char    m_background_colour_interpolation_mode;
        char    m_background_fill_style;
        struct {
                char    indicator;
                unsigned long index;
                CColor colour;
        } m_background_null_colour;
        CColor  m_background_fill_constant_colour;
        char    m_background_fill_alignment;
        char    m_background_fill_var_colour_selection;
        struct {
                float factor, bias;
                long min, max;
        } m_background_fill_var_linear;

        CColorReps *m_pColorReps;

        const CCgmTrace& operator=( const CCgmTrace& a );

private:
};


class CCgmCircle : public CCgmBaseObj
{
protected:
        CCgmCircle() {};

public:
        CCgmCircle(CCgmObjects* pParent, enum Shape nShape = circle);
        virtual ~CCgmCircle();

// Implementation
public:
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        bool IsFill();
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 0);
        PolyPolylineData* ConvertToPoints(double step, bool bBezierPts);
        void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        long GetHandleCount();
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        void Restore(CCgmBaseObj* pObj) { *this = *((CCgmCircle*)pObj); };
        void TransformBy(CMatrix* pXForm);
        DPoint ArcCenter();
        DPoint ArcStartPt();
        DPoint ArcEndPt();
        DPoint ArcMidPt();
        bool IsCoLinear();
        const CCgmCircle& operator=( const CCgmCircle& a );

        DPoint m_centerOrInter;
        DPoint m_start; 
        DPoint m_end;
        double m_radius;
        char m_closure;

protected:
        bool IsPerpendicular(DPoint &pt1, DPoint &pt2, DPoint &pt3);
        DPoint Arc3PtCalcCenter(DPoint &pt1, DPoint &pt2, DPoint &pt3);
};


class CCgmEllipse : public CCgmBaseObj
{
protected:
        CCgmEllipse() {};

public:
        CCgmEllipse(CCgmObjects* pParent, enum Shape nShape);
        CCgmEllipse(CCgmObjects* pParent, CCgmCircle* pCircle);
        virtual ~CCgmEllipse();

#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        bool IsFill();
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 0);
        PolyPolylineData* ConvertToPoints(double step, bool bBezierPts);
        CCgmPoly* ConvertToPolyBezier();
        void MakeBezierFromArc(double CenterX, double CenterY, double RadiusX,
                double RadiusY, double StartAngle, double SweepRange, bool UseMoveTo, CCgmPoly *pPoly);
        void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        long GetHandleCount();
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        void Restore(CCgmBaseObj* pObj) { *this = *((CCgmEllipse*)pObj); };
        void TransformBy(CMatrix* pXForm);
        DPoint ArcStartPt();
        DPoint ArcEndPt();
        DPoint ArcMidPt();
        const CCgmEllipse& operator=( const CCgmEllipse& a );

        DPoint m_center;
        DPoint m_cdp1;
        DPoint m_cdp2;
        DPoint m_start;
        DPoint m_end;
        char   m_closure;

private:
        DPoint SinglePoint(DPoint vector);

};


class CCgmHyperbolicArc : public CCgmBaseObj
{
protected:
        CCgmHyperbolicArc() {};

public:
        CCgmHyperbolicArc(CCgmObjects* pParent, enum Shape nShape);

        virtual ~CCgmHyperbolicArc();

// Implementation
public:
        DPoint m_center;                
        DPoint m_tv_radius_end; 
        DPoint m_cj_radius_end; 
        DPoint m_start;                 
        DPoint m_end;                   

#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 0);
        void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        long GetHandleCount();
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        void Restore(CCgmBaseObj* pObj) { *this = *((CCgmHyperbolicArc*)pObj); };
        void TransformBy(CMatrix* pXForm);
        const CCgmHyperbolicArc& operator=( const CCgmHyperbolicArc& a );

private:
        DPoint SinglePoint(DPoint vector);

};


class CCgmParabolicArc : public CCgmBaseObj
{
protected:
        CCgmParabolicArc() {};

public:
        CCgmParabolicArc(CCgmObjects* pParent, enum Shape nShape);

        virtual ~CCgmParabolicArc();

// Implementation
public:
        DPoint m_tg_intersection_pt;    
        DPoint m_start_pt;              
        DPoint m_end_pt;                

#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 0);
        void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        long GetHandleCount();
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        void Restore(CCgmBaseObj* pObj) { *this = *((CCgmParabolicArc*)pObj); };
        void TransformBy(CMatrix* pXForm);
        const CCgmParabolicArc& operator=( const CCgmParabolicArc& a );

private:
        DPoint SinglePoint(DPoint vector);

};


class CCgmNurb : public CCgmBaseObj
{
protected:
        CCgmNurb() {};

public:
        CCgmNurb(CCgmObjects* pParent, enum Shape nShape);
        virtual ~CCgmNurb();

        long            m_order;                
        long            m_nControlPts;  
        DPoint* m_points;                       
        double* m_knots;                        
        double  m_startValue;           
        double  m_endValue;                     
        long    m_nWeights;                     
        double*  m_weights;                     

// Implementation
public:
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        bool IsFill();
        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step = 0);
        void Draw(CDrawBase *pDB);
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        long GetHandleCount();
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void Restore(CCgmBaseObj* pObj);
        void TransformBy(CMatrix* pXForm);

        const CCgmNurb& operator=( const CCgmNurb& a );

protected:
};


class CCgmArrow : public CCgmPoly
{
protected:
        CCgmArrow() {};

public:
        enum ArrowheadType {
                arrowheadNone = 0,
                arrowheadStick  = 1,
                arrowheadFilled = 2,
                arrowheadCircle = 3,
                arrowheadDiamond = 4
        };

        CCgmArrow(CCgmObjects* pParent, enum Shape nShape = arrow);

        virtual CCgmBaseObj* Clone();
        void Draw(CDrawBase *pDB);
        void ReCalcBounds();
        void Restore(CCgmBaseObj* pObj);
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        const CCgmArrow& operator=( const CCgmArrow& a );

        ArrowheadType m_beginType;
        ArrowheadType m_endType;

        float m_beginArrowheadWidth;
        float m_beginArrowheadHeight;

        float m_endArrowheadWidth;
        float m_endArrowheadHeight;

        char    m_halo;
        float  m_haloSize;

protected:
        CCgmBaseObj* MakeArrowheadObj(ArrowheadType arrowType, float arrowheadWidth, float arrowheadHeight, DPoint start, DPoint end, DPoint* pOffset);
};


class CCgmCallout : public CCgmText
{
protected:
        CCgmCallout() {};

public:
        enum OutlineType {
                noOutline  = 0,
                circle = 1,
                rectangle = 2
        };
        enum ConnectType {
                none  = 0,                      
                line = 1,                       
                dogleg = 2                      
        };

        CCgmCallout(CCgmObjects* pParent, enum Shape nShape = callout);

        virtual CCgmBaseObj* Clone();
        PolyPolylineData* ConvertToPoints(double step);
        void Draw(CDrawBase *pDB);
        long GetHandleCount();
        DPoint GetHandle(long nHandle, int*pType,double handleOffset = 0);
        bool HitTest(DPoint point, double margin, int* pSegIndex = NULL);
        void MoveEditHandle(long nHandle, bool bAspect, DPoint point);
        void ReCalcBounds();
        void Restore(CCgmBaseObj* pObj);
#ifndef CGMOBJECTS_NO_SAVE
        long Save(CGMLIB2_HANDLE hCGMLIB2, int bwCompression, int colorCompression, bool unicode, bool bRGBa, int vdcPrecision);
#endif
        void TransformBy(CMatrix* pXForm);


        OutlineType m_outline;          
        ConnectType m_connect;          
        DPoint m_anchor;                        
        DPoint m_dogleg;                        
        DPoint m_center;                        
        CCgmArrow::ArrowheadType m_arrowheadType;       
        float m_arrowheadWidth;         
        float m_arrowheadHeight;        
        float   m_gap;                          
        char    m_halo;                         
        float  m_haloSize;                      

// Operations
        const CCgmCallout& operator=( const CCgmCallout& a );

protected:
        CCgmBaseObj* MakeOutlineObj();
        CCgmBaseObj* MakeOutlineHaloObj();
        CCgmArrow* MakeConnectLineObj();
        DPoint ConnectPt();
        DPoint* TextPoints(int baseCap = 0);
};

        
class CCgmCopySegment : public CCgmBaseObj
{
protected:
        CCgmCopySegment() {};

public:
        CCgmCopySegment(CCgmObjects* pParent, enum Shape nShape = copySegment);
        virtual ~CCgmCopySegment();

        // Implementation
public:
        DRect GetBounds(bool locus = false);
        void Draw(CDrawBase *pDB);

        long m_name;
        CMatrix m_transform;
        //              otherwise it is not applied
        long m_transformationApplication;
};

class CCgmGdp : public CCgmBaseObj
{
protected:
        CCgmGdp() 
        {       
                m_pts = NULL;
                m_id = m_nPts = 0;
        };

public:
        CCgmGdp(CCgmObjects* pParent, enum Shape nShape = gdp);
        virtual ~CCgmGdp()
        {       
                if (m_pts)
                        delete[] m_pts;
        };

        // Implementation
public:
        int m_id;
        DPoint *m_pts;
        long m_nPts;
};

class CCgmPolySymbol : public CCgmBaseObj
{
protected:
        CCgmPolySymbol() {};

public:
        CCgmPolySymbol(CCgmObjects* pParent, enum Shape nShape = polySymbol);
        virtual ~CCgmPolySymbol();

// Operations
        const CCgmPolySymbol& operator=( const CCgmPoly& a );

// Implementation
public:
        DPoint* m_pts;
        long m_nPts;

        long m_libraryIndex;
        DPoint  m_orientation[2];  
        long    m_sizeIndicator; 
        double  m_size[2];

        void AddPoint(DPoint point, long index);
        virtual CCgmBaseObj* Clone();
        void DeletePoint(long index);
        void Draw(CDrawBase *pDB);
};

class CCgmMessage : public CCgmBaseObj
{
protected:
        CCgmMessage() {};

public:
        CCgmMessage(CCgmObjects* pParent, enum Shape nShape = message);
        virtual ~CCgmMessage() {};

        // Implementation
public:

        int m_action;
        std::wstring m_text;
};

};  // end namespace Larson

#endif // __DRAWOBJ_H__