core/ASCOfficePDFReader/GState.h

#ifndef _GSTATE_H
#define _GSTATE_H

#include "Object.h"
#include "Function.h"
#include <math.h>

class Array;
class GrFont;
class PDFRectangle;
class GrShading;

//-------------------------------------------------------------------------------------------------------------------------------
// GraphicsBlendMode
//-------------------------------------------------------------------------------------------------------------------------------

enum GraphicsBlendMode 
{
	grBlendNormal,
	grBlendMultiply,
	grBlendScreen,
	grBlendOverlay,
	grBlendDarken,
	grBlendLighten,
	grBlendColorDodge,
	grBlendColorBurn,
	grBlendHardLight,
	grBlendSoftLight,
	grBlendDifference,
	grBlendExclusion,
	grBlendHue,
	grBlendSaturation,
	grBlendColor,
	grBlendLuminosity
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrColorComp
//-------------------------------------------------------------------------------------------------------------------------------

// 16.16 
typedef int GrColorComp;

#define GrColorComp1 0x10000

static inline GrColorComp   DoubleToColor(double dValue) 
{
	return (GrColorComp)(dValue * GrColorComp1);
}

static inline double        ColorToDouble(GrColorComp nColor) 
{
	return (double)nColor / (double)GrColorComp1;
}

static inline GrColorComp   ByteToColor(unsigned char nByte) 
{
	// (nByte / 255) << 16  =  (0.0000000100000001... * nByte) << 16
	//                      =  ((nByte << 8) + (nByte) + (nByte >> 8) + ...) << 16
	//                      =   (nByte << 8) + (nByte) + (nByte >> 7)
	//                                      [äëÿ îêðóãëåíèÿ]
	return (GrColorComp)( ( nByte << 8 ) + nByte + ( nByte >> 7 ) );
}

static inline unsigned char ColorToByte(GrColorComp nColor) 
{
	// 255 * nColor + 0.5  =  256 * nColor - nColor + 0x8000
	return (unsigned char)( ( ( nColor << 8) - nColor + 0x8000 ) >> 16 );
}

//-------------------------------------------------------------------------------------------------------------------------------
// GrColor
//-------------------------------------------------------------------------------------------------------------------------------

#define GrColorMaxComps funcMaxOutputs

struct GrColor 
{
	GrColorComp arrComp[GrColorMaxComps];
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrGray
//-------------------------------------------------------------------------------------------------------------------------------

typedef GrColorComp GrGray;

//-------------------------------------------------------------------------------------------------------------------------------
// GrRGB
//-------------------------------------------------------------------------------------------------------------------------------

struct GrRGB 
{
	GrColorComp r, g, b;
};

//------------------------------------------------------------------------
// GrCMYK
//------------------------------------------------------------------------

struct GrCMYK 
{
	GrColorComp c, m, y, k;
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

// Êîíñòàíòû GrColorSpaceModes è ìàññèâ GrColorSpaceModeNames, îïðåäåëåííûé
// â GState.cpp äîëæíû ñîâïàäàòü.
enum GrColorSpaceMode 
{
	csDeviceGray,
	csCalGray,
	csDeviceRGB,
	csCalRGB,
	csDeviceCMYK,
	csLab,
	csICCBased,
	csIndexed,
	csSeparation,
	csDeviceN,
	csPattern
};

class GrColorSpace
{
public:

	GrColorSpace();
	virtual ~GrColorSpace();
	virtual GrColorSpace *Copy() = 0;
	virtual GrColorSpaceMode GetMode() = 0;

	static GrColorSpace *Parse(Object *pColorSpaceObject);

	// Êîíâåðòèðóåì â -> Gray, RGB, èëè CMYK.
	virtual void GetGray(GrColor *pColor, GrGray *pGray) = 0;
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB)  = 0;
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK) = 0;

	// Êîëè÷åñòâî êîìïîíåíò.
	virtual int  GetComponentsCount() = 0;

	// Ïîëó÷àåì ñòàíäàðòíîå çíà÷åíèå öâåòà â äàííîì öâåòîâîì ïðîñòðàíñòâå.
	virtual void GetDefaultColor(GrColor *pColor) = 0;

	// Ñòàíäàðòíûå ãðàíèö÷íûå çíà÷åíèÿ äëÿ êàæäîé êîìïîíåíòû ïèêñåëÿ, ãäå nMaxImagePixelValue - ìàêñèìàëüíîå çíà÷åíèå ïèêñåëÿ.
	virtual void GetDefaultRanges(double *pDecodeLow, double *pDecodeRange, int nMaxImagePixelValue);

	// True, åñëè â äàííîì öâåòîâîì ïðîñòðàíñòâå íà ñòðàíèöå íè÷åãî íå íàðèñîâàíî.
	virtual BOOL IsNonMarking() 
	{ 
		return FALSE; 
	}

	// ×èñëî ðàçëè÷íûõ öâåòîâûõ ïðîñòðàíñòâ.
	static int GetColorSpaceModesCount();

	// Èìÿ ñîîòâåòñòâóþùåãî öâåòîâîãî ïðîñòðàíñòâà.
	static char *GetColorSpaceModeName(int nIndex);

	DWORD GetDwordColor(GrColor *pColor)
	{
		GrRGB oRGB;
		GetRGB( pColor, &oRGB );
		BYTE nR = ColorToByte(oRGB.r);
		BYTE nG = ColorToByte(oRGB.g);
		BYTE nB = ColorToByte(oRGB.b);
		return ( (nB << 16) | (nG << 8) | nR );
	}

private:
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrDeviceGrayColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrDeviceGrayColorSpace: public GrColorSpace 
{
public:

	GrDeviceGrayColorSpace();
	virtual ~GrDeviceGrayColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csDeviceGray; 
	}

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 1; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

private:
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrCalGrayColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrCalGrayColorSpace: public GrColorSpace 
{
public:

	GrCalGrayColorSpace();
	virtual ~GrCalGrayColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csCalGray; 
	}

	static GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int GetComponentsCount() 
	{ 
		return 1; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó CalGray.
	double GetWhiteX() 
	{ 
		return m_dWhiteX; 
	}
	double GetWhiteY() 
	{ 
		return m_dWhiteY; 
	}
	double GetWhiteZ() 
	{ 
		return m_dWhiteZ; 
	}
	double GetBlackX() 
	{ 
		return m_dBlackX; 
	}
	double GetBlackY() 
	{ 
		return m_dBlackY; 
	}
	double GetBlackZ() 
	{ 
		return m_dBlackZ; 
	}
	double GetGamma() 
	{ 
		return m_dGamma; 
	}

private:

	double m_dWhiteX;   //
	double m_dWhiteY;   // White point
	double m_dWhiteZ;   //

	double m_dBlackX;   //
	double m_dBlackY;   // Black point
	double m_dBlackZ;   // 

	double m_dGamma;    // Gamma
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrDeviceRGBColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrDeviceRGBColorSpace: public GrColorSpace 
{
public:

	GrDeviceRGBColorSpace();
	virtual ~GrDeviceRGBColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csDeviceRGB; 
	}


	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 3; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

private:
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrCalRGBColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrCalRGBColorSpace: public GrColorSpace 
{
public:

	GrCalRGBColorSpace();
	virtual ~GrCalRGBColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csCalRGB; 
	}

	static GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int GetComponentsCount() 
	{ 
		return 3; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó CalRBG.
	double  GetWhiteX() 
	{ 
		return m_dWhiteX; 
	}
	double  GetWhiteY() 
	{ 
		return m_dWhiteY; 
	}
	double  GetWhiteZ() 
	{ 
		return m_dWhiteZ; 
	}
	double  GetBlackX() 
	{ 
		return m_dBlackX; 
	}
	double  GetBlackY() 
	{ 
		return m_dBlackY; 
	}
	double  GetBlackZ() 
	{ 
		return m_dBlackZ; 
	}
	double  GetGammaR() 
	{ 
		return m_dGammaR; 
	}
	double  GetGammaG() 
	{ 
		return m_dGammaG; 
	}
	double  GetGammaB() 
	{ 
		return m_dGammaB; 
	}
	double *GetMatrix() 
	{ 
		return m_arrdMatrix; 
	}

private:

	double m_dWhiteX;       //
	double m_dWhiteY;       // White point
	double m_dWhiteZ;       //

	double m_dBlackX;       //
	double m_dBlackY;       // Black point
	double m_dBlackZ;       //

	double m_dGammaR;       //
	double m_dGammaG;       // Gamma
	double m_dGammaB;       //

	double m_arrdMatrix[9]; // Ìàòðèöà ïðåîáðàçîâàíèÿ: ABC -> XYZ
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrDeviceCMYKColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrDeviceCMYKColorSpace: public GrColorSpace 
{
public:

	GrDeviceCMYKColorSpace();
	virtual ~GrDeviceCMYKColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csDeviceCMYK; 
	}

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 4; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

private:
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrLabColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrLabColorSpace: public GrColorSpace
{
public:

	GrLabColorSpace();
	virtual ~GrLabColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csLab; 
	}

	static GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 3; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	virtual void GetDefaultRanges(double *pDecodeLow, double *pDecodeRange, int nMaxImagePixelValue);

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó Lab.
	double GetWhiteX() 
	{ 
		return m_dWhiteX; 
	}
	double GetWhiteY() 
	{ 
		return m_dWhiteY; 
	}
	double GetWhiteZ() 
	{ 
		return m_dWhiteZ; 
	}
	double GetBlackX() 
	{ 
		return m_dBlackX; 
	}
	double GetBlackY() 
	{ 
		return m_dBlackY; 
	}
	double GetBlackZ() 
	{ 
		return m_dBlackZ; 
	}
	double GetMinA() 
	{ 
		return m_dMinA; 
	}
	double GetMaxA() 
	{ 
		return m_dMaxA; 
	}
	double GetMinB() 
	{ 
		return m_dMinB; 
	}
	double GetMaxB() 
	{ 
		return m_dMaxB; 
	}

private:

	double m_dWhiteX;  //
	double m_dWhiteY;  // White point
	double m_dWhiteZ;  //

	double m_dBlackX;  //
	double m_dBlackY;  // Black point
	double m_dBlackZ;  // 
  
	double m_dMinA;    //
	double m_dMaxA;    // Ãðàíèöû äëÿ êîìïîíåíò À è Â
	double m_dMinB;    //
	double m_dMaxB;    //

	double m_dMultR;   // 
	double m_dMultG;   // Äîïîëíèòåëüíûå ñîìíîæèòåëè
	double m_dMultB;   //
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrICCBasedColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrICCBasedColorSpace: public GrColorSpace 
{
public:

	GrICCBasedColorSpace(int nCompontnsCount, GrColorSpace *pAlternate, Ref *pICCProfileStream);
	virtual ~GrICCBasedColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csICCBased; 
	}


	static GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return m_nComponentsCount; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	virtual void GetDefaultRanges(double *pDecodeLow, double *pDecodeRange, int nMaxImagePixelValue);

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó Lab.
	GrColorSpace *GetAlternate() 
	{ 
		return m_pAlternate; 
	}

private:

	int           m_nComponentsCount;  // ×èñëî êîìïîíåíò öâåòà (1, 3, or 4)
	GrColorSpace *m_pAlternate;        // Àëüòåðíàòèâíîå öâåòîâîå ïðîñòðàíñòâî
	double        m_arrdRangeMin[4];   // Ìèíèìàëüíûå çíà÷åíèÿ äëÿ êàæäîé êîìïîíåíòû
	double        m_arrdRangeMax[4];   // Ìàêñèìàëüíûå çíà÷åíèÿ äëÿ êàæäîé êîìïîíåíòû
	Ref           m_oICCProfileStream; // ICC 
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrIndexedColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrIndexedColorSpace: public GrColorSpace 
{
public:

	GrIndexedColorSpace(GrColorSpace *pBase, int nHival);
	virtual ~GrIndexedColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csIndexed; 
	}

	static  GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 1; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	virtual void GetDefaultRanges(double *pDecodeLow, double *pDecodeRange, int nMaxImagePixelValue);

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó Indexed.
	GrColorSpace  *GetBase() 
	{ 
		return m_pBase; 
	}
	int            GetHival() 
	{ 
		return m_nHival; 
	}
	unsigned char *GetLookup() 
	{ 
		return m_pLookup; 
	}

private:

	GrColor *MapColorToBase(GrColor *pColor, GrColor *pBaseColor);

private:

	GrColorSpace  *m_pBase;   // Áàçîâîå öâåòîâîå ïðîñòðàíñòâî
	int            m_nHival;  // Hival = max valid index value
	unsigned char *m_pLookup; // Òàáëèöà öâåòîâ
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrSeparationColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrSeparationColorSpace: public GrColorSpace
{
public:

	GrSeparationColorSpace(StringExt *seName, GrColorSpace *pAlternate, Function *pFunction);
	virtual ~GrSeparationColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csSeparation; 
	}

	static  GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 1; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	virtual BOOL IsNonMarking()  
	{ 
		return m_bNonMarking; 
	}

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó Separation.
	StringExt    *GetName() 
	{ 
		return m_seName; 
	}
	GrColorSpace *GetAlternateSpace() 
	{ 
		return m_pAlternateSpace; 
	}
	Function     *GetTransformFunction() 
	{ 
		return m_pFunction; 
	}

private:

	StringExt    *m_seName;          // Color space family name
	GrColorSpace *m_pAlternateSpace; // Àëüòåðíàòèâíîå öâåòîâîå ïðîñòðàíñòâî
	Function     *m_pFunction;	     // tintTransform ( ôóíêöèÿ ïðåîáðàçîâàíèÿ â àëüòåðíàòèâíîå ïðîñòðàíñòâî)

	BOOL          m_bNonMarking;     // Áóäåò ëè âèäèìîé ãðàôèêà, èñïîëüçóþùàÿ äàííîå öâåòîâîå ïðîñòðàíñòâî
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrDeviceNColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrDeviceNColorSpace: public GrColorSpace 
{
public:

	GrDeviceNColorSpace(int nComponentsCount, GrColorSpace *pAlternate, Function *pFunction);
	virtual ~GrDeviceNColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csDeviceN; 
	}

	
	static  GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return m_nComponentsCount; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	virtual BOOL IsNonMarking()  
	{ 
		return m_bNonMarking; 
	}

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó DeviceN.
	StringExt    *GetColorantName(int nIndex) 
	{ 
		return m_arrseNames[nIndex]; 
	}
	GrColorSpace *GetAlternateColor() 
	{ 
		return m_pAlternateSpace; 
	}
	Function     *GetTransformFunction() 
	{ 
		return m_pFunction; 
	}

private:

	int           m_nComponentsCount;            // ×èñëî êîìïîíåíò
	StringExt    *m_arrseNames[GrColorMaxComps]; // Îáúåêòû òèïà "Name" îïðåäåëÿþùèå êàæäóþ öâåòîâóþ êîìïîíåíòó
	GrColorSpace *m_pAlternateSpace;             // Àëüòåðíàòèâíîå öâåòîâîå ïðîñòðàíñòâî
	Function     *m_pFunction;	                 // tintTransform ( ôóíêöèÿ ïðåîáðàçîâàíèÿ â àëüòåðíàòèâíîå ïðîñòðàíñòâî)

	BOOL          m_bNonMarking;                 // Áóäåò ëè âèäèìîé ãðàôèêà, èñïîëüçóþùàÿ äàííîå öâåòîâîå ïðîñòðàíñòâî
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrPatternColorSpace
//-------------------------------------------------------------------------------------------------------------------------------

class GrPatternColorSpace: public GrColorSpace 
{
public:

	GrPatternColorSpace(GrColorSpace *pUnder);
	virtual ~GrPatternColorSpace();
	virtual GrColorSpace *Copy();
	virtual GrColorSpaceMode GetMode() 
	{ 
		return csPattern; 
	}

	
	static  GrColorSpace *Parse(Array *pArray);

	virtual void GetGray(GrColor *pColor, GrGray *pGray);
	virtual void GetRGB (GrColor *pColor, GrRGB  *pRGB);
	virtual void GetCMYK(GrColor *pColor, GrCMYK *pCMYK);

	virtual int  GetComponentsCount() 
	{ 
		return 0; 
	}
	virtual void GetDefaultColor(GrColor *pColor);

	// Âîçâðàùàåì çíà÷åíèÿ, ñïåöèôè÷íûå ïðîñòðàíñòâó Pattern.
	GrColorSpace *GetUnder() 
	{ 
		return m_pUnder; 
	}

private:

	GrColorSpace *m_pUnder;    // Öâåòîâîå ïðîñòðàíñòâî ïîäêëàäêè (äëÿ íå öâåòîâûõ Patterns)
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrPattern
//-------------------------------------------------------------------------------------------------------------------------------

class GrPattern 
{
public:

	GrPattern(int nType);
	virtual ~GrPattern();

	static  GrPattern *Parse(Object *pObject);

	virtual GrPattern *Copy() = 0;

	int GetType() 
	{ 
		return m_nType; 
	}

private:

	int m_nType;
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrTilingPattern
//-------------------------------------------------------------------------------------------------------------------------------

class GrTilingPattern: public GrPattern 
{
public:

	static GrTilingPattern *Parse(Object *pPatternObject);
	virtual ~GrTilingPattern();

	virtual GrPattern *Copy();

	int     GetPaintType() 
	{ 
		return m_nPaintType; 
	}
	int     GetTilingType() 
	{ 
		return m_nTilingType; 
	}
	double *GetBBox() 
	{ 
		return m_arrBBox; 
	}
	double  GetXStep() 
	{ 
		return m_dXStep; 
	}
	double  GetYStep() 
	{ 
		return m_dYStep; 
	}
	Dict   *GetResourcesDict()
    { 
		return m_oResources.IsDict() ? m_oResources.GetDict() : (Dict *)NULL; 
	}
	double *GetMatrix() 
	{ 
		return m_arrMatrix; 
	}
	Object *GetContentStream() 
	{ 
		return &m_oContentStream; 
	}

private:

	GrTilingPattern(int nPaintType, int nTilingType, double *pBBox, double dXStep, double dYStep, Object *pResources, double *pMatrix, Object *pContentStream);

private:

	int    m_nPaintType;
	int    m_nTilingType;
	double m_arrBBox[4];
	double m_dXStep;
	double m_dYStep;
	Object m_oResources;
	double m_arrMatrix[6];

	Object m_oContentStream;
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrShadingPattern
//-------------------------------------------------------------------------------------------------------------------------------

class GrShadingPattern: public GrPattern 
{
public:

	static GrShadingPattern *Parse(Object *pPatternObject);
	virtual ~GrShadingPattern();

	virtual GrPattern *Copy();

	GrShading *GetShading() 
	{ 
		return m_pShading; 
	}
	double     *GetMatrix() 
	{ 
		return m_arrMatrix; 
	}

private:

	GrShadingPattern(GrShading *pShading, double *pMatrix);

private:

	GrShading *m_pShading;      // Ñàì îáúåêò Shading
	double     m_arrMatrix[6];  // Pattern matrix
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrShading
//-------------------------------------------------------------------------------------------------------------------------------

class GrShading 
{
public:

	GrShading(int nType);
	GrShading(GrShading *pShading);
	virtual ~GrShading();

	static GrShading *Parse(Object *pObject);

	virtual GrShading *Copy() = 0;

	int           GetType() 
	{ 
		return m_nType; 
	}
	GrColorSpace *GetColorSpace() 
	{ 
		return m_pColorSpace; 
	}
	GrColor      *GetBackground() 
	{ 
		return &m_oBackground; 
	}
	BOOL          GetHasBackground() 
	{ 
		return m_bHasBackground; 
	}
	void          GetBBox(double *pdXMin, double *pdYMin, double *pdXMax, double *pdYMax)
    { 
		*pdXMin = m_dXMin; 
		*pdYMin = m_dYMin; 
		*pdXMax = m_dXMax; 
		*pdYMax = m_dYMax; 
	}
	BOOL          GetHasBBox() 
	{ 
		return m_bHasBBox; 
	}

protected:

	BOOL Initialize(Dict *pDict);

protected:

	int           m_nType;          // Òèï
	GrColorSpace *m_pColorSpace;    // Öâåòîâîå ïðîñòðàíñòâî, â êîòîðîì ðèñóåì
	GrColor       m_oBackground;    // Öâåò ïîäêëàäêè, åñëè îíà åñòü
	BOOL          m_bHasBackground; // Åñòü ëè ïîäêëàäêà?

	double        m_dXMin;          //
	double        m_dYMin;          // BBox
	double        m_dXMax;          //
	double        m_dYMax;          //
	BOOL          m_bHasBBox;       // Çàäàí ëè BBox?
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrFunctionShading
//-------------------------------------------------------------------------------------------------------------------------------

class GrFunctionShading: public GrShading 
{
public:

	GrFunctionShading(double dMinX, double dMinY, double dMaxX, double dMaxY, double *pMatrix, Function **ppFunctions, int nFuncsCount);
	GrFunctionShading(GrFunctionShading *pShading);
	virtual ~GrFunctionShading();

	static GrFunctionShading *Parse(Dict *pDict);

	virtual GrShading *Copy();

	void      GetDomain(double *pdMinX, double *pdMinY, double *pdMaxX, double *pdMaxY)
    { 
		*pdMinX = m_dDomainMinX; 
		*pdMinY = m_dDomainMinY; 
		*pdMaxX = m_dDomainMaxX; 
		*pdMaxY = m_dDomainMaxY; 
	}
	double   *GetMatrix() 
	{ 
		return m_arrMatrix; 
	}
	int       GetFunctionsCount() 
	{ 
		return m_nFunctionsCount; 
	}
	Function *GetFunction(int nIndex) 
	{ 
		return m_arrFunctions[nIndex]; 
	}
	void      GetColor(double dX, double dY, GrColor *pColor);

private:

	double    m_dDomainMinX;   // 
	double    m_dDomainMinY;   //  Domain
	double    m_dDomainMaxX;   //
	double    m_dDomainMaxY;   //

	double    m_arrMatrix[6];  // Ìàòðèöà ïðåîáðàçîâàíèÿ è ïðîñòðàíñòâà, îïðåäåëåííîãî Domain, â òåêóùåå ïðîñòðàíñòâî Shading
	Function *m_arrFunctions[GrColorMaxComps];
	int       m_nFunctionsCount;
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrAxialShading
//-------------------------------------------------------------------------------------------------------------------------------

class GrAxialShading: public GrShading 
{
public:

	GrAxialShading(double dX0, double dY0, double dX1, double dY1, double dT0, double dT1, Function **ppFunctions, int nFuncsCount, BOOL bExtendStart, BOOL bExtendEnd);
	GrAxialShading(GrAxialShading *pShading);
	virtual ~GrAxialShading();

	static GrAxialShading *Parse(Dict *pDict);

	virtual GrShading *Copy();

	void      GetCoords(double *pdX0, double *pdY0, double *pdX1, double *pdY1)
    { 
		*pdX0 = m_dAxisX0; 
		*pdY0 = m_dAxisY0; 
		*pdX1 = m_dAxisX1; 
		*pdY1 = m_dAxisY1; 
	}
	double    GetDomain0() 
	{ 
		return m_dT0; 
	}
	double    GetDomain1() 
	{ 
		return m_dT1; 
	}
	BOOL      GetExtendStart() 
	{ 
		return m_bExtendStart; 
	}
	BOOL      GetExtendEnd() 
	{ 
		return m_bExtendEnd; 
	}
	int       GetFunctionsCount() 
	{ 
		return m_nFunctionsCount; 
	}
	Function *GetFunctions(int nIndex) 
	{ 
		return m_arrFunctions[nIndex]; 
	}
	void      GetColor(double dT, GrColor *pColor);

private:

	double    m_dAxisX0;              // Íà÷àëüíàÿ òî÷êà âåêòîðà
	double    m_dAxisY0;              // 
	double    m_dAxisX1;              // Êîíå÷íàÿ òî÷êà âåêòîðà
	double    m_dAxisY1;              //

	double    m_dT0;                  // Ïðåäåëû ïàðàìåòðà t(ïàðàìåòðèçàöèÿ îñè)
	double    m_dT1;

	Function *m_arrFunctions[GrColorMaxComps]; 
	int       m_nFunctionsCount;

	BOOL      m_bExtendStart;         // Ïðîäîëæàòü ëè çà íà÷àëüíóþ òî÷êó îñè
	BOOL      m_bExtendEnd;           // Ïðîäîëæàòü ëè çà êîíå÷íóþ òî÷êó îñè
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrRadialShading
//-------------------------------------------------------------------------------------------------------------------------------

class GrRadialShading: public GrShading 
{
public:

	GrRadialShading(double dFirstX, double dFirstY, double dFirstRad, double dSecondX, double dSecondY, double dSecondRad, double dT0, double dT1, Function **ppFunctions, int nFuncsCount, BOOL bExtendFirst, BOOL bExtendSecond);
	GrRadialShading(GrRadialShading *pShading);
	virtual ~GrRadialShading();

	static GrRadialShading *Parse(Dict *pDict);

	virtual GrShading *Copy();

	void      GetCoords(double *pdFirstX, double *pdFirstY, double *pdFirstRad, double *pdSecondX, double *pdSecondY, double *pdSecondRad)
    { 
		*pdFirstX    = m_dFirstX; 
		*pdFirstY    = m_dFirstY; 
		*pdFirstRad  = m_dFirstRad; 
		*pdSecondX   = m_dSecondX; 
		*pdSecondY   = m_dSecondY; 
		*pdSecondRad = m_dSecondRad; 
	}
	double    GetDomain0() 
	{ 
		return m_dT0; 
	}
	double    GetDomain1() 
	{ 
		return m_dT1; 
	}
	BOOL      GetExtendFirst() 
	{ 
		return m_bExtendFirst; 
	}
	BOOL      GetExtendSecond() 
	{ 
		return m_bExtendSecond; 
	}
	int       GetFunctionsCount() 
	{ 
		return m_nFunctionsCount; 
	}
	Function *GetFunctions(int nIndex) 
	{ 
		return m_arrFunctions[nIndex]; 
	}
	void      GetColor(double dT, GrColor *pColor);

private:

	double    m_dFirstX;          // Êîîðäèíàòû öåíòðà ïåðâîé îêðóæíîñòè
	double    m_dFirstY;          //
	double    m_dFirstRad;        // Ðàäèóñ ïåðâîé îêðóæíîñòè
	double    m_dSecondX;         // Êîîðäèíàòû öåíòðà âòîðîé îêðóæíîñòè
	double    m_dSecondY;         // 
	double    m_dSecondRad;       // Ðàäèóñ âòîðîé îêðóæíîñòè

	double    m_dT0;              // Ãðàíèöû ïàðàìåòðà t
	double    m_dT1;              // 

	Function *m_arrFunctions[GrColorMaxComps];
	int       m_nFunctionsCount;
	BOOL      m_bExtendFirst;     // Ïðîäîëæàòü ëè ðèñîâàòü çà ïåðâûé êðóã
	BOOL      m_bExtendSecond;    // Ïðîäîëæàòü ëè ðèñîâàòü çà âòîðîé êðóã
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrGouraudTriangleShading
//-------------------------------------------------------------------------------------------------------------------------------

struct GrGouraudVertex 
{
	double  dX;       // Êîîðäèíàòû âåðøèíû
	double  dY;       //
	GrColor oColor;   // Öâåò
};

class GrGouraudTriangleShading: public GrShading 
{
public:

	GrGouraudTriangleShading(int nType, GrGouraudVertex *pVertexes, int nVertexsCount, int (*pTriangles)[3], int nTrianglesCount, Function **ppFunctions, int nFunctionsCount);
	GrGouraudTriangleShading(GrGouraudTriangleShading *pShading);
	virtual ~GrGouraudTriangleShading();

	static GrGouraudTriangleShading *Parse(int nType, Dict *pDict, Stream *pStream);

	virtual GrShading *Copy();

	int  GetTrianglesCount() 
	{ 
		return m_nTrianglesCount; 
	}
	void GetTriangle(int nIndex, double *pdX0, double *pdY0, GrColor *pColor0, double *pdX1, double *pdY1, GrColor *pColor1, double *pdX2, double *pdY2, GrColor *pColor2);

private:

	GrGouraudVertex *m_arrVertexs;                    // Ìàññèâ âñåõ âåðøèí
	int              m_nVertexsCount;                 // Êîëè÷åñòâî âåðøèí
	int            (*m_arrTriangles)[3];              // Ìàññèâ òðåóãîëüíèêîâ(òðåóãîëüíèê îïðåäåëÿåòñÿ ïî íîìåðàì âåðøèí)
	int              m_nTrianglesCount;               // Êîëè÷åñòâî òðåóãîëüíèêîâ
	Function        *m_ppFunctions[GrColorMaxComps];  // Ôóíêöèè
	int              m_nFunctionsCount;               // Êîëè÷åñòâî ôóíêöèé
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrPatchMeshShading
//-------------------------------------------------------------------------------------------------------------------------------

struct GrPatch 
{
	double  arrX[4][4];
	double  arrY[4][4];
	GrColor arrColor[2][2];
};

class GrPatchMeshShading: public GrShading 
{
public:

	GrPatchMeshShading(int nType, GrPatch *pPatches, int nPatchesCount, Function **ppFuntions, int nFunctionsCount);
	GrPatchMeshShading(GrPatchMeshShading *pShading);

	virtual ~GrPatchMeshShading();

	static GrPatchMeshShading *Parse(int nType, Dict *pDict, Stream *pStream);

	virtual GrShading *Copy();

	int      GetPatchesCount() 
	{ 
		return m_nPatchesCount; 
	}
	GrPatch *GetPatch(int nIndex)
	{ 
		return &m_pPatches[nIndex]; 
	}

private:

	GrPatch  *m_pPatches;                      // Ìàññèâ ÷àñòåé
	int       m_nPatchesCount;                 // Êîëè÷åñòâî ÷àñòåé
	Function *m_ppFunctions[GrColorMaxComps];  // Ìàññèâ ôóíêöèé
	int       m_nFunctionsCount;               // Êîëè÷åñòâî ôóíêöèé
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrImageColorMap
//-------------------------------------------------------------------------------------------------------------------------------

class GrImageColorMap 
{
public:

	GrImageColorMap(int nBitsPerComponent, Object *pDecode, GrColorSpace *pColorSpace);

	~GrImageColorMap();

	GrImageColorMap *Copy() 
	{ 
		return new GrImageColorMap(this);
	}

	BOOL IsValid() 
	{ 
		return m_bSuccess; 
	}

	GrColorSpace *GetColorSpace() 
	{ 
		return m_pColorSpace; 
	}

	int GetComponentsCount() 
	{ 
		return m_nComponentsCount; 
	}
	int GetBitsPerComponent() 
	{ 
		return m_nBitsPerComponent; 
	}

	double GetDecodeLow(int nIndex) 
	{ 
		return m_arrDecodeLow[nIndex]; 
	}
	double GetDecodeHigh(int nIndex) 
	{ 
		return m_arrDecodeLow[nIndex] + m_arrDecodeRange[nIndex]; 
	}

	void GetGray (unsigned char *pColorValue, GrGray  *pGray);
	void GetRGB  (unsigned char *pColorValue, GrRGB   *pRGB);
	void GetCMYK (unsigned char *pColorValue, GrCMYK  *pCMYK);
	void GetColor(unsigned char *pColorValue, GrColor *pColor);

private:

	GrImageColorMap(GrImageColorMap *pColorMap);

private:

	GrColorSpace *m_pColorSpace;                     // Öâåòîâîå ïðîñòðàíñòâî èçîáðàæåíèÿ
	int           m_nBitsPerComponent;               // bits per component
	int           m_nComponentsCount;                // ×èñëî öâåòîâûõ êîìïîíåíò â ïèêñåëå
	GrColorSpace *m_pColorSpace2;                    // Âòîðîå öâåòîâîå ïðîñòðàíñòâî
	int           m_nComponentsCount2;               // ×èñëî öâåòîâûõ êîìïîíåíò â ïèêñåëå(âî âòîðîì ïðîñòðàíñòâå)
	GrColorComp  *m_ppLookup[GrColorMaxComps];       // lookup table
	double        m_arrDecodeLow[GrColorMaxComps];   // Ìèíèìàëüíûå çíà÷åíèÿ äëÿ êàæäîé êîìïîíåíòû
	double        m_arrDecodeRange[GrColorMaxComps]; // Çíà÷åíèÿ (Max - min) äëÿ êàæäîé êîìïîíåíòû

	BOOL          m_bSuccess;
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrSubpath and GrPath
//-------------------------------------------------------------------------------------------------------------------------------

class GrSubpath 
{
public:

	GrSubpath(double dX, double dY);

	~GrSubpath();

	GrSubpath *Copy() 
	{ 
		return new GrSubpath(this); 
	}

	int    GetPointsCount() 
	{ 
		return m_nPointsCount; 
	}
	double GetX(int nIndex) 
	{ 
		return m_pX[nIndex]; 
	}
	double GetY(int nIndex) 
	{ 
		return m_pY[nIndex]; 
	}
	BOOL   GetCurve(int nIndex) 
	{ 
		return m_pbCurve[nIndex]; 
	}

	double GetLastX() 
	{ 
		return m_pX[m_nPointsCount - 1]; 
	}
	double GetLastY() 
	{ 
		return m_pY[m_nPointsCount - 1]; 
	}


	void LineTo(double dX, double dY);

	void CurveTo(double dX1, double dY1, double dX2, double dY2, double dX3, double dY3);

	void Close();

	BOOL IsClosed() 
	{ 
		return m_bClosed; 
	}


	// Äîáàâëÿåì ñäâèã (<dDx>, <dDy>) ê êàæäîé òî÷êå subpath.
	void Offset(double dDx, double dDy);
	void Transform(double *pMatrix);

	bool IsEqual(GrSubpath *pSubPath)
	{
		if ( m_nPointsCount != pSubPath->m_nPointsCount || m_bClosed != pSubPath->m_bClosed )
			return false;


		for ( int nIndex = 0; nIndex < m_nPointsCount; nIndex++ )
		{
			if ( fabs( m_pX[nIndex] - pSubPath->m_pX[nIndex] ) > 0.001 || fabs( m_pY[nIndex] - pSubPath->m_pY[nIndex] ) > 0.001 || m_pbCurve[nIndex] != pSubPath->m_pbCurve[nIndex] )
				return false;
		}

		return true;
	}

private:

	GrSubpath(GrSubpath *pSubpath);

private:

	double *m_pX;           // Êîîðäèíàòû òî÷åê â supath
	double *m_pY;           //

	BOOL   *m_pbCurve;      // Åñëè m_bCurve[i] = true => òî÷êà i - êîíòðîëüíàÿ òî÷êà äëÿ êðèâîé Áåçüå
	int     m_nPointsCount; // Êîëè÷åñòâî òî÷åê
	int     m_nSize;        // Ðàçìåð ìàññèâîâ m_pX/m_pY
	BOOL    m_bClosed;      // Çàêðûò ëè path?
};

class GrPath 
{
public:

	GrPath();

	~GrPath();

	GrPath *Copy() 
	{ 
		return new GrPath( m_bJustStarted, m_dFirstX, m_dFirstY, m_ppSubpaths, m_nSubpathsCount, m_nSize); 
	}

	// Åñòü ëè òåêóùàÿ òî÷êà?
	BOOL IsCurPoint() 
	{ 
		return m_nSubpathsCount > 0 || m_bJustStarted; 
	}

	// Ïóñòîé ëè path, ò.å. åñòü ëè â íåì õîòÿ áû îäèí subpath?
	BOOL IsPathNonEmpty() 
	{ 
		return m_nSubpathsCount > 0; 
	}

	int        GetSubpathsCount() 
	{ 
		return m_nSubpathsCount; 
	}
	GrSubpath *GetSubpath(int nIndex) 
	{ 
		return m_ppSubpaths[nIndex]; 
	}

	double     GetLastX() 
	{ 
		return m_ppSubpaths[m_nSubpathsCount - 1]->GetLastX(); 
	}
	double     GetLastY() 
	{ 
		return m_ppSubpaths[m_nSubpathsCount - 1]->GetLastY(); 
	}


	void MoveTo (double dX, double dY);
	void LineTo (double dX, double dY);
	void CurveTo(double dX1, double dY1, double dX2, double dY2, double dX3, double dY3);
	void Close();
	void Append(GrPath *pPath);

	// Äîáàâëÿåì ñäâèã (<dDx>, <dDy>) ê êàæäîé òî÷êå path.
	void Offset(double dDx, double dDy);

	bool IsEqual(GrPath *pPath)
	{
		if ( m_nSubpathsCount != pPath->m_nSubpathsCount )
			return false;

		for ( int nIndex = 0; nIndex < m_nSubpathsCount; nIndex++ )
		{
			if ( !m_ppSubpaths[nIndex]->IsEqual( pPath->m_ppSubpaths[nIndex] ) ) 
				return false;
		}

		return true;
	}

private:

	GrPath(BOOL bJustStarted, double dFirstX, double dFirstY, GrSubpath **ppSubpaths, int nSubpathsCount, int nSize);

private:
	BOOL        m_bJustStarted;   // True, åñëè íîâûé subpath áûë òîëüêî ÷òî íà÷àò
	double      m_dFirstX;        // Êîîðäèíàòû ïåðâîé òî÷êè íîâîãî subpath
	double      m_dFirstY;        // 
	GrSubpath **m_ppSubpaths;     // Ñïèñîê subpaths
	int         m_nSubpathsCount; // Êîëè÷åòñâî subpaths
	int         m_nSize;          // Ðàçìåð ìàññèâà m_ppSubpaths
};


//-------------------------------------------------------------------------------------------------------------------------------
// GrTextClip
//-------------------------------------------------------------------------------------------------------------------------------

class GrTextClip
{
public:

	GrTextClip()
	{
		m_nTextsCount = m_nSize = 0;
		m_pTexts  = NULL;
		m_pMatrix = NULL;
	}

	GrTextClip *Copy() 
	{ 
		return new GrTextClip(this);
	}

	~GrTextClip()
	{
		for ( int nIndex = 0; nIndex < m_nTextsCount; ++nIndex ) 
		{
			if ( m_pTexts->bsText )
			{
				::SysFreeString( m_pTexts->bsText );
			}

			if ( m_pTexts->bsFontName )
			{
				::SysFreeString( m_pTexts->bsFontName );
			}

			if ( m_pTexts->bsFontPath )
			{
				::SysFreeString( m_pTexts->bsFontPath );
			}
		}
		MemUtilsFree( m_pTexts );
		MemUtilsFree( m_pMatrix );
	}

	void Reset()
	{
		for ( int nIndex = 0; nIndex < m_nTextsCount; ++nIndex ) 
		{
			if ( m_pTexts->bsText )
			{
				::SysFreeString( m_pTexts->bsText );
			}
		}
		MemUtilsFree( m_pTexts );
		MemUtilsFree( m_pMatrix );

		m_nTextsCount = m_nSize = 0;
		m_pTexts  = NULL;
		m_pMatrix = NULL;
	}

	void ClipToText(CString sFontName, CString sFontPath, double dFontSize, LONG lFontStyle, double *pMatrix, CString sText, double dX, double dY, double dWidth = 0, double dHeight = 0, double dBaseLineOffset = 0)
	{
		Resize(1);

		m_pTexts[m_nTextsCount].bsFontName      = sFontName.AllocSysString();
		m_pTexts[m_nTextsCount].bsFontPath      = sFontPath.AllocSysString();
		m_pTexts[m_nTextsCount].dFontSize       = dFontSize;
		m_pTexts[m_nTextsCount].lFontStyle      = lFontStyle;
		m_pTexts[m_nTextsCount].bsText          = sText.AllocSysString();
		m_pTexts[m_nTextsCount].dX              = dX;
		m_pTexts[m_nTextsCount].dY              = dY;
		m_pTexts[m_nTextsCount].dWidth          = dWidth;
		m_pTexts[m_nTextsCount].dHeight         = dHeight;
		m_pTexts[m_nTextsCount].dBaseLineOffset = dBaseLineOffset;

		m_pMatrix[m_nTextsCount].FromDoublePointer( pMatrix );

		++m_nTextsCount;
		return;

	}

	int     GetTextsCount() 
	{ 
		return m_nTextsCount; 
	}

	BSTR    GetText(int nTextIndex, double *pdX, double *pdY, double *pdWidth, double *pdHeight, double *pdBaseLineOffset, BSTR *pbsFontName, BSTR *pbsFontPath, double *pdFontSize, LONG *plFontStyle)
	{
		if ( nTextIndex < 0 || nTextIndex >= m_nTextsCount )
			return NULL;

		*pdX              = m_pTexts[nTextIndex].dX;
		*pdY              = m_pTexts[nTextIndex].dY;
		*pdWidth          = m_pTexts[nTextIndex].dWidth;
		*pdHeight         = m_pTexts[nTextIndex].dHeight;
		*pdBaseLineOffset = m_pTexts[nTextIndex].dBaseLineOffset;

		*pbsFontName      = m_pTexts[nTextIndex].bsFontName;
		*pbsFontPath      = m_pTexts[nTextIndex].bsFontPath;
		*pdFontSize       = m_pTexts[nTextIndex].dFontSize;
		*plFontStyle      = m_pTexts[nTextIndex].lFontStyle;

		return m_pTexts[nTextIndex].bsText;
	}
	double *GetMatrix(int nTextIndex)
	{
		if ( nTextIndex < 0 || nTextIndex >= m_nTextsCount )
			return NULL;

		return m_pMatrix[nTextIndex].ToDoublePointer();
	}
	bool    IsEqual(GrTextClip *pClip)
	{
		if ( pClip->m_nTextsCount != m_nTextsCount )
			return false;

		for ( int nIndex = 0; nIndex < m_nTextsCount; nIndex++ )
		{
			if ( !m_pTexts[nIndex].IsEqual( pClip->m_pTexts[nIndex] ) || !m_pMatrix[nIndex].IsEqual( pClip->m_pMatrix[nIndex] ) )
				return false;
		}

		return true;
	}

private:

	GrTextClip(GrTextClip *pTextClip)
	{
		m_nTextsCount = pTextClip->m_nTextsCount;
		m_nSize       = pTextClip->m_nSize;

		m_pTexts  = (Text   *)MemUtilsMallocArray( m_nSize, sizeof(Text));
		m_pMatrix = (Matrix *)MemUtilsMallocArray( m_nSize, sizeof(Matrix)); 

		for ( int nIndex = 0; nIndex < m_nTextsCount; ++nIndex ) 
		{
			m_pTexts[nIndex].bsText          = CString(pTextClip->m_pTexts[nIndex].bsText).AllocSysString();
			m_pTexts[nIndex].dX              = pTextClip->m_pTexts[nIndex].dX;
			m_pTexts[nIndex].dY              = pTextClip->m_pTexts[nIndex].dY;
			m_pTexts[nIndex].dWidth          = pTextClip->m_pTexts[nIndex].dWidth;
			m_pTexts[nIndex].dHeight         = pTextClip->m_pTexts[nIndex].dHeight;
			m_pTexts[nIndex].dBaseLineOffset = pTextClip->m_pTexts[nIndex].dBaseLineOffset;

			m_pTexts[nIndex].bsFontName      = CString(pTextClip->m_pTexts[nIndex].bsFontName).AllocSysString();
			m_pTexts[nIndex].bsFontPath      = CString(pTextClip->m_pTexts[nIndex].bsFontPath).AllocSysString();
			m_pTexts[nIndex].dFontSize       = pTextClip->m_pTexts[nIndex].dFontSize;
			m_pTexts[nIndex].lFontStyle      = pTextClip->m_pTexts[nIndex].lFontStyle;

			m_pMatrix[nIndex]   = pTextClip->m_pMatrix[nIndex];
		}

	}
	void    Resize(int nTextsCount)
	{
		if ( m_nTextsCount + nTextsCount > m_nSize ) 
		{
			if ( m_nSize == 0 ) 
			{
				m_nSize = 32;
			}
			while ( m_nSize < m_nTextsCount + nTextsCount ) 
			{
				m_nSize *= 2;
			}

			m_pTexts  = (Text   *)MemUtilsReallocArray( m_pTexts,  m_nSize, sizeof(Text));
			m_pMatrix = (Matrix *)MemUtilsReallocArray( m_pMatrix, m_nSize, sizeof(Matrix));
		}
	}
	void    Transform(double *pMatrix, double dX, double dY, double *pdX, double *pdY) 
	{
		*pdX = dX * pMatrix[0] + dY * pMatrix[2] + pMatrix[4];
		*pdY = dX * pMatrix[1] + dY * pMatrix[3] + pMatrix[5];
	}

private:

#pragma pack(push, 1)
	struct Matrix
	{
		double dA;
		double dB;
		double dC;
		double dD;
		double dE;
		double dF;

		double *ToDoublePointer()
		{
			return &dA;
		}

		void FromDoublePointer(double *pMatrix)
		{
			dA = pMatrix[0];
			dB = pMatrix[1];
			dC = pMatrix[2];
			dD = pMatrix[3];
			dE = pMatrix[4];
			dF = pMatrix[5];
		}
		bool IsEqual(Matrix &oMatrix)
		{
			if ( fabs( dA - oMatrix.dA ) < 0.001 && fabs( dB - oMatrix.dB ) < 0.001 && fabs( dC - oMatrix.dC ) < 0.001 && fabs( dD - oMatrix.dD ) < 0.001 && fabs( dE - oMatrix.dE ) < 0.001 && fabs( dF - oMatrix.dF ) < 0.001 )
				return true;

			return false;
		}
	};

	struct Text
	{
		BSTR   bsFontName;
		BSTR   bsFontPath;
		double dFontSize;
		LONG   lFontStyle;

		BSTR   bsText;
		double dX;
		double dY;
		double dWidth;
		double dHeight;
		double dBaseLineOffset;

		bool IsEqual(Text &oText)
		{
			if ( fabs( dX - oText.dX ) < 0.001 && fabs( dY - oText.dY ) < 0.001 && fabs( dWidth - oText.dWidth ) < 0.001 && fabs( dHeight - oText.dHeight ) < 0.001 && fabs( dBaseLineOffset - oText.dBaseLineOffset ) < 0.001 && CString( bsText ) == CString( oText.bsText ) )
				return true;

			return false;
		}
	};

#pragma pack(pop)

private:

	Text           *m_pTexts;
	Matrix         *m_pMatrix;
	int             m_nTextsCount;
	int             m_nSize;
};

//-------------------------------------------------------------------------------------------------------------------------------
// GrClip
//-------------------------------------------------------------------------------------------------------------------------------

#define GrClipEOFlag       0x01	// Èñïîëüçóåì ïðàâèëî Even-odd

class GrClip
{
public:

	GrClip(double dMinX, double dMinY, double dMaxX, double dMaxY);

	GrClip *Copy() 
	{ 
		return new GrClip(this);
	}

	~GrClip();

	void ResetToRect(double dX0, double dY0, double dX1, double dY1);

	// Ïåðåñåêàåì Clip ñ çàäàííûì ïðÿìîóãîëüíèêîì.
	void ClipToRect(double dX0, double dY0, double dX1, double dY1);

	// Ïåðåñåêàåì Clip ñ <pPath>.
	void ClipToPath(GrPath *pPath, double *pMatrix, BOOL bEO);

	// Ïåðåñåêàåì ñ òåêñòîì
	void ClipToText(CString sFontName, CString sFontPath, double dFontSize, LONG lFontStyle, double *pMatrix, CString sText, double dX, double dY, double dWidth, double dHeight, double dBaseLineOffset)
	{
		if ( !m_pTextClip )
			m_pTextClip = new GrTextClip();

		m_pTextClip->ClipToText( sFontName, sFontPath, dFontSize, lFontStyle, pMatrix, sText, dX, dY, dWidth, dHeight, dBaseLineOffset );
	}


	//
	void AppendTextClip(GrTextClip *pTextClip)
	{
		for ( int nIndex = 0; nIndex < pTextClip->GetTextsCount(); nIndex++ )
		{
			BSTR bsFontName, bsFontPath;
			LONG lFontStyle;
			double dFontSize = 10, dX = 0, dY = 0, dWidth = 0, dHeight = 0, dBaseLineOffset = 0;
			BSTR bsText = pTextClip->GetText( nIndex, &dX, &dY, &dWidth, &dHeight, &dBaseLineOffset, &bsFontName, &bsFontPath, &dFontSize, &lFontStyle );
			double *pMatrix = pTextClip->GetMatrix( nIndex );

			ClipToText( (CString)bsFontName, (CString)bsFontPath, dFontSize, lFontStyle, pMatrix, CString( bsText ), dX, dY, dWidth, dHeight, dBaseLineOffset );
		}
	}

	int     GetMinX() 
	{ 
		return m_nMinX; 
	}
	int     GetMaxX() 
	{ 
		return m_nMaxX; 
	}
	int     GetMinY() 
	{ 
		return m_nMinY; 
	}
	int     GetMaxY() 
	{ 
		return m_nMaxY; 
	}

	int     GetPathsCount() 
	{ 
		return m_nPathsCount; 
	}

	GrPath *GetPath(int nPathIndex)
	{
		if ( nPathIndex < 0 || nPathIndex >= m_nPathsCount )
			return NULL;

		return m_ppPaths[nPathIndex];
	}
	double *GetMatrix(int nPathIndex)
	{
		if ( nPathIndex < 0 || nPathIndex >= m_nPathsCount )
			return NULL;

		return m_pMatrix[nPathIndex].ToDoublePointer();
	}
	int     GetFlag(int nPathIndex)
	{
		if ( nPathIndex < 0 || nPathIndex >= m_nPathsCount )
			return NULL;

		return m_pFlags[nPathIndex];
	}	
	BSTR    GetText(int nTextIndex, double *pdX, double *pdY, double *pdWidth, double *pdHeight, double *pdBaseLineOffset, BSTR *pbsFontName, BSTR *pbsFontPath, double *pdFontSize, LONG *plFontStyle)
	{
		if ( m_pTextClip )
		{
			return m_pTextClip->GetText( nTextIndex, pdX, pdY, pdWidth, pdHeight, pdBaseLineOffset, pbsFontName, pbsFontPath, pdFontSize, plFontStyle);
		}
		
		return NULL;
	}
	int     GetTextsCount()
	{
		if ( m_pTextClip )
		{
			return m_pTextClip->GetTextsCount();
		}
		return -1;
	}
	double *GetTextMatrix(int nTextIndex)
	{
		if ( m_pTextClip )
			return m_pTextClip->GetMatrix( nTextIndex );
		
		return NULL;
	}

	bool IsEqual(GrClip *pClip, int &nPathIndex)
	{
		bool bResult = true;
		nPathIndex = -1;

		if ( !m_pTextClip->IsEqual( pClip->m_pTextClip ) )
			return false;

		if ( m_nPathsCount < pClip->m_nPathsCount )
			bResult = false;
		else if ( m_nPathsCount > pClip->m_nPathsCount )
			return false;


		for ( int nIndex = 0; nIndex < m_nPathsCount; nIndex++ )
		{
			if ( !m_pMatrix[nIndex].IsEqual( pClip->m_pMatrix[nIndex] ) || m_pFlags[nIndex] != pClip->m_pFlags[nIndex] || !m_ppPaths[nIndex]->IsEqual( pClip->m_ppPaths[nIndex] ) )
				return false;
		}

		nPathIndex = m_nPathsCount;

		return bResult;
	}

private:

	GrClip(GrClip *pClip);
	void    Resize(int nPathsCount);
	GrPath *PathRect(double dX0, double dY0, double dX1, double dY1);
	void    Transform(double *pMatrix, double dX, double dY, double *pdX, double *pdY) 
	{
		*pdX = dX * pMatrix[0] + dY * pMatrix[2] + pMatrix[4];
		*pdY = dX * pMatrix[1] + dY * pMatrix[3] + pMatrix[5];
	}

private:

#pragma pack(push, 1)
	struct Matrix
	{
		double dA;
		double dB;
		double dC;
		double dD;
		double dE;
		double dF;

		double *ToDoublePointer()
		{
			return &dA;
		}

		void FromDoublePointer(double *pMatrix)
		{
			dA = pMatrix[0];
			dB = pMatrix[1];
			dC = pMatrix[2];
			dD = pMatrix[3];
			dE = pMatrix[4];
			dF = pMatrix[5];
		}

		bool IsEqual(Matrix &oMatrix)
		{
			if ( fabs( dA - oMatrix.dA ) < 0.001 && fabs( dB - oMatrix.dB ) < 0.001 && fabs( dC - oMatrix.dC ) < 0.001 && fabs( dD - oMatrix.dD ) < 0.001 && fabs( dE - oMatrix.dE ) < 0.001 && fabs( dF - oMatrix.dF ) < 0.001 )
				return true;

			return false;
		}

	};
#pragma pack(pop)

private:

	double          m_dMinX;
	double          m_dMinY;
	double          m_dMaxX;
	double          m_dMaxY;

	int             m_nMinX;
	int             m_nMinY;
	int             m_nMaxX;
	int             m_nMaxY;

	GrPath        **m_ppPaths;
	Matrix         *m_pMatrix;
	unsigned char  *m_pFlags;
	int             m_nPathsCount;
	int             m_nSize;

	GrTextClip     *m_pTextClip;
};


//-------------------------------------------------------------------------------------------------------------------------------
// GrState
//-------------------------------------------------------------------------------------------------------------------------------

class GrState 
{
public:

	GrState(double dHorizDPI, double dVertDPI, PDFRectangle *pPageBox, int nRotate, BOOL bUpsideDown);

	~GrState();

	GrState *Copy() 
	{ 
		return new GrState(this); 
	}


	double            GetHorDPI() 
	{ 
		return m_dHorDPI; 
	}
	double            GetVerDPI() 
	{ 
		return m_dVerDPI; 
	}
	double           *GetCTM() 
	{ 
		return m_arrCTM; 
	}
	double            GetPageLeft() 
	{ 
		return m_dPageLeft; 
	}
	double            GetPageBottom() 
	{ 
		return m_dPageBottom; 
	}
	double            GetPageRight() 
	{ 
		return m_dPageRight; 
	}
	double            GetPageTop() 
	{ 
		return m_dPageTop; 
	}
	double            GetPageWidth() 
	{ 
		return m_dPageWidth; 
	}
	double            GetPageHeight() 
	{ 
		return m_dPageHeight; 
	}
	int               GetRotate() 
	{ 
		return m_nRotate; 
	}
	GrColor          *GetFillColor() 
	{ 
		return &m_oFillColor; 
	}
	GrColor          *GetStrokeColor() 
	{ 
		return &m_oStrokeColor; 
	}
	void              GetFillGray(GrGray *pGray)
    { 
		m_pFillColorSpace->GetGray( &m_oFillColor, pGray); 
	}
	void              GetStrokeGray(GrGray *pGray)
    { 
		m_pStrokeColorSpace->GetGray( &m_oStrokeColor, pGray); 
	}
	void              GetFillRGB(GrRGB *pRGB)
    { 
		m_pFillColorSpace->GetRGB( &m_oFillColor, pRGB); 
	}
	void              GetStrokeRGB(GrRGB *pRGB)
    { 
		m_pStrokeColorSpace->GetRGB( &m_oStrokeColor, pRGB); 
	}
	void              GetFillCMYK(GrCMYK *pCMYK)
    { 
		m_pFillColorSpace->GetCMYK( &m_oFillColor, pCMYK); 
	}
	void              GetStrokeCMYK(GrCMYK *pCMYK)
    { 
		m_pStrokeColorSpace->GetCMYK( &m_oStrokeColor, pCMYK); 
	}
	GrColorSpace     *GetFillColorSpace() 
	{ 
		return m_pFillColorSpace; 
	}
	GrColorSpace     *GetStrokeColorSpace() 
	{ 
		return m_pStrokeColorSpace; 
	}
	GrPattern        *GetFillPattern() 
	{ 
		return m_pFillPattern; 
	}
	GrPattern        *GetStrokePattern() 
	{ 
		return m_pStrokePattern; 
	}
	GraphicsBlendMode GetBlendMode() 
	{ 
		return m_eBlendMode; 
	}
	double            GetFillOpacity() 
	{ 
		return m_dFillOpacity; 
	}
	double            GetStrokeOpacity() 
	{ 
		return m_dStrokeOpacity; 
	}
	BOOL              GetFillOverprint() 
	{ 
		return m_bFillOverprint; 
	}
	BOOL              GetStrokeOverprint() 
	{ 
		return m_bStrokeOverprint; 
	}
	Function        **GetTransfer() 
	{ 
		return m_ppTransfer; 
	}
	double            GetLineWidth() 
	{ 
		return m_dLineWidth; 
	}
	void              GetLineDash(double **ppDash, int *pSize, double *pStart)
    { 
		*ppDash = m_pLineDash; 
		*pSize  = m_nLineDashSize; 
		*pStart = m_dLineDashStart; 
	}
	int               GetFlatness() 
	{ 
		return m_nFlatness; 
	}
	int               GetLineJoin() 
	{ 
		return m_nLineJoin; 
	}
	int               GetLineCap() 
	{ 
		return m_nLineCap; 
	}
	double            GetMiterLimit() 
	{ 
		return m_dMiterLimit; 
	}
	BOOL              GetStrokeAdjust() 
	{ 
		return m_bStrokeAdjust; 
	}
	GrFont           *GetFont() 
	{ 
		return m_pFont; 
	}
	double            GetFontSize() 
	{ 
		return m_dFontSize; 
	}
	double           *GetTextMatrix() 
	{ 
		return m_arrTextMatrix; 
	}
	double            GetCharSpace() 
	{ 
		return m_dCharSpace; 
	}
	double            GetWordSpace() 
	{ 
		return m_dWordSpace; 
	}
	double            GetHorizScaling() 
	{ 
		return m_dHorizScaling; 
	}
	double            GetLeading() 
	{ 
		return m_dLeading; 
	}
	double            GetRise() 
	{ 
		return m_nRise; 
	}
	int               GetRenderMode() 
	{ 
		return m_nRenderMode; 
	}
	GrPath           *GetPath() 
	{ 
		return m_pPath; 
	}
	double            GetCurX() 
	{ 
		return m_dCurX; 
	}
	double            GetCurY() 
	{ 
		return m_dCurY; 
	}
	void              GetClipBBox(double *pXMin, double *pYMin, double *pXMax, double *pYMax)
    { 
		*pXMin = m_dClipXMin; 
		*pYMin = m_dClipYMin; 
		*pXMax = m_dClipXMax; 
		*pYMax = m_dClipYMax; 
	}
	void              GetUserClipBBox(double *pXMin, double *pYMin, double *pXMax, double *pYMax);
	double            GetTextLineX() 
	{ 
		return m_dTextLineX; 
	}
	double            GetTextLineY() 
	{ 
		return m_dTextLineY; 
	}

	GrClip           *GetClip()
	{
		return m_pClip;
	}
	// Åñòü ëè òåêóùàÿ òî÷êà?
	BOOL IsCurPoint() 
	{ 
		return m_pPath->IsCurPoint(); 
	}
	// Åñòü ëè íåïóñòîé path?
	BOOL IsPathNonEmpty() 
	{ 
		return m_pPath->IsPathNonEmpty(); 
	}

	// Ðàçëè÷íûå ïðåîáðàçîâàíèÿ êîîðäèíàò.
	void   Transform(double dSrcX, double dSrcY, double *pdResX, double *pdResY)
    { 
		*pdResX = m_arrCTM[0] * dSrcX + m_arrCTM[2] * dSrcY + m_arrCTM[4];
		*pdResY = m_arrCTM[1] * dSrcX + m_arrCTM[3] * dSrcY + m_arrCTM[5]; 
	}
	void   TransformDelta(double dSrcX, double dSrcY, double *pdResX, double *pdResY)
    { 
		*pdResX = m_arrCTM[0] * dSrcX + m_arrCTM[2] * dSrcY;
		*pdResY = m_arrCTM[1] * dSrcX + m_arrCTM[3] * dSrcY; 
	}
	void   TextTransform(double dSrcX, double dSrcY, double *pdResX, double *pdResY)
    { 
		*pdResX = m_arrTextMatrix[0] * dSrcX + m_arrTextMatrix[2] * dSrcY + m_arrTextMatrix[4];
		*pdResY = m_arrTextMatrix[1] * dSrcX + m_arrTextMatrix[3] * dSrcY + m_arrTextMatrix[5]; 
	}
	void   TextTransformDelta(double dSrcX, double dSrcY, double *pdResX, double *pdResY)
    { 
		*pdResX = m_arrTextMatrix[0] * dSrcX + m_arrTextMatrix[2] * dSrcY;
		*pdResY = m_arrTextMatrix[1] * dSrcX + m_arrTextMatrix[3] * dSrcY; 
	}
	double TransformWidth(double dWidth);
	double GetTransformedLineWidth()
    { 
		return TransformWidth(m_dLineWidth); 
	}
	double GetTransformedFontSize();
	void   GetFontTransformMatrix(double *pdM11, double *pdM12, double *pdM21, double *pdM22);

	void SetCTM(double dA, double dB, double dC, double dD, double dE, double dF);
	void ConcatCTM(double dA, double dB, double dC, double dD, double dE, double dF);
	void ShiftCTM(double dShiftX, double dShiftY);
	void SetFillColorSpace(GrColorSpace *pColorSpace);
	void SetStrokeColorSpace(GrColorSpace *pColorSpace);
	void SetFillColor(GrColor *pColor) 
	{ 
		m_oFillColor = *pColor; 
	}
	void SetStrokeColor(GrColor *pColor) 
	{ 
		m_oStrokeColor = *pColor; 
	}
	void SetFillPattern(GrPattern *pPattern);
	void SetStrokePattern(GrPattern *pPattern);
	void SetBlendMode(GraphicsBlendMode eMode) 
	{ 
		m_eBlendMode = eMode; 
	}
	void SetFillOpacity(double dOpacity) 
	{ 
		m_dFillOpacity = dOpacity; 
	}
	void SetStrokeOpacity(double dOpacity)
	{ 
		m_dStrokeOpacity = dOpacity; 
	}
	void SetFillOverprint(BOOL bOverprint) 
	{ 
		m_bFillOverprint = bOverprint; 
	}
	void SetStrokeOverprint(BOOL bOverprint) 
	{ 
		m_bStrokeOverprint = bOverprint; 
	}
	void SetTransfer(Function **ppFunctions);
	void SetLineWidth(double dWidth) 
	{
		m_dLineWidth = dWidth; 
	}
	void SetLineDash(double *pDash, int nLength, double dStart);
	void SetFlatness(int nFlatness) 
	{ 
		m_nFlatness = nFlatness; 
	}
	void SetLineJoin(int nLineJoin) 
	{ 
		m_nLineJoin = nLineJoin; 
	}
	void SetLineCap(int nLineCap) 
	{ 
		m_nLineCap = nLineCap; 
	}
	void SetMiterLimit(double dMiterLimit) 
	{ 
		m_dMiterLimit = dMiterLimit; 
	}
	void SetStrokeAdjust(BOOL bStrokeAdjust) 
	{
		m_bStrokeAdjust = bStrokeAdjust; 
	}
	void SetFont(GrFont *pFont, double dFontSize)
    { 
		m_pFont = pFont; 
		m_dFontSize = dFontSize; 
	}
	void SetTextMatrix(double dA, double dB, double dC, double dD, double dE, double dF)
    { 
		m_arrTextMatrix[0] = dA; 
		m_arrTextMatrix[1] = dB; 
		m_arrTextMatrix[2] = dC;
		m_arrTextMatrix[3] = dD; 
		m_arrTextMatrix[4] = dE; 
		m_arrTextMatrix[5] = dF; 
	}
	void SetCharSpace(double dCharSpace)
	{ 
		m_dCharSpace = dCharSpace; 
	}
	void SetWordSpace(double dWordSpace)
    { 
		m_dWordSpace = dWordSpace; 
	}
	void SetHorizScaling(double dScale)
    { 
		m_dHorizScaling = 0.01 * dScale; 
	}
	void SetLeading(double dLeading)
    { 
		m_dLeading = dLeading; 
	}
	void SetRise(double dRise)
    { 
		m_nRise = dRise; 
	}
	void SetRenderMode(int nRenderMode)
    { 
		m_nRenderMode = nRenderMode; 
	}
	void SetPath(GrPath *pPath);
	void MoveTo(double dX, double dY)
    { 
		m_pPath->MoveTo( m_dCurX = dX, m_dCurY = dY); 
	}
	void LineTo(double dX, double dY)
    { 
		m_pPath->LineTo( m_dCurX = dX, m_dCurY = dY); 
	}
	void CurveTo(double dX1, double dY1, double dX2, double dY2, double dX3, double dY3)
    { 
		m_pPath->CurveTo( dX1, dY1, dX2, dY2, m_dCurX = dX3, m_dCurY = dY3); 
	}
	void ClosePath() 
    {
		m_pPath->Close(); 
		m_dCurX = m_pPath->GetLastX(); 
		m_dCurY = m_pPath->GetLastY(); 
	}
	void ClearPath();
	void Clip();
	void ClipToStrokePath();

	// Òåêñò.
	void TextSetPos(double dX, double dY) 
	{ 
		m_dTextLineX = dX; 
		m_dTextLineY = dY; 
	}
	void TextMoveTo(double dX, double dY)
    { 
		m_dTextLineX = dX; 
		m_dTextLineY = dY; 
		TextTransform( dX, dY, &m_dCurX, &m_dCurY);
	}
	void TextShift(double dShiftX, double dShiftY);
	void Shift(double dShidtX, double dShiftY);

	// Ðàáîòà ñî ñòåêîì.
	GrState *Save();
	GrState *Restore();
	BOOL HasSaves() 
	{ 
		return m_pNext != NULL; 
	}

	// 
	BOOL ParseBlendMode(Object *pObject, GraphicsBlendMode *peMode);

private:

	GrState(GrState *pState);

private:

	double m_dHorDPI;      // Ðàçðåøåíèå ïî ãîðèçîíòàëè
	double m_dVerDPI;      // Ðàçðåøåíèå ïî âåðòèêàëè
	double m_arrCTM[6];    // Ìàòðèöà ïðåîáðàçîâàíèÿ êîîðäèíàò

	double m_dPageLeft;    // Êîîðäèíàòû ëåâîãî íèæíåãî óãëà è
	double m_dPageBottom;  // ïðàâîãî âåðõíåãî â ïîëüçîâàòåëüñòêèõ êîîðäèíàòàõ
	double m_dPageRight;   //
	double m_dPageTop;     // 

	double m_dPageWidth;   // Øèðèíà ñòðàíèöû â ïèêñåëÿõ(ò.å. ñ ó÷åòîì ðàçðåøåíèÿ m_dHorDPI)
	double m_dPageHeight;  // Âûñîòà ñòðàíèöû â ïèêñåëÿõ(ò.å. ñ ó÷åòîì ðàçðåøåíèÿ m_dVerDPI)

	int    m_nRotate;      // Óãîë ïîâîðîòà ñòðàíèöû

	GrColorSpace     *m_pFillColorSpace;  // Öâåòîâîå ïðîñòðàíñòâî äëÿ çàëèâêè
	GrColorSpace     *m_pStrokeColorSpace;// Öâåòîâîå ïðîñòðàíñòâî äëÿ îáâîäêè
	GrColor           m_oFillColor;       // Öâåò äëÿ çàëèâêè
	GrColor           m_oStrokeColor;     // Öâåò äëÿ îáâîäêè
	GrPattern        *m_pFillPattern;     // Óêàçàòåëü íà îáúåêò, îïðåäåëÿþùèé çàëèâêó
	GrPattern        *m_pStrokePattern;   // Óêàçàòåëü íà îáúåêò, îïðåäåëÿþùèé îáâîäêó
	
	GraphicsBlendMode m_eBlendMode;	      // Blend mode (äëÿ ïðîçðà÷íîñòè)
	
	double            m_dFillOpacity;     // Ïðîçðà÷íîñòü çàëèâêè
	double            m_dStrokeOpacity;   // Ïðîçðà÷íîñòü îáâîäêè

	BOOL              m_bFillOverprint;   // Çàëèâàåì ïîâåðõ âñåãî?
	BOOL              m_bStrokeOverprint; // Îáâîäèì ïîâåðõ âñåãî?
	Function         *m_ppTransfer[4];	  // Ôóíêöèÿ ïåðåíîñà. Âàðèàíòû âõîäíûõ ïàðàìåòðîâ:
	                                      // âñå NULL = òîæäåñòâííàÿ ôóíêöèÿ;
	                                      // ïîñëåäíèå òðè NULL = îäíîìåðíàÿ ôóíêöèÿ;
	                                      // âñå 4 íå NULL = R,G,B,gray -ôóíêöèÿ

	double  m_dLineWidth;    // Òîëùèíà ëèíèè
	double *m_pLineDash;     // Ïàðàìåòðû, åñëè ëèíèÿ ïóíêòèðíàÿ
	int     m_nLineDashSize; // Ðàçìåð ìàññèâà m_pLineDash
	double  m_dLineDashStart;//
	int     m_nFlatness;     // Flatness Tolerance
	int     m_nLineJoin;     // Òèï ñîåäèíåíèÿ ëèíèé
	int     m_nLineCap;      // Òèï îêîíà÷íèÿ ëèíèé
	double  m_dMiterLimit;   // Miter limit
	BOOL    m_bStrokeAdjust; // True, àâòîìàòè÷åñêè îáâîäèòü

	GrFont *m_pFont;            // Øðèôò
	double  m_dFontSize;        // Ðàçìåð øðèôòà
	double  m_arrTextMatrix[6]; // Ìàòðèöà êîîðäèíàòíûõ ïðåîáðàçîâàíèé òåêñòà
	double  m_dCharSpace;       // Ðàññòîÿíèå ìåæäó ñèìâîëàìè
	double  m_dWordSpace;       // Ðàññòîÿíèå ìåæäó ñëîâàìè
	double  m_dHorizScaling;    // Ãîðèçîíòàëüíîå ðàñòÿæåíèå òåêñòà
	double  m_dLeading;         // Ðàññòîÿíèå ìåæäó ñòðîêàìè
	double  m_nRise;            // Ïîäíÿòèå/îïóñêàíèå òåêñòà îòíîñèòåëüíî baseline
	int     m_nRenderMode;      // Ñïîñîá ðèñîâàíèÿ áóêâ

	GrPath *m_pPath;            // Ìàññèâ ãðàôè÷åñêèõ Path
	double  m_dCurX;            // Êîîðäèíàòû òåêóùåé òî÷êè
	double  m_dCurY;            // (â ïîëüçîâàòåëüñêèõ êîîðäèíàòàõ)
	double  m_dTextLineX;       // Êîîðäèíàòû íà÷àëüíîé òî÷êè, íà÷èíàÿ ñ êîòîðîé ïèøåòñÿ òåêñò
	double  m_dTextLineY;       // (â òåêñòîâûõ êîîðäèíàòàõ)

	GrClip *m_pClip;
	double  m_dClipXMin;    //
	double  m_dClipYMin;    // Ãðàíèöû äëÿ clip region
	double  m_dClipXMax;    //
	double  m_dClipYMax;    //

	GrState *m_pNext;       // Ñëåäóþùèé GrState â ñòýêå
};

#endif /* _GSTATE_H */