DrawBase.h

// DrawBase.h: interface for the CDrawBase class.
//

#if !defined(AFX_DRAWBASE_H__CA9A4F64_A587_44FB_A36B_8C173B304AA7__INCLUDED_)
#define AFX_DRAWBASE_H__CA9A4F64_A587_44FB_A36B_8C173B304AA7__INCLUDED_

#pragma once

#include "CgmObjects.h"
#include "CgmObj.h"
#include "Geometry.h"
#include "Utility/wstring.h"

namespace Larson
{
        class CDrawBase
        {
        typedef struct matStr { double m[3][3]; } matStr;
        typedef struct mptStr { double x, y, z; } mptStr;

        typedef struct edgeInfo { double y_max, y_min, Mi, B, x1, y1, x2, y2; } edgeInfo;

        typedef struct emFillStruct {
                long hatch_interval;         /* hatch scan line interval */
                double hatch_thickness,         /* hatch line thickness*/
                        hatch_blanks,                   /* number of blank scans between hatch lines */
                                                                        /* NOTE: thickness + blanks = interval */
                        hatch_do;                
                int     custom_index;
                double *f_mat_rot;
                double *b_mat_rot;
                long rx, ry, sx, sy, px, py;
                double *cpts;
                int cptsNum;
                long cur_pts;
                CColor *pa;
                CColor *fill_color;

                long p1x, p1y, p2x, p2y;
                double A[3], B[3], C[3], D0, dblpx, dblpy;
                long r[3], g[3], b[3];
                long sxp1;
                double ea, eb, ec, ed;

                DPoint *points;

                double lx1, ly1, lx2, ly2, ly_max;

                edgeInfo *edge_info;
                long *edge_flags;

                                                        // 7aug2013- use long for worst case even though CgmObjs use short lineType
                long *line_type;        // custom hatch definitions can have multiple line types

                DRect orgRect;

        } emFillStruct;

        public:
        typedef struct { int x, y; } IPoint;
        typedef struct DrawInfo {
                DRect window, viewport;
                DRect clientRect;
                double rotation;
                int originFlag;
                double resolution; // resolution of output device
        } DrawInfo;

                CDrawBase();
                virtual ~CDrawBase();

                enum OriginFlag {
                        lowerLeft               = 0,
                        upperLeft               = 1
                };

                enum ProcessFlag {
                        firstCgmObjects = 0,
                        middleCgmObjects = 1,
                        lastCgmObjects = 2,
                        onlyCgmObjects = 3,
                        preDrawSetup = 4,
                        postDrawCleanup = 5
                };

                virtual long setLineAttr(CCgmBaseObj*) = 0;

                virtual long setFillAttr(CCgmBaseObj*) = 0;

                virtual bool applyClipping(CCgmBaseObj*, DRect*) = 0;

                virtual void drawDCline(CCgmBaseObj *pCgmBaseObj, DPoint *pPts, long count, bool close) = 0;

                virtual void drawDCfill(CCgmBaseObj *pCgmBaseObj, DPoint *pPts, long count) = 0;

// draw a char from freetype outline in device coordinates
                virtual void drawDCGlyph(CCgmBaseObj *pCgmBaseObj, DPoint &charPos, void* glyph, bool fillChar, double dScaleUp);

                virtual void drawCellArray(CCgmCellArray *pCCgmCellArray);

                virtual void open() = 0;

                virtual void close() = 0;

                virtual void setDisplay(void* pDisplay, void* pOther = 0) = 0;

                virtual void setTransform(DRect *window, DRect *viewport, DRect *clientRect, double rotation = 0.0, int originFlag = 0);

                virtual void setHardclip(DRect *hardclip);

                virtual void clear() = 0;

                virtual void flush() = 0;
                virtual void drawDCdots(CCgmBaseObj *pCgmBaseObj, DPoint *pPts, long count) = 0;
                virtual void unApplyClipping(CCgmBaseObj*) = 0;
                virtual void eraseDCarea(DRect *area) = 0;

                virtual void begAps(CAppStruct *) { return; };
                virtual void endAps(CAppStruct *) { return; };

                virtual DPoint *VdcToDPts(DPoint *pPts, long *nPts, bool removeDups = false, bool bNint = false);
                inline DPoint VdcToDPt(DPoint dPt, bool bNint = false)
                {
                        DPoint VdcPt;
                        if (m_pXForm)
                                VdcPt = m_pXForm->transformPt(dPt);
                        else
                                VdcPt = dPt;

                        DPoint DPt;
                        DPt.x = ((VdcPt.x * m_vdcToCcMatrix[0][0]) + (VdcPt.y * m_vdcToCcMatrix[0][1]) + m_vdcToCcMatrix[0][2]);
                        DPt.y = ((VdcPt.x * m_vdcToCcMatrix[1][0]) + (VdcPt.y * m_vdcToCcMatrix[1][1]) + m_vdcToCcMatrix[1][2]);

                        if(bNint)
                        {
                                DPt.x = NINT(DPt.x);
                                DPt.y = NINT(DPt.y);
                        }

                        return DPt;
                }
                inline DPoint VdcToDVec(DPoint dVec, bool bNint = false)
                {
                        DPoint vdcVec;
                        if (m_pXForm)
                                vdcVec = m_pXForm->transformVec(dVec);
                        else
                                vdcVec = dVec;
                        
                        DPoint vec;
                        vec.x = ((vdcVec.x * m_vdcToCcMatrix[0][0]) + (vdcVec.y * m_vdcToCcMatrix[0][1]));
                        vec.y = ((vdcVec.x * m_vdcToCcMatrix[1][0]) + (vdcVec.y * m_vdcToCcMatrix[1][1]));

                        if(bNint)
                        {
                                vec.x = NINT(vec.x);
                                vec.y = NINT(vec.y);
                        }

                        return vec;
                }

                virtual LPoint *VdcToLPts(DPoint *pPts, long *nPts, bool removeDups = false);
                inline LPoint VdcToLPt(DPoint dPt)
                {
                        DPoint VdcPt;
                        if (m_pXForm)
                                VdcPt = m_pXForm->transformPt(dPt);
                        else
                                VdcPt = dPt;

                        LPoint LPt;

                        LPt.x = NINT((double)((VdcPt.x * m_vdcToCcMatrix[0][0]) + (VdcPt.y * m_vdcToCcMatrix[0][1]) +
                                                m_vdcToCcMatrix[0][2]) );
                        LPt.y = NINT((double)((VdcPt.x * m_vdcToCcMatrix[1][0]) + (VdcPt.y * m_vdcToCcMatrix[1][1]) +
                                                m_vdcToCcMatrix[1][2]) );

                        return LPt;
                }
                inline LPoint VdcToLVec(DPoint dVec)
                {
                        DPoint vdcVec;
                        if (m_pXForm)
                                vdcVec = m_pXForm->transformVec(dVec);
                        else
                                vdcVec = dVec;

                        LPoint lVec;

                        lVec.x = NINT((double)((vdcVec.x * m_vdcToCcMatrix[0][0]) + (vdcVec.y * m_vdcToCcMatrix[0][1])) );
                        lVec.y = NINT((double)((vdcVec.x * m_vdcToCcMatrix[1][0]) + (vdcVec.y * m_vdcToCcMatrix[1][1])) );

                        return lVec;
                }

                virtual Larson::CDrawBase::IPoint *VdcToIPts(DPoint *pPts, int *nPts, bool removeDups = false);
                inline Larson::CDrawBase::IPoint VdcToIPt(DPoint dPt)
                {
                        DPoint VdcPt;
                        if (m_pXForm)
                                VdcPt = m_pXForm->transformPt(dPt);
                        else
                                VdcPt = dPt;

                        IPoint IPt;

                        IPt.x = ININT((double)((VdcPt.x * m_vdcToCcMatrix[0][0]) + (VdcPt.y * m_vdcToCcMatrix[0][1]) +
                                                m_vdcToCcMatrix[0][2]) );
                        IPt.y = ININT((double)((VdcPt.x * m_vdcToCcMatrix[1][0]) + (VdcPt.y * m_vdcToCcMatrix[1][1]) +
                                                m_vdcToCcMatrix[1][2]) );

                        return IPt;
                }
                inline IPoint VdcToIVec(DPoint dVec)
                {
                        DPoint vdcVec;
                        if (m_pXForm)
                                vdcVec = m_pXForm->transformVec(dVec);
                        else
                                vdcVec = dVec;

                        IPoint IVec;

                        IVec.x = ININT((double)((vdcVec.x * m_vdcToCcMatrix[0][0]) + (vdcVec.y * m_vdcToCcMatrix[0][1])) );
                        IVec.y = ININT((double)((vdcVec.x * m_vdcToCcMatrix[1][0]) + (vdcVec.y * m_vdcToCcMatrix[1][1])) );

                        return IVec;
                }

                virtual DPoint IPtToVdcPt(IPoint lPt);
                virtual DPoint LPtToVdcPt(LPoint lPt);
                virtual DPoint DPtToVdcPt(DPoint dcPt);
                virtual DPoint DVecToVdcVec(DPoint dcVec);

                virtual long WeightToCc(double scale, int specMode, double scaleFactor = 1.0);
                virtual double WeightToD(double scale, int specMode, double scaleFactor = 1.0);

                virtual double OneDcIsVdc();

                virtual void PreProcess(CCgmObjects*, enum ProcessFlag ) { return; };
                virtual void PostProcess(CCgmObjects*, enum ProcessFlag ) { return; };

                void CalcTextExpFactors(CCgmText *pCgmText, CCgmText *pTextOwner, CTextExtent *pTotalExtent,
                        double *pHFac, double *pEFac);

                virtual void drawRect(CCgmRect *pCgmRect);
                virtual void drawText(CCgmText *pCgmText);
                virtual void drawPoly(CCgmPoly *pCgmPoly);
                virtual void drawTrace(CCgmTrace *pCgmTrace);
                virtual void drawTraceVariableAreaPos(CCgmTrace *pCgmTrace, float m[2][3]);
                virtual void drawTraceVariableAreaNeg(CCgmTrace *pCgmTrace, float m[2][3]);
                virtual void drawTraceBackground(CCgmTrace *pCgmTrace, float m[2][3], long flag);
                virtual void drawEllipse(CCgmEllipse *pCgmEllipse);
                virtual void drawCircle(CCgmCircle *pCgmCircle);
                virtual void drawHyperbolicArc(CCgmHyperbolicArc *pCgmHyperbolicArc);
                virtual void drawParabolicArc(CCgmParabolicArc *pCgmParabolicArc);
                virtual void drawNurb(CCgmNurb *pCgmNurb);
                virtual void drawTileArray(CCgmTileArray *pCgmTileArray);
                virtual void drawFigure(CCgmFigure *pCgmFigure);
                virtual void drawPath(CCgmBaseObj *pCgmBaseObj, Path *pPath, bool fill);

                virtual DPoint drawDCArrowHead(CCgmBaseObj*, DPoint* p1, DPoint* p2, double width);
                void emulDCline(CCgmBaseObj *pCgmBaseObj, DPoint *pDa, long cnt, bool close);
                long emulDCfill(CCgmBaseObj *pCgmBaseObj, DPoint *pDa, long cnt, bool bCustomHatch = false);

                void drawDCdegen(CCgmBaseObj *pCgmBaseObj, DPoint *pts, bool bOnePt = true);

                void traceBackgroundRun(CCgmTrace *pCgmTrace, DPoint P, DPoint Q, DPoint R);

                void traceBackgroundInterpolated(CCgmTrace *pCgmTrace, DPoint P, DPoint Q, DPoint R, float m[2][3], bool group);

                long traceBackgroundInterpolatedLeft2Center(CCgmTrace *pCgmTrace, DPoint P, DPoint Q, DPoint R,
                        long left, unsigned long *left_list, long oi, long mid,
                        long cen, unsigned long *cen_list, long type, long first, long last, long final, long nC, long nCl, long nR,
                        unsigned long *CA,
                        long *ci, long mc, long cM, long *gCol, long nflg, long nrep, long csm, long *last_cell);

                long traceBackgroundInterpolatedCenter2Right(CCgmTrace *pCgmTrace, DPoint P, DPoint Q, DPoint R,
                        long cen, unsigned long *cen_list, long type, long first, long last,
                        long final, long mid, long right, unsigned long *right_list, long oi, long nC, long nCr, long nR,
                        unsigned long *CA,
                        long *ci, long mc, long cM, long *gCol, long nflg, long nrep, long csm, long *last_cell);

                void traceBackgroundInterpolatedFlushCells(CCgmTrace *pCgmTrace, long csm, long *cell_count,
                        DPoint P, DPoint Q, DPoint R, long nC, long nR, long *last_cell, unsigned long *CA, long type);

                void setLineWidthControl(double minimum, double maximum, double multiplier);

                void setTempDir(std::wstring tempDir);

                void setCanDrawBoth(bool bCanDrawBoth) { m_bCanDrawBoth = bCanDrawBoth; };

                double degreesToRadians(double degrees);
                double radiansToDegrees(double radians);
                void rotatePt(double angle, DPoint *point);
                void rotatePts(DPoint& center, double angle, DPoint *points, int npoints);

                void setMinMarkerSize(double size);
                void setMinCharHeight(double height);

                CColor m_backgroundColor;
                CDeviceColor m_deviceColor;

                DrawInfo m_drawInfo;

                double  m_vdcToCcMatrix[2][3];
                double  m_ccToVdcMatrix[2][3];
                double  m_stepValue;
 
                bool    m_hardclipValid;
                DRect   m_hardclip;

                bool    m_removeDups;
                bool    m_nint;
                
                emFillStruct m_emFillStruct;
                long m_nRotateHatchNPattern90; // 0-no, 1-pos/neg hatch, 2-all

                long m_clippingPathIndex;

                double  m_dMinLineWidth;
                double  m_dMaxLineWidth;
                double  m_dMultLineWidth;

                double m_dDCmaxDrawableLineWidth;

                double  m_dMinMarkerSize;

                double  m_dMinCharHeight;
                double m_dBaseTextScaleUp;
                double m_dStrokeCharLargerThan;

                CMatrix* m_pXForm;

                std::wstring *m_psTempDir;

                std::string encodingByType_n_Tail(int type, wchar_t tail);

                long getNumCircleSegments(double r, long maxNum = 0);
                DPoint* elCirclePolygon(DPoint, double, long*, DPoint*);

                double m_dMaxPenDCwidth; // the widest line a CDrawXXX::drawDCline() can draw
                                                                 // or you want to allow it to draw (some OpenGL can handle very
                                                                 // wide lines but the line ends look like crap so we limit
                                                                 // it to 3 pixels wide)

        private:

                bool m_bINemulDCline; // let's drawDCline know if we are already hitting the wall

                bool m_bCanDrawBoth; // DrawXXX's fill functions also draw edge at same time

                bool m_bProcessingTraceGroup;

                // emulate line support functions and variables
                void elDrawDashedPolyline(CCgmBaseObj*, double, long, DPoint*, long, float*, bool);
                void elDrawLineCap(CCgmBaseObj*, DPoint*, double, double, double, long);
                void elDrawLineJoin(CCgmBaseObj*, DPoint*, double, double, double);
                long swrdst(double, double, double, double, double, double,
                        double, double*, double*, double*, double*, double*, double*);
                long swrltl(double, double, double, double, double, double,
                        double, double, double*, double*);

                // emulate fill support functions
                void efPolyInsert(long);
                void efFillScan(CCgmBaseObj*, double);
                void efPlotVect(CCgmBaseObj*, double, double, double);
                void efPlotPat(CCgmBaseObj*, long, long, long);
                void efPlotHor(CCgmBaseObj*, long, long, long);
                void efPlotPix(CCgmBaseObj*, long, long, long);
                void efFlushPts(CCgmBaseObj*, long);
                void efRefGeometry(CCgmBaseObj*);
                void efMatSet(matStr*, double, double, double, double, double, double, double, double, double);
                void efMatMul(matStr*, matStr*, matStr*);
                void efPtMul(mptStr*, matStr*, mptStr*);

        };
};

/* use std::vector instead
class CDoubleArray
{
//Internal Data Members
protected:
        unsigned int    _size; //Count items.
        unsigned int    _room; //Available space.
        double*         _data; //The list.
        unsigned int    _grow; //Grow by increment.
public:
        //<summary>Default constructor.</summary>
        //<param name="grow">Array growth increment.</param>
        CDoubleArray(unsigned int grow = 4):
                _size(0),
                        _room(0),
                        _data(NULL),
                        _grow(grow)
                {
                        _data = (double*)malloc(sizeof(double)*_grow);
                        _room = (_data) ? _grow : 0;
                }
                ~CDoubleArray(){ if(_data) free(_data); }
public:
        bool empty(){ return (_size == 0); } //True if there is no data in the array.
        void remove_all(){ _size = 0; } //Remove all data elements from the array.
        void clear() //Free any allocated memory.
        {
                if(_data)
                {
                        _data = (double*)realloc(_data,sizeof(double)*_grow); //Reallocate to first growth increment.
                        _room = _grow; //Mark it as such.
                        _size = 0; //Mark array as empty.
                }
        }
        virtual double& operator[](unsigned int i) //Access element at subscript, or dummy value if overflow.
        {
                static double dummy = 0;
                if(i < _size) return _data[i]; else return dummy;
        }
        unsigned int size(){ return _size; } //Count data elements in the array.
        virtual double at(unsigned int i)       //Access element at subscript, or NULL if overflow.
        { 
                static double dummy = 0;
                if(i < _size) return _data[i]; else return dummy; 
        } 
        long push_back(double element) //Append a new element to the array.
        {
                if(_data) //Fail if no array.
                {
                        if(_size < _room) //There is enough allocated space.
                        {
                                _data[_size] = element; //Set it.
                                _size++; //Increment our count of elements.
                                return _size-1; //Return the element's subscript.
                        }
                        else //Not enough room.
                        {
                                double* temp = (double*)realloc(_data,sizeof(double)*(_size+_grow)); //Grow the array.
                                if(temp) //Reallocation succeeded.
                                {
                                        _room += _grow; //Increment available space.
                                        _data = temp; //Assign reallocated value to array pointer.
                                        _data[_size] = element; //Set the element to be added.
                                        _size++; //Increment our count of elements.
                                        return _size-1; //Return the element's subscript.
                                }
                        }
                }
                return -1; //Something failed, so return a bad subscript.
        }
        long insert(unsigned int i, double element)
        {
                if(_data) //Fail if no array
                {
                        if(_size < _room) //There is enough allocated space.
                        {
                                if(i >= _size) i = _size;
                                for(unsigned int m = _size; m > i; m--) _data[m] = _data[m-1];
                                _data[i] = element; //Set it.
                                _size++; //Increment our count of elements
                                return i; //Return the element's subscript.
                        }
                        else //Not enough room.
                        {
                                double* temp = (double*)realloc(_data,sizeof(double)*(_size+_grow)); //Grow the array.
                                if(temp) //Reallocation succeeded.
                                {
                                        _room += _grow; //Increment available space.
                                        _data = temp; //Assign reallocated value to array pointer.
                                        if(i >= _size) i = _size;
                                        for(unsigned int m = _size; m > i; m--) _data[m] = _data[m-1];
                                        _data[i] = element; //Set it.
                                        _size++; //Increment our count of elements
                                        return i; //Return the element's subscript.
                                }
                        }
                }
                return -1; //Something failed, so return a bad subscript
        }
};
*/

#endif // !defined(AFX_DRAWBASE_H__CA9A4F64_A587_44FB_A36B_8C173B304AA7__INCLUDED_)