Yajbir Singh
1903 lines
51 KiB
C++
1903 lines
51 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
#ifndef _PDF_WRITER_SRC_STATE_H
|
|
#define _PDF_WRITER_SRC_STATE_H
|
|
|
|
#include "../../DesktopEditor/common/Types.h"
|
|
#include "../../DesktopEditor/graphics/AggPlusEnums.h"
|
|
#include "../../DesktopEditor/graphics/GraphicsPath.h"
|
|
#include "Types.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
|
|
namespace PdfWriter
|
|
{
|
|
class CPage;
|
|
class CFontDict;
|
|
class CShading;
|
|
class CExtGrState;
|
|
}
|
|
|
|
class CPdfWriter;
|
|
|
|
enum ERendererCommandType
|
|
{
|
|
renderercommandtype_Text = 0x01,
|
|
renderercommandtype_Image = 0x02,
|
|
renderercommandtype_Path = 0x03,
|
|
renderercommandtype_Clip = 0x04
|
|
};
|
|
class CRendererCommandBase
|
|
{
|
|
public:
|
|
virtual ~CRendererCommandBase(){};
|
|
virtual ERendererCommandType GetType() = 0;
|
|
};
|
|
class CRendererTextCommand : public CRendererCommandBase
|
|
{
|
|
public:
|
|
CRendererTextCommand(unsigned char* pCodes, unsigned int nLen, const double& dX, const double& dY)
|
|
{
|
|
m_pCodes = pCodes;
|
|
m_nLen = nLen;
|
|
m_dX = dX;
|
|
m_dY = dY;
|
|
m_pFont = NULL;
|
|
m_dSize = -1;
|
|
m_nType = PdfWriter::EFontType::fontUnknownType;
|
|
m_lColor = 0;
|
|
m_nAlpha = 255;
|
|
m_dCharSpace = 0;
|
|
m_dHorScaling = 100;
|
|
m_nMode = (int)PdfWriter::textrenderingmode_Fill;
|
|
m_dRise = 0;
|
|
m_dWordSpace = 0;
|
|
m_dWidth = -1;
|
|
|
|
m_bNeedDoItalic = false;
|
|
m_bNeedDoBold = false;
|
|
}
|
|
~CRendererTextCommand()
|
|
{
|
|
if (m_pCodes)
|
|
delete[] m_pCodes;
|
|
}
|
|
ERendererCommandType GetType()
|
|
{
|
|
return renderercommandtype_Text;
|
|
}
|
|
|
|
inline double GetX() const
|
|
{
|
|
return m_dX;
|
|
}
|
|
inline double GetY() const
|
|
{
|
|
return m_dY;
|
|
}
|
|
inline unsigned char* GetCodes() const
|
|
{
|
|
return m_pCodes;
|
|
}
|
|
inline unsigned int GetCodesLen() const
|
|
{
|
|
return m_nLen;
|
|
}
|
|
inline void SetFont(PdfWriter::CFontDict* pFont)
|
|
{
|
|
m_pFont = pFont;
|
|
}
|
|
inline void SetSize(const double& dSize)
|
|
{
|
|
m_dSize = dSize;
|
|
}
|
|
inline void SetType(PdfWriter::EFontType oType)
|
|
{
|
|
m_nType = oType;
|
|
}
|
|
inline void SetColor(const LONG& lColor)
|
|
{
|
|
m_lColor = lColor;
|
|
}
|
|
inline void SetAlpha(const BYTE& nAlpha)
|
|
{
|
|
m_nAlpha = nAlpha;
|
|
}
|
|
inline void SetCharSpace(const double& dCharSpace)
|
|
{
|
|
m_dCharSpace = dCharSpace;
|
|
}
|
|
inline void SetHorScaling(const double& dKoef)
|
|
{
|
|
m_dHorScaling = dKoef;
|
|
}
|
|
inline void SetMode(const int& nMode)
|
|
{
|
|
m_nMode = nMode;
|
|
}
|
|
inline void SetNeedDoItalic(const bool& bItalic)
|
|
{
|
|
m_bNeedDoItalic = bItalic;
|
|
}
|
|
inline void SetNeedDoBold(const bool& bBold)
|
|
{
|
|
m_bNeedDoBold = bBold;
|
|
}
|
|
inline void SetPUA(const std::string& sPUA)
|
|
{
|
|
m_sPUA = sPUA;
|
|
}
|
|
inline void SetRise(const double& dRise)
|
|
{
|
|
m_dRise = dRise;
|
|
}
|
|
inline void SetWordSpace(const double& dWordSpace)
|
|
{
|
|
m_dWordSpace = dWordSpace;
|
|
}
|
|
inline void SetName(const std::wstring& sName)
|
|
{
|
|
m_sName = sName;
|
|
}
|
|
inline void SetWidth(const double& dWidth)
|
|
{
|
|
m_dWidth = dWidth;
|
|
}
|
|
inline PdfWriter::CFontDict* GetFont() const
|
|
{
|
|
return m_pFont;
|
|
}
|
|
inline double GetSize() const
|
|
{
|
|
return m_dSize;
|
|
}
|
|
inline PdfWriter::EFontType GetFontType() const
|
|
{
|
|
return m_nType;
|
|
}
|
|
inline LONG GetColor() const
|
|
{
|
|
return m_lColor;
|
|
}
|
|
inline BYTE GetAlpha() const
|
|
{
|
|
return m_nAlpha;
|
|
}
|
|
inline double GetSpace() const
|
|
{
|
|
return m_dCharSpace;
|
|
}
|
|
inline double GetHorScaling() const
|
|
{
|
|
return m_dHorScaling;
|
|
}
|
|
inline int GetMode() const
|
|
{
|
|
return m_nMode;
|
|
}
|
|
inline bool IsNeedDoItalic() const
|
|
{
|
|
return m_bNeedDoItalic;
|
|
}
|
|
inline bool IsNeedDoBold() const
|
|
{
|
|
return m_bNeedDoBold;
|
|
}
|
|
inline std::string GetPUA() const
|
|
{
|
|
return m_sPUA;
|
|
}
|
|
inline double GetRise()
|
|
{
|
|
return m_dRise;
|
|
}
|
|
inline double GetWordSpace()
|
|
{
|
|
return m_dWordSpace;
|
|
}
|
|
inline std::wstring GetName()
|
|
{
|
|
return m_sName;
|
|
}
|
|
inline double GetWidth()
|
|
{
|
|
return m_dWidth;
|
|
}
|
|
|
|
private:
|
|
|
|
unsigned char* m_pCodes;
|
|
unsigned int m_nLen;
|
|
double m_dX;
|
|
double m_dY;
|
|
|
|
PdfWriter::CFontDict* m_pFont;
|
|
bool m_bNeedDoItalic;
|
|
bool m_bNeedDoBold;
|
|
double m_dSize;
|
|
PdfWriter::EFontType m_nType;
|
|
LONG m_lColor;
|
|
BYTE m_nAlpha;
|
|
double m_dCharSpace;
|
|
int m_nMode;
|
|
double m_dHorScaling;
|
|
std::string m_sPUA;
|
|
double m_dRise;
|
|
double m_dWordSpace;
|
|
std::wstring m_sName;
|
|
double m_dWidth;
|
|
};
|
|
struct TFontInfo
|
|
{
|
|
TFontInfo(const std::wstring& fontName, const bool& bold, const bool& italic, const std::wstring& fontPath, const LONG& faceIndex)
|
|
{
|
|
wsFontName = fontName;
|
|
bBold = bold;
|
|
bItalic = italic;
|
|
wsFontPath = fontPath;
|
|
lFaceIndex = faceIndex;
|
|
}
|
|
|
|
std::wstring wsFontName;
|
|
bool bBold;
|
|
bool bItalic;
|
|
std::wstring wsFontPath;
|
|
LONG lFaceIndex;
|
|
};
|
|
struct TColor
|
|
{
|
|
TColor()
|
|
{
|
|
lColor = 0;
|
|
r = 0;
|
|
g = 0;
|
|
b = 0;
|
|
a = 255;
|
|
}
|
|
TColor(const LONG& _lColor)
|
|
{
|
|
Set(_lColor);
|
|
}
|
|
|
|
void Set(const LONG& _lColor)
|
|
{
|
|
lColor = _lColor;
|
|
|
|
r = (unsigned char)(lColor & 0xFF);
|
|
g = (unsigned char)((lColor >> 8) & 0xFF);
|
|
b = (unsigned char)((lColor >> 16) & 0xFF);
|
|
a = (unsigned char)((lColor >> 24) & 0xFF);
|
|
}
|
|
void operator=(const LONG& _lColor)
|
|
{
|
|
Set(_lColor);
|
|
}
|
|
void Set(BYTE _r, BYTE _g, BYTE _b, BYTE _a = 255)
|
|
{
|
|
r = _r;
|
|
g = _g;
|
|
b = _b;
|
|
a = _a;
|
|
|
|
lColor = (LONG)(((LONG)r) | ((LONG)g << 8) | ((LONG)b << 16) | ((LONG)a << 24));
|
|
}
|
|
|
|
LONG lColor;
|
|
BYTE r;
|
|
BYTE g;
|
|
BYTE b;
|
|
BYTE a;
|
|
};
|
|
class CPenState
|
|
{
|
|
public:
|
|
|
|
CPenState()
|
|
{
|
|
m_pDashPattern = NULL;
|
|
Reset();
|
|
}
|
|
~CPenState()
|
|
{
|
|
if (m_pDashPattern)
|
|
delete[] m_pDashPattern;
|
|
}
|
|
inline LONG GetColor()
|
|
{
|
|
return m_oColor.lColor;
|
|
}
|
|
inline void SetColor(const LONG& lColor)
|
|
{
|
|
m_oColor.Set(lColor);
|
|
}
|
|
inline TColor GetTColor()
|
|
{
|
|
return m_oColor;
|
|
}
|
|
inline LONG GetAlpha()
|
|
{
|
|
return m_nAlpha;
|
|
}
|
|
inline void SetAlpha(const LONG& lAlpha)
|
|
{
|
|
m_nAlpha = (BYTE)(std::max)(0, (std::min)(255, (int)lAlpha));
|
|
}
|
|
inline double GetSize()
|
|
{
|
|
return m_dSize;
|
|
}
|
|
inline void SetSize(const double& dSize)
|
|
{
|
|
m_dSize = dSize;
|
|
}
|
|
inline BYTE GetDashStyle()
|
|
{
|
|
return m_nDashStyle;
|
|
}
|
|
inline void SetDashStyle(const BYTE& nDashStyle)
|
|
{
|
|
m_nDashStyle = nDashStyle;
|
|
}
|
|
inline BYTE GetStartCapStyle()
|
|
{
|
|
return m_nStartCapStyle;
|
|
}
|
|
inline void SetStartCapStyle(const BYTE& nCapStyle)
|
|
{
|
|
m_nStartCapStyle = nCapStyle;
|
|
}
|
|
inline BYTE GetEndCapStyle()
|
|
{
|
|
return m_nEndCapStyle;
|
|
}
|
|
inline void SetEndCapStyle(const BYTE& nCapStyle)
|
|
{
|
|
m_nEndCapStyle = nCapStyle;
|
|
}
|
|
inline BYTE GetJoinStyle()
|
|
{
|
|
return m_nJoinStyle;
|
|
}
|
|
inline void SetJoinStyle(const BYTE& nJoinStyle)
|
|
{
|
|
m_nJoinStyle = nJoinStyle;
|
|
}
|
|
inline double GetDashOffset()
|
|
{
|
|
return m_dDashOffset;
|
|
}
|
|
inline void SetDashOffset(const double& dOffset)
|
|
{
|
|
m_dDashOffset = dOffset;
|
|
}
|
|
inline LONG GetAlign()
|
|
{
|
|
return m_lAlign;
|
|
}
|
|
inline void SetAlign(const LONG& lAlign)
|
|
{
|
|
m_lAlign = lAlign;
|
|
}
|
|
inline double GetMiter()
|
|
{
|
|
return m_dMiter;
|
|
}
|
|
inline void SetMiter(const double& dMiter)
|
|
{
|
|
m_dMiter = dMiter;
|
|
}
|
|
inline void SetDashPattern(const double* pPattern, const LONG& lSize)
|
|
{
|
|
if (m_pDashPattern)
|
|
{
|
|
delete[] m_pDashPattern;
|
|
m_pDashPattern = NULL;
|
|
}
|
|
|
|
m_lDashPatternSize = 0;
|
|
|
|
if (!pPattern || !lSize)
|
|
{
|
|
m_lDashPatternSize = 0;
|
|
m_pDashPattern = NULL;
|
|
}
|
|
else
|
|
{
|
|
// Избавляемся от нулей, потому что все pdf-ридеры плохо их воспринимают
|
|
std::vector<double> vPattern;
|
|
for (LONG lIndex = 0; lIndex < lSize; lIndex++)
|
|
{
|
|
if (lIndex > 1 && fabs(pPattern[lIndex]) < 0.001)
|
|
{
|
|
if (0 == lIndex % 2)
|
|
{
|
|
if (fabs(pPattern[lIndex + 1]) < 0.001)
|
|
{
|
|
lIndex++;
|
|
}
|
|
else if (lIndex + 1 < lSize)
|
|
{
|
|
size_t nPatternSize = vPattern.size();
|
|
vPattern.at(nPatternSize - 1) = vPattern.at(nPatternSize - 1) + pPattern[lIndex + 1];
|
|
lIndex++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
size_t nPatternSize = vPattern.size();
|
|
vPattern.at(nPatternSize - 2) = vPattern.at(nPatternSize - 2) + vPattern.at(nPatternSize - 1);
|
|
vPattern.pop_back();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vPattern.push_back(pPattern[lIndex]);
|
|
}
|
|
}
|
|
|
|
size_t nPatternSize = vPattern.size();
|
|
if (nPatternSize > 0)
|
|
{
|
|
m_pDashPattern = new double[nPatternSize];
|
|
if (m_pDashPattern)
|
|
{
|
|
for (int nIndex = 0; nIndex < nPatternSize; nIndex++)
|
|
{
|
|
m_pDashPattern[nIndex] = vPattern.at(nIndex);
|
|
}
|
|
m_lDashPatternSize = nPatternSize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
inline double* GetDashPattern(LONG& lSize)
|
|
{
|
|
lSize = m_lDashPatternSize;
|
|
return m_pDashPattern;
|
|
}
|
|
inline double GetFlatness()
|
|
{
|
|
return m_dFlatness;
|
|
}
|
|
inline void SetFlatness(const double& dF)
|
|
{
|
|
m_dFlatness = dF;
|
|
}
|
|
inline double* GetDColor2(int& nSize)
|
|
{
|
|
nSize = m_nColor2Size;
|
|
return m_dColor2;
|
|
}
|
|
inline void SetDColor2(int nSize, double d1 = 0, double d2 = 0, double d3 = 0, double d4 = 0)
|
|
{
|
|
m_nColor2Size = nSize;
|
|
m_dColor2[0] = d1;
|
|
m_dColor2[1] = d2;
|
|
m_dColor2[2] = d3;
|
|
m_dColor2[3] = d4;
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
if (m_pDashPattern)
|
|
delete[] m_pDashPattern;
|
|
|
|
m_oColor.Set(0);
|
|
m_dSize = 0;
|
|
m_nAlpha = 255;
|
|
m_nStartCapStyle = Aggplus::LineCapFlat;
|
|
m_nEndCapStyle = Aggplus::LineCapFlat;
|
|
m_nJoinStyle = Aggplus::LineJoinMiter;
|
|
|
|
m_lAlign = 0;
|
|
m_dMiter = 3.527778;
|
|
m_dFlatness = 0;
|
|
|
|
m_nDashStyle = Aggplus::DashStyleSolid;
|
|
m_lDashPatternSize = 0;
|
|
m_pDashPattern = NULL;
|
|
m_dDashOffset = 0;
|
|
|
|
m_nColor2Size = 0;
|
|
}
|
|
|
|
private:
|
|
|
|
double m_dSize;
|
|
TColor m_oColor;
|
|
BYTE m_nAlpha;
|
|
BYTE m_nStartCapStyle;
|
|
BYTE m_nEndCapStyle;
|
|
BYTE m_nJoinStyle;
|
|
|
|
LONG m_lAlign;
|
|
double m_dMiter;
|
|
double m_dFlatness;
|
|
|
|
BYTE m_nDashStyle;
|
|
double m_dDashOffset;
|
|
double*m_pDashPattern;
|
|
LONG m_lDashPatternSize;
|
|
|
|
double m_dColor2[4];
|
|
int m_nColor2Size;
|
|
};
|
|
class CBrushState
|
|
{
|
|
public:
|
|
struct TColorAndPoint
|
|
{
|
|
TColorAndPoint()
|
|
{
|
|
lColor = 0;
|
|
dPoint = 0;
|
|
bUse = false;
|
|
}
|
|
TColorAndPoint(const LONG& color, const double& point)
|
|
{
|
|
lColor = color;
|
|
dPoint = point;
|
|
bUse = true;
|
|
}
|
|
|
|
static bool Compare(const TColorAndPoint& oFirst, const TColorAndPoint& oSecond)
|
|
{
|
|
return (oFirst.dPoint < oSecond.dPoint);
|
|
}
|
|
static LONG GetLinearApprox(const TColorAndPoint& oPoint1, const TColorAndPoint& oPoint2, const double& dDstPoint)
|
|
{
|
|
double dPoint1 = oPoint1.dPoint;
|
|
double dPoint2 = oPoint2.dPoint;
|
|
LONG lColor1 = oPoint1.lColor;
|
|
LONG lColor2 = oPoint2.lColor;
|
|
|
|
double dDiff = dPoint2 - dPoint1;
|
|
if (fabs(dDiff) < 0)
|
|
return lColor1;
|
|
|
|
TColor oColor1 = lColor1;
|
|
TColor oColor2 = lColor2;
|
|
|
|
BYTE r = (BYTE)(std::max)(0, (std::min)(255, (int)(oColor1.r + (oColor2.r - oColor1.r) / dDiff * (dDstPoint - dPoint1))));
|
|
BYTE g = (BYTE)(std::max)(0, (std::min)(255, (int)(oColor1.g + (oColor2.g - oColor1.g) / dDiff * (dDstPoint - dPoint1))));
|
|
BYTE b = (BYTE)(std::max)(0, (std::min)(255, (int)(oColor1.b + (oColor2.b - oColor1.b) / dDiff * (dDstPoint - dPoint1))));
|
|
BYTE a = (BYTE)(std::max)(0, (std::min)(255, (int)(oColor1.a + (oColor2.a - oColor1.a) / dDiff * (dDstPoint - dPoint1))));
|
|
|
|
TColor oResColor;
|
|
oResColor.Set(r, g, b, a);
|
|
return oResColor.lColor;
|
|
}
|
|
|
|
LONG lColor;
|
|
double dPoint;
|
|
bool bUse;
|
|
};
|
|
struct TBrushRect
|
|
{
|
|
TBrushRect()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
bUse = false;
|
|
nVal = 0;
|
|
dLeft = 0;
|
|
dTop = 0;
|
|
dWidth = 0;
|
|
dHeight = 0;
|
|
}
|
|
|
|
bool bUse;
|
|
int nVal;
|
|
double dLeft;
|
|
double dTop;
|
|
double dWidth;
|
|
double dHeight;
|
|
};
|
|
|
|
public:
|
|
CBrushState()
|
|
{
|
|
m_pShadingColors = NULL;
|
|
m_pShadingPoints = NULL;
|
|
m_lShadingPointsCount = 0;
|
|
Reset();
|
|
}
|
|
~CBrushState()
|
|
{
|
|
if (m_pShadingColors)
|
|
delete[] m_pShadingColors;
|
|
if (m_pShadingPoints)
|
|
delete[] m_pShadingPoints;
|
|
}
|
|
void Reset();
|
|
inline LONG GetType()
|
|
{
|
|
return m_lType;
|
|
}
|
|
inline void SetType(const LONG& lType)
|
|
{
|
|
m_lType = lType;
|
|
}
|
|
inline LONG GetColor1()
|
|
{
|
|
return m_oColor1.lColor;
|
|
}
|
|
inline TColor GetTColor1()
|
|
{
|
|
return m_oColor1;
|
|
}
|
|
inline void SetColor1(const LONG& lColor)
|
|
{
|
|
m_oColor1.Set(lColor);
|
|
}
|
|
inline LONG GetColor2()
|
|
{
|
|
return m_oColor2.lColor;
|
|
}
|
|
inline TColor GetTColor2()
|
|
{
|
|
return m_oColor2;
|
|
}
|
|
inline void SetColor2(const LONG& lColor)
|
|
{
|
|
m_oColor2.Set(lColor);
|
|
}
|
|
inline LONG GetAlpha1()
|
|
{
|
|
return m_nAlpha1;
|
|
}
|
|
inline void SetAlpha1(const LONG& lAlpha)
|
|
{
|
|
m_nAlpha1 = (BYTE)(std::max)(0, (std::min)(255, (int)lAlpha));
|
|
}
|
|
inline LONG GetAlpha2()
|
|
{
|
|
return m_nAlpha2;
|
|
}
|
|
inline void SetAlpha2(const LONG& lAlpha)
|
|
{
|
|
m_nAlpha2 = (BYTE)(std::max)(0, (std::min)(255, (int)lAlpha));
|
|
}
|
|
inline std::wstring GetTexturePath()
|
|
{
|
|
return m_wsTexturePath;
|
|
}
|
|
inline void SetTexturePath(const std::wstring& wsPath)
|
|
{
|
|
m_wsTexturePath = wsPath;
|
|
}
|
|
inline LONG GetTextureMode()
|
|
{
|
|
return m_lTextureMode;
|
|
}
|
|
inline void SetTextureMode(const LONG& lMode)
|
|
{
|
|
m_lTextureMode = lMode;
|
|
}
|
|
inline BYTE GetTextureAlpha()
|
|
{
|
|
return m_nTextureAlpha;
|
|
}
|
|
inline void SetTextureAlpha(const LONG& lAlpha)
|
|
{
|
|
m_nTextureAlpha = (BYTE)(std::max)(0, (std::min)(255, (int)lAlpha));
|
|
}
|
|
inline double GetLinearAngle()
|
|
{
|
|
return m_dLinearAngle;
|
|
}
|
|
inline void SetLinearAngle(const double& dAngle)
|
|
{
|
|
m_dLinearAngle = dAngle;
|
|
}
|
|
inline void SetGradientColors(LONG* pColors, double* pPoints, const LONG& lCount)
|
|
{
|
|
// Мы создаем упорядоченный по возрастанию массив, причем первая и последняя точки должны быть 0 и 1 соответственно.
|
|
if (m_pShadingColors)
|
|
{
|
|
delete[] m_pShadingColors;
|
|
m_pShadingColors = NULL;
|
|
}
|
|
|
|
if (m_pShadingPoints)
|
|
{
|
|
delete[] m_pShadingPoints;
|
|
m_pShadingPoints = NULL;
|
|
}
|
|
|
|
if (!pColors || !pPoints || !lCount)
|
|
return;
|
|
|
|
// Проверим вырожденный случай, когда задана либо 1 точка, либо несколько точек с одинковым значением
|
|
bool bIrregular = false;
|
|
if (1 == lCount)
|
|
{
|
|
bIrregular = true;
|
|
}
|
|
else
|
|
{
|
|
bIrregular = true;
|
|
for (LONG lIndex = 0; lIndex < lCount; lIndex++)
|
|
{
|
|
double dPoint1 = pPoints[lIndex];
|
|
for (LONG lIndex2 = lIndex + 1; lIndex2 < lCount; lIndex2++)
|
|
{
|
|
double dPoint2 = pPoints[lIndex2];
|
|
if (fabs(dPoint2 - dPoint1) > 0.00001)
|
|
{
|
|
bIrregular = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bIrregular)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bIrregular)
|
|
{
|
|
if (1 == lCount)
|
|
{
|
|
m_pShadingPoints = new double[2];
|
|
m_pShadingColors = new TColor[2];
|
|
|
|
if (!m_pShadingColors || !m_pShadingColors)
|
|
return;
|
|
|
|
m_pShadingPoints[0] = 0.0;
|
|
m_pShadingColors[0] = pColors[0];
|
|
m_pShadingPoints[1] = 1.0;
|
|
m_pShadingColors[1] = pColors[0];
|
|
m_lShadingPointsCount = 2;
|
|
}
|
|
else
|
|
{
|
|
if (pPoints[0] < 0)
|
|
{
|
|
m_pShadingPoints = new double[2];
|
|
m_pShadingColors = new TColor[2];
|
|
|
|
if (!m_pShadingColors || !m_pShadingColors)
|
|
return;
|
|
|
|
m_pShadingPoints[0] = 0.0;
|
|
m_pShadingColors[0] = pColors[lCount - 1];
|
|
m_pShadingPoints[1] = 1.0;
|
|
m_pShadingColors[1] = pColors[lCount - 1];
|
|
m_lShadingPointsCount = 2;
|
|
}
|
|
else if (pPoints[0] > 1)
|
|
{
|
|
m_pShadingPoints = new double[2];
|
|
m_pShadingColors = new TColor[2];
|
|
|
|
if (!m_pShadingColors || !m_pShadingColors)
|
|
return;
|
|
|
|
m_pShadingPoints[0] = 0.0;
|
|
m_pShadingColors[0] = pColors[0];
|
|
m_pShadingPoints[1] = 1.0;
|
|
m_pShadingColors[1] = pColors[0];
|
|
m_lShadingPointsCount = 2;
|
|
}
|
|
else
|
|
{
|
|
m_pShadingPoints = new double[4];
|
|
m_pShadingColors = new TColor[4];
|
|
|
|
if (!m_pShadingColors || !m_pShadingColors)
|
|
return;
|
|
|
|
m_pShadingPoints[0] = 0.0;
|
|
m_pShadingColors[0] = pColors[0];
|
|
m_pShadingPoints[1] = pPoints[0];
|
|
m_pShadingColors[1] = pColors[0];
|
|
m_pShadingPoints[2] = pPoints[lCount - 1];
|
|
m_pShadingColors[2] = pColors[lCount - 1];
|
|
m_pShadingPoints[3] = 1.0;
|
|
m_pShadingColors[3] = pColors[lCount - 1];
|
|
m_lShadingPointsCount = 4;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::vector<TColorAndPoint> vPoints;
|
|
for (LONG lIndex = 0; lIndex < lCount; lIndex++)
|
|
{
|
|
vPoints.push_back(TColorAndPoint(pColors[lIndex], pPoints[lIndex]));
|
|
}
|
|
std::sort(vPoints.begin(), vPoints.end(), TColorAndPoint::Compare);
|
|
|
|
LONG lMinIn = -1, lMaxIn = -1, lMinOut = -1, lMaxOut = -1;
|
|
for (LONG lIndex = 0; lIndex < lCount; lIndex++)
|
|
{
|
|
double dPoint = vPoints.at(lIndex).dPoint;
|
|
if (0 <= dPoint && dPoint <= 1)
|
|
{
|
|
if (-1 == lMinIn || dPoint < vPoints.at(lMinIn).dPoint)
|
|
lMinIn = lIndex;
|
|
|
|
if (-1 == lMaxIn || dPoint > vPoints.at(lMaxIn).dPoint)
|
|
lMaxIn = lIndex;
|
|
}
|
|
else if (dPoint < 0)
|
|
{
|
|
if (-1 == lMinOut || dPoint > vPoints.at(lMinOut).dPoint)
|
|
lMinOut = lIndex;
|
|
}
|
|
else// if (dPoint > 1)
|
|
{
|
|
if (-1 == lMaxOut || dPoint < vPoints.at(lMaxOut).dPoint)
|
|
lMaxOut = lIndex;
|
|
}
|
|
}
|
|
|
|
LONG lBeginIndex = lMinIn;
|
|
LONG lEndIndex = lMaxIn;
|
|
|
|
bool bNeed0 = true, bNeed1 = true;
|
|
if (-1 != lMinIn && vPoints.at(lMinIn).dPoint < 0.001)
|
|
{
|
|
bNeed0 = false;
|
|
lBeginIndex = lMinIn;
|
|
vPoints.at(lMinIn).dPoint = 0;
|
|
}
|
|
else if (-1 != lMinOut && vPoints.at(lMinOut).dPoint > -0.001)
|
|
{
|
|
bNeed0 = false;
|
|
lBeginIndex = lMinOut;
|
|
vPoints.at(lMinOut).dPoint = 0;
|
|
}
|
|
|
|
if (-1 != lMaxIn && vPoints.at(lMaxIn).dPoint > 0.999)
|
|
{
|
|
bNeed1 = false;
|
|
lEndIndex = lMaxIn;
|
|
vPoints.at(lEndIndex).dPoint = 1;
|
|
}
|
|
else if (-1 != lMaxOut && vPoints.at(lMaxOut).dPoint < 1.001)
|
|
{
|
|
bNeed1 = false;
|
|
lEndIndex = lMaxOut;
|
|
vPoints.at(lEndIndex).dPoint = 1;
|
|
}
|
|
|
|
std::vector<TColorAndPoint> vResPoints;
|
|
if (bNeed0)
|
|
{
|
|
LONG lIndex0, lIndex1;
|
|
if (-1 != lMinOut)
|
|
{
|
|
if (-1 != lMinIn)
|
|
{
|
|
lIndex0 = lMinOut;
|
|
lIndex1 = lMinIn;
|
|
}
|
|
else if (-1 != lMaxOut)
|
|
{
|
|
lIndex0 = lMinOut;
|
|
lIndex1 = lMaxOut;
|
|
}
|
|
else
|
|
{
|
|
lIndex0 = lMinIn - 1;
|
|
lIndex1 = lMinIn;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (-1 != lMinIn)
|
|
{
|
|
lIndex0 = lMinIn;
|
|
lIndex1 = lMinIn + 1;
|
|
}
|
|
else
|
|
{
|
|
lIndex0 = lMaxOut;
|
|
lIndex1 = lMaxOut + 1;
|
|
}
|
|
}
|
|
|
|
LONG lColor0 = TColorAndPoint::GetLinearApprox(vPoints.at(lIndex0), vPoints.at(lIndex1), 0);
|
|
vResPoints.push_back(TColorAndPoint(lColor0, 0));
|
|
}
|
|
|
|
if (-1 != lBeginIndex && -1 != lEndIndex)
|
|
{
|
|
for (LONG lIndex = lBeginIndex; lIndex <= lEndIndex; lIndex++)
|
|
{
|
|
vResPoints.push_back(vPoints.at(lIndex));
|
|
}
|
|
}
|
|
|
|
if (bNeed1)
|
|
{
|
|
LONG lIndex0, lIndex1;
|
|
if (-1 != lMaxOut)
|
|
{
|
|
if (-1 != lMaxIn)
|
|
{
|
|
lIndex0 = lMaxIn;
|
|
lIndex1 = lMaxOut;
|
|
}
|
|
else if (-1 != lMinOut)
|
|
{
|
|
lIndex0 = lMinOut;
|
|
lIndex1 = lMaxOut;
|
|
}
|
|
else
|
|
{
|
|
lIndex0 = lMaxOut;
|
|
lIndex1 = lMaxOut + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (-1 != lMaxIn)
|
|
{
|
|
lIndex0 = lMaxIn - 1;
|
|
lIndex1 = lMaxIn;
|
|
}
|
|
else
|
|
{
|
|
lIndex0 = lMinOut - 1;
|
|
lIndex1 = lMinOut;
|
|
}
|
|
}
|
|
|
|
LONG lColor1 = TColorAndPoint::GetLinearApprox(vPoints.at(lIndex0), vPoints.at(lIndex1), 1);
|
|
vResPoints.push_back(TColorAndPoint(lColor1, 1));
|
|
}
|
|
|
|
size_t lResCount = vResPoints.size();
|
|
if (lResCount == 0)
|
|
return;
|
|
|
|
m_pShadingColors = new TColor[lResCount];
|
|
m_pShadingPoints = new double[lResCount];
|
|
m_lShadingPointsCount = lResCount;
|
|
|
|
if (!m_pShadingColors || !m_pShadingPoints)
|
|
return;
|
|
|
|
for (LONG lIndex = 0; lIndex < lResCount; lIndex++)
|
|
{
|
|
m_pShadingColors[lIndex] = vResPoints.at(lIndex).lColor;
|
|
m_pShadingPoints[lIndex] = vResPoints.at(lIndex).dPoint;
|
|
}
|
|
}
|
|
}
|
|
inline void SetBrushRect(const int& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight)
|
|
{
|
|
m_oRect.nVal = nVal;
|
|
m_oRect.dLeft = dLeft;
|
|
m_oRect.dTop = dTop;
|
|
m_oRect.dWidth = dWidth;
|
|
m_oRect.dHeight = dHeight;
|
|
}
|
|
inline void EnableBrushRect(bool bEnable)
|
|
{
|
|
m_oRect.bUse = bEnable;
|
|
}
|
|
TBrushRect& GetBrushRect()
|
|
{
|
|
return m_oRect;
|
|
}
|
|
|
|
inline void SetLinearGradientPattern(const double& dX0, const double& dY0, const double& dX1, const double& dY1)
|
|
{
|
|
m_pShadingPattern[0] = dX0;
|
|
m_pShadingPattern[1] = dY0;
|
|
m_pShadingPattern[2] = dX1;
|
|
m_pShadingPattern[3] = dY1;
|
|
}
|
|
inline void SetRadialGradientPattern(const double& dX0, const double& dY0, const double& dR0, const double& dX1, const double& dY1, const double& dR1)
|
|
{
|
|
m_pShadingPattern[0] = dX0;
|
|
m_pShadingPattern[1] = dY0;
|
|
m_pShadingPattern[2] = dR0;
|
|
m_pShadingPattern[3] = dX1;
|
|
m_pShadingPattern[4] = dY1;
|
|
m_pShadingPattern[5] = dR1;
|
|
}
|
|
inline void GetLinearGradientPattern(double& dX0, double& dY0, double& dX1, double& dY1)
|
|
{
|
|
dX0 = m_pShadingPattern[0];
|
|
dY0 = m_pShadingPattern[1];
|
|
dX1 = m_pShadingPattern[2];
|
|
dY1 = m_pShadingPattern[3];
|
|
}
|
|
inline void GetRadialGradientPattern(double& dX0, double& dY0, double& dR0, double& dX1, double& dY1, double& dR1)
|
|
{
|
|
dX0 = m_pShadingPattern[0];
|
|
dY0 = m_pShadingPattern[1];
|
|
dR0 = m_pShadingPattern[2];
|
|
dX1 = m_pShadingPattern[3];
|
|
dY1 = m_pShadingPattern[4];
|
|
dR1 = m_pShadingPattern[5];
|
|
}
|
|
inline void GetGradientColors(TColor*& pColors, double*& pPoints, LONG& lCount)
|
|
{
|
|
pColors = m_pShadingColors;
|
|
pPoints = m_pShadingPoints;
|
|
lCount = m_lShadingPointsCount;
|
|
}
|
|
|
|
inline double* GetDColor2(int& nSize)
|
|
{
|
|
nSize = m_nColor2Size;
|
|
return m_dColor2;
|
|
}
|
|
inline void SetDColor2(int nSize, double d1 = 0, double d2 = 0, double d3 = 0, double d4 = 0)
|
|
{
|
|
m_nColor2Size = nSize;
|
|
m_dColor2[0] = d1;
|
|
m_dColor2[1] = d2;
|
|
m_dColor2[2] = d3;
|
|
m_dColor2[3] = d4;
|
|
}
|
|
|
|
private:
|
|
|
|
LONG m_lType;
|
|
TColor m_oColor1;
|
|
TColor m_oColor2;
|
|
BYTE m_nAlpha1;
|
|
BYTE m_nAlpha2;
|
|
std::wstring m_wsTexturePath;
|
|
LONG m_lTextureMode;
|
|
BYTE m_nTextureAlpha;
|
|
double m_dLinearAngle;
|
|
TBrushRect m_oRect;
|
|
|
|
TColor* m_pShadingColors;
|
|
double* m_pShadingPoints;
|
|
LONG m_lShadingPointsCount;
|
|
double m_pShadingPattern[6]; // У линейного градиента x0, y0, x1, y1 (2 не используются), у радиального x0, y0, r0, x1, y1, r1
|
|
|
|
double m_dColor2[4];
|
|
int m_nColor2Size;
|
|
};
|
|
class CFontState
|
|
{
|
|
public:
|
|
|
|
CFontState() : m_wsName(L"Arial"), m_wsPath(L""), m_dSize(10), m_bGid(false), m_lFaceIndex(0), m_lStyle(0), m_bBold(false), m_bItalic(false), m_dCharSpace(0), m_bNeedDoItalic(false),
|
|
m_bNeedDoBold(false), m_nRenderMode(0), m_dRise(0), m_dWordSpace(0), m_dHorizontalScaling(100)
|
|
{
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
m_wsName = L"Arial";
|
|
m_wsPath = L"";
|
|
m_dSize = 10;
|
|
m_bGid = false;
|
|
m_lFaceIndex = 0;
|
|
m_lStyle = 0;
|
|
m_bBold = false;
|
|
m_bItalic = false;
|
|
m_dCharSpace = 0;
|
|
m_nRenderMode = 0;
|
|
m_dRise = 0;
|
|
m_dWordSpace = 0;
|
|
m_dHorizontalScaling = 100;
|
|
|
|
m_bNeedDoItalic = false;
|
|
m_bNeedDoBold = false;
|
|
}
|
|
|
|
inline std::wstring GetName()
|
|
{
|
|
return m_wsName;
|
|
}
|
|
inline void SetName(const std::wstring& wsName)
|
|
{
|
|
m_wsName = wsName;
|
|
}
|
|
inline std::wstring GetPath()
|
|
{
|
|
return m_wsPath;
|
|
}
|
|
inline void SetPath(const std::wstring& wsPath)
|
|
{
|
|
m_wsPath = wsPath;
|
|
}
|
|
inline double GetSize()
|
|
{
|
|
return m_dSize;
|
|
}
|
|
inline void SetSize(const double& dSize)
|
|
{
|
|
m_dSize = dSize;
|
|
}
|
|
inline LONG GetFaceIndex()
|
|
{
|
|
return m_lFaceIndex;
|
|
}
|
|
inline void SetFaceIndex(const LONG& lFaceIndex)
|
|
{
|
|
m_lFaceIndex = lFaceIndex;
|
|
}
|
|
inline LONG GetStyle()
|
|
{
|
|
return m_lStyle;
|
|
}
|
|
inline void SetStyle(const LONG& lStyle)
|
|
{
|
|
m_lStyle = lStyle;
|
|
m_bBold = (lStyle & 1 ? true : false);
|
|
m_bItalic = (lStyle & 2 ? true : false);
|
|
}
|
|
inline bool GetGid()
|
|
{
|
|
return m_bGid;
|
|
}
|
|
inline void SetGid(const bool& bGid)
|
|
{
|
|
m_bGid = bGid;
|
|
}
|
|
inline double GetCharSpace()
|
|
{
|
|
return m_dCharSpace;
|
|
}
|
|
inline void SetCharSpace(const double& dCharSpace)
|
|
{
|
|
m_dCharSpace = dCharSpace;
|
|
}
|
|
inline bool IsBold()
|
|
{
|
|
return m_bBold;
|
|
}
|
|
inline bool IsItalic()
|
|
{
|
|
return m_bItalic;
|
|
}
|
|
inline void SetNeedDoItalic(const bool& bNeedDoItalic)
|
|
{
|
|
m_bNeedDoItalic = bNeedDoItalic;
|
|
}
|
|
inline void SetNeedDoBold(const bool& bNeedDoBold)
|
|
{
|
|
m_bNeedDoBold = bNeedDoBold;
|
|
}
|
|
inline bool IsNeedDoItalic()
|
|
{
|
|
return m_bNeedDoItalic;
|
|
}
|
|
inline bool IsNeedDoBold()
|
|
{
|
|
return m_bNeedDoBold;
|
|
}
|
|
inline void SetRenderMode(BYTE nMode)
|
|
{
|
|
m_nRenderMode = nMode;
|
|
}
|
|
inline BYTE GetRenderMode()
|
|
{
|
|
return m_nRenderMode;
|
|
}
|
|
inline void SetRise(double dRise)
|
|
{
|
|
m_dRise = dRise;
|
|
}
|
|
inline double GetRise()
|
|
{
|
|
return m_dRise;
|
|
}
|
|
inline void SetWordSpace(double dWordSpace)
|
|
{
|
|
m_dWordSpace = dWordSpace;
|
|
}
|
|
inline double GetWordSpace()
|
|
{
|
|
return m_dWordSpace;
|
|
}
|
|
inline void SetHorizontalScaling(double dHS)
|
|
{
|
|
m_dHorizontalScaling = dHS;
|
|
}
|
|
inline double GetHorizontalScaling()
|
|
{
|
|
return m_dHorizontalScaling;
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
std::wstring m_wsName;
|
|
std::wstring m_wsPath;
|
|
double m_dSize;
|
|
bool m_bGid;
|
|
LONG m_lFaceIndex;
|
|
LONG m_lStyle;
|
|
bool m_bBold;
|
|
bool m_bItalic;
|
|
double m_dCharSpace;
|
|
bool m_bNeedDoItalic;
|
|
bool m_bNeedDoBold;
|
|
BYTE m_nRenderMode;
|
|
double m_dRise;
|
|
double m_dWordSpace;
|
|
double m_dHorizontalScaling;
|
|
};
|
|
struct CTransform
|
|
{
|
|
CTransform()
|
|
{
|
|
Reset();
|
|
}
|
|
void operator=(const CTransform& oT)
|
|
{
|
|
m11 = oT.m11;
|
|
m12 = oT.m12;
|
|
m21 = oT.m21;
|
|
m22 = oT.m22;
|
|
dx = oT.dx;
|
|
dy = oT.dy;
|
|
}
|
|
void Reset()
|
|
{
|
|
m11 = 1.0;
|
|
m12 = 0.0;
|
|
m21 = 0.0;
|
|
m22 = 1.0;
|
|
dx = 0;
|
|
dy = 0;
|
|
}
|
|
bool IsIdentity() const
|
|
{
|
|
if (fabs(m11 - 1) < 0.001
|
|
&& fabs(m12) < 0.001
|
|
&& fabs(m21) < 0.001
|
|
&& fabs(m22 - 1) < 0.001
|
|
&& fabs(dx) < 0.001
|
|
&& fabs(dy) < 0.001)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
void Set(const double& dM11, const double& dM12, const double& dM21, const double& dM22, const double& dX, const double& dY)
|
|
{
|
|
m11 = dM11;
|
|
m12 = dM12;
|
|
m21 = dM21;
|
|
m22 = dM22;
|
|
dx = dX;
|
|
dy = dY;
|
|
}
|
|
void Transform(double dUserX, double dUserY, double* pdDeviceX, double* pdDeviceY) const
|
|
{
|
|
*pdDeviceX = dUserX * m11 + dUserY * m21 + dx;
|
|
*pdDeviceY = dUserX * m12 + dUserY * m22 + dy;
|
|
}
|
|
|
|
double m11;
|
|
double m12;
|
|
double m21;
|
|
double m22;
|
|
double dx;
|
|
double dy;
|
|
};
|
|
class CPath
|
|
{
|
|
private:
|
|
|
|
enum EPathCommandType
|
|
{
|
|
rendererpathcommand_Unknown = 0x00,
|
|
rendererpathcommand_MoveTo = 0x01,
|
|
rendererpathcommand_LineTo = 0x02,
|
|
rendererpathcommand_CurveTo = 0x03,
|
|
rendererpathcommand_ArcTo = 0x04,
|
|
rendererpathcommand_Close = 0x05,
|
|
rendererpathcommand_TextChar = 0x06,
|
|
rendererpathcommand_Text = 0x07,
|
|
rendererpathcommand_TextExChar = 0x08,
|
|
rendererpathcommand_TextEx = 0x09
|
|
};
|
|
class CPathCommandBase
|
|
{
|
|
public:
|
|
CPathCommandBase()
|
|
{
|
|
}
|
|
virtual ~CPathCommandBase()
|
|
{
|
|
}
|
|
virtual void Draw(PdfWriter::CPage* pPage) = 0;
|
|
virtual void UpdateBounds(double& dL, double& dT, double& dR, double& dB) = 0;
|
|
virtual void GetLastPoint(double& dX, double& dY) = 0;
|
|
virtual EPathCommandType GetType() = 0;
|
|
virtual void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath) = 0;
|
|
};
|
|
class CPathMoveTo : public CPathCommandBase
|
|
{
|
|
public:
|
|
CPathMoveTo(const double& dX, const double& dY)
|
|
{
|
|
x = dX;
|
|
y = dY;
|
|
}
|
|
void GetLastPoint(double& dX, double& dY)
|
|
{
|
|
dX = x;
|
|
dY = y;
|
|
}
|
|
void Draw(PdfWriter::CPage* pPage);
|
|
void UpdateBounds(double& dL, double& dT, double& dR, double& dB);
|
|
EPathCommandType GetType()
|
|
{
|
|
return rendererpathcommand_MoveTo;
|
|
}
|
|
void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath);
|
|
|
|
public:
|
|
|
|
double x;
|
|
double y;
|
|
};
|
|
class CPathLineTo : public CPathCommandBase
|
|
{
|
|
public:
|
|
CPathLineTo(const double& dX, const double& dY)
|
|
{
|
|
x = dX;
|
|
y = dY;
|
|
}
|
|
void GetLastPoint(double& dX, double& dY)
|
|
{
|
|
dX = x;
|
|
dY = y;
|
|
}
|
|
void Draw(PdfWriter::CPage* pPage);
|
|
void UpdateBounds(double& dL, double& dT, double& dR, double& dB);
|
|
EPathCommandType GetType()
|
|
{
|
|
return rendererpathcommand_LineTo;
|
|
}
|
|
void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath);
|
|
|
|
public:
|
|
|
|
double x;
|
|
double y;
|
|
};
|
|
class CPathCurveTo : public CPathCommandBase
|
|
{
|
|
public:
|
|
CPathCurveTo(const double& dX1, const double& dY1, const double& dX2, const double& dY2, const double& dXe, const double& dYe)
|
|
{
|
|
x1 = dX1;
|
|
y1 = dY1;
|
|
x2 = dX2;
|
|
y2 = dY2;
|
|
xe = dXe;
|
|
ye = dYe;
|
|
}
|
|
void GetLastPoint(double& dX, double& dY)
|
|
{
|
|
dX = xe;
|
|
dY = ye;
|
|
}
|
|
void Draw(PdfWriter::CPage* pPage);
|
|
void UpdateBounds(double& dL, double& dT, double& dR, double& dB);
|
|
EPathCommandType GetType()
|
|
{
|
|
return rendererpathcommand_CurveTo;
|
|
}
|
|
void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath);
|
|
|
|
public:
|
|
|
|
double x1;
|
|
double y1;
|
|
double x2;
|
|
double y2;
|
|
double xe;
|
|
double ye;
|
|
};
|
|
class CPathArcTo : public CPathCommandBase
|
|
{
|
|
public:
|
|
CPathArcTo(const double& dX, const double& dY, const double& dW, const double& dH, const double& dStartAngle, const double& dSweepAngle)
|
|
{
|
|
x = dX;
|
|
y = dY;
|
|
w = dW;
|
|
h = dH;
|
|
startAngle = dStartAngle;
|
|
sweepAngle = dSweepAngle;
|
|
}
|
|
void GetLastPoint(double& dX, double& dY)
|
|
{
|
|
// TODO: Надо грамотно пересчитать
|
|
dX = x;
|
|
dY = y;
|
|
}
|
|
void Draw(PdfWriter::CPage* pPage);
|
|
void UpdateBounds(double& dL, double& dT, double& dR, double& dB);
|
|
EPathCommandType GetType()
|
|
{
|
|
return rendererpathcommand_ArcTo;
|
|
}
|
|
void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath);
|
|
|
|
public:
|
|
|
|
double x;
|
|
double y;
|
|
double w;
|
|
double h;
|
|
double startAngle;
|
|
double sweepAngle;
|
|
};
|
|
class CPathClose : public CPathCommandBase
|
|
{
|
|
public:
|
|
CPathClose()
|
|
{
|
|
}
|
|
void GetLastPoint(double& dX, double& dY)
|
|
{
|
|
// TODO: Надо грамотно пересчитать
|
|
dX = 0;
|
|
dY = 0;
|
|
}
|
|
void Draw(PdfWriter::CPage* pPage);
|
|
void UpdateBounds(double& dL, double& dT, double& dR, double& dB);
|
|
EPathCommandType GetType()
|
|
{
|
|
return rendererpathcommand_Close;
|
|
}
|
|
void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath);
|
|
};
|
|
class CPathText : public CPathCommandBase
|
|
{
|
|
public:
|
|
CPathText(PdfWriter::CFontDict* pFont, unsigned char* pCodes, const unsigned int& unCodesCount, const double& dX, const double& dY, const double& dSize, const double& dCharSpace)
|
|
{
|
|
font = pFont;
|
|
codes = pCodes;
|
|
codesCount = unCodesCount;
|
|
x = dX;
|
|
y = dY;
|
|
fontSize = dSize;
|
|
charSpace = dCharSpace;
|
|
}
|
|
~CPathText()
|
|
{
|
|
RELEASEARRAYOBJECTS(codes);
|
|
}
|
|
void GetLastPoint(double& dX, double& dY)
|
|
{
|
|
dX = x;
|
|
dY = y;
|
|
}
|
|
void Draw(PdfWriter::CPage* pPage);
|
|
void UpdateBounds(double& dL, double& dT, double& dR, double& dB);
|
|
EPathCommandType GetType()
|
|
{
|
|
return rendererpathcommand_Text;
|
|
}
|
|
void ToCGraphicsPath(PdfWriter::CMatrix* pMatrix, Aggplus::CGraphicsPath& oPath);
|
|
|
|
public:
|
|
|
|
PdfWriter::CFontDict* font;
|
|
unsigned char* codes;
|
|
unsigned int codesCount;
|
|
double x;
|
|
double y;
|
|
double fontSize;
|
|
double charSpace;
|
|
};
|
|
|
|
public:
|
|
|
|
CPath()
|
|
{
|
|
m_bIsMoveTo = false;
|
|
}
|
|
~CPath()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
bool MoveTo(const double& dX, const double& dY)
|
|
{
|
|
m_bIsMoveTo = true;
|
|
return Add(new CPathMoveTo(dX, dY));
|
|
}
|
|
bool LineTo(const double& dX, const double& dY)
|
|
{
|
|
if (!m_bIsMoveTo)
|
|
MoveTo(dX, dY);
|
|
|
|
return Add(new CPathLineTo(dX, dY));
|
|
}
|
|
bool CurveTo(double dX1, double dY1, double dX2, double dY2, double dXE, double dYE)
|
|
{
|
|
if (!m_bIsMoveTo)
|
|
MoveTo(dX1, dY1);
|
|
|
|
return Add(new CPathCurveTo(dX1, dY1, dX2, dY2, dXE, dYE));
|
|
}
|
|
bool ArcTo(double dX, double dY, double dW, double dH, double dStart, double dSweep)
|
|
{
|
|
if (!m_bIsMoveTo)
|
|
MoveTo(dX, dY);
|
|
|
|
return Add(new CPathArcTo(dX, dY, dW, dH, dStart, dSweep));
|
|
}
|
|
bool AddText(PdfWriter::CFontDict* pFont, unsigned char* pCodes, const unsigned int& unLen, const double& dX, const double& dY, const double& dSize, const double& dCharSpace)
|
|
{
|
|
return Add(new CPathText(pFont, pCodes, unLen, dX, dY, dSize, dCharSpace));
|
|
}
|
|
bool Close()
|
|
{
|
|
return Add(new CPathClose());
|
|
}
|
|
void Clear()
|
|
{
|
|
for (size_t nIndex = 0, nCount = m_vCommands.size(); nIndex < nCount; nIndex++)
|
|
{
|
|
CPathCommandBase* pCommand = m_vCommands.at(nIndex);
|
|
delete pCommand;
|
|
}
|
|
m_vCommands.clear();
|
|
m_bIsMoveTo = false;
|
|
}
|
|
bool IsMoveTo()
|
|
{
|
|
return m_bIsMoveTo;
|
|
}
|
|
void GetLastPoint(double& dX, double& dY);
|
|
void Draw(PdfWriter::CPage* pPage, bool bStroke, bool bFill, bool bEoFill);
|
|
void Clip(PdfWriter::CPage* pPage, bool bEvenOdd = false);
|
|
void GetBounds(double& dL, double& dT, double& dR, double& dB);
|
|
void Redact(PdfWriter::CMatrix* oMatrix, const std::vector<double>& arrRedact, PdfWriter::CPage* pPage, bool bStroke, bool bFill, bool bEoFill,
|
|
PdfWriter::CShading* pShading, PdfWriter::CExtGrState* pShadingExtGrState);
|
|
bool DrawPathRedact(PdfWriter::CMatrix* oMatrix, Aggplus::CGraphicsPath* oPath, bool bStroke, const std::vector<PdfWriter::CSegment>& arrForStroke = {});
|
|
|
|
private:
|
|
|
|
bool Add(CPathCommandBase* pCommand)
|
|
{
|
|
if (pCommand)
|
|
{
|
|
m_vCommands.push_back(pCommand);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public:
|
|
|
|
std::vector<CPathCommandBase*> m_vCommands;
|
|
bool m_bIsMoveTo;
|
|
};
|
|
|
|
class CCommandManager
|
|
{
|
|
public:
|
|
CCommandManager(CPdfWriter* pRenderer);
|
|
~CCommandManager();
|
|
CRendererTextCommand* AddText(unsigned char* pCodes, unsigned int nLen, const double& dX, const double& dY);
|
|
void Flush();
|
|
void SetTransform(const CTransform& oTransform) { m_oTransform = oTransform; }
|
|
void SetTransform(const double& m11, const double& m12, const double& m21, const double& m22, const double& dx, const double& dy) { m_oTransform.Set(m11, m12, m21, m22, dx, dy); }
|
|
private:
|
|
void Add(CRendererCommandBase* pCommand);
|
|
void Clear();
|
|
private:
|
|
CPdfWriter* m_pRenderer;
|
|
std::vector<CRendererCommandBase*> m_vCommands;
|
|
CTransform m_oTransform;
|
|
};
|
|
struct TDestinationInfo
|
|
{
|
|
TDestinationInfo(PdfWriter::CPage* page, const double& x, const double& y, const double& w, const double& h, const double& dx, const double& dy, const unsigned int& undpage)
|
|
{
|
|
pPage = page;
|
|
dX = x;
|
|
dY = y;
|
|
dW = w;
|
|
dH = h;
|
|
dDestX = dx;
|
|
dDestY = dy;
|
|
unDestPage = undpage;
|
|
}
|
|
|
|
PdfWriter::CPage* pPage;
|
|
double dX;
|
|
double dY;
|
|
double dW;
|
|
double dH;
|
|
double dDestX;
|
|
double dDestY;
|
|
unsigned int unDestPage;
|
|
};
|
|
class CMultiLineTextManager
|
|
{
|
|
public:
|
|
CMultiLineTextManager()
|
|
{
|
|
m_pCodes = NULL;
|
|
m_pWidths = NULL;
|
|
m_unLen = 0;
|
|
m_ushSpaceCode = 0;
|
|
m_unLineHeight = 0;
|
|
m_nAscent = 0;
|
|
m_nDescent = 0;
|
|
}
|
|
void Init(unsigned short* pCodes, unsigned int* pWidths, const unsigned int& unLen, const unsigned short& ushSpaceCode, const unsigned short& ushNewLineCode, const unsigned int& unLineHeight, const int& nAscent)
|
|
{
|
|
m_pCodes = pCodes;
|
|
m_pWidths = pWidths;
|
|
m_unLen = unLen;
|
|
m_ushSpaceCode = ushSpaceCode;
|
|
m_ushNewLineCode = ushNewLineCode;
|
|
m_unLineHeight = unLineHeight;
|
|
m_nAscent = nAscent;
|
|
m_nDescent = unLineHeight - nAscent;
|
|
}
|
|
void Clear()
|
|
{
|
|
m_pCodes = NULL;
|
|
m_pWidths = NULL;
|
|
m_unLen = 0;
|
|
m_ushSpaceCode = 0;
|
|
m_ushNewLineCode = 0;
|
|
m_unLineHeight = 0;
|
|
m_nAscent = 0;
|
|
m_nDescent = 0;
|
|
}
|
|
void CalculateLines(const double& dFontSize, const double& dW)
|
|
{
|
|
m_vBreaks.clear();
|
|
|
|
bool bLineStart = true, bWord = false, bFirstItemOnLine = true;
|
|
|
|
unsigned int unPos = 0, unWordStartPos = 0;
|
|
double dWordWidth = 0;
|
|
double dX = 0, dKoef = dFontSize / 1000.0;
|
|
|
|
while (unPos < m_unLen)
|
|
{
|
|
if (IsSpace(unPos))
|
|
{
|
|
dX += dWordWidth + m_pWidths[unPos] * dKoef;
|
|
bWord = false;
|
|
dWordWidth = 0;
|
|
bLineStart = false;
|
|
bFirstItemOnLine = false;
|
|
}
|
|
else if (IsNewLine(unPos))
|
|
{
|
|
bLineStart = true;
|
|
bFirstItemOnLine = true;
|
|
bWord = false;
|
|
dX = 0;
|
|
dWordWidth = 0;
|
|
m_vBreaks.push_back(unPos + 1);
|
|
}
|
|
else
|
|
{
|
|
double dLetterWidth = m_pWidths[unPos] * dKoef;
|
|
if (dX + dWordWidth + dLetterWidth > dW)
|
|
{
|
|
if (bLineStart)
|
|
{
|
|
if (bFirstItemOnLine)
|
|
{
|
|
if (unPos != m_unLen - 1)
|
|
m_vBreaks.push_back(unPos + 1);
|
|
|
|
unPos++;
|
|
}
|
|
else
|
|
{
|
|
m_vBreaks.push_back(unPos);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bWord)
|
|
{
|
|
m_vBreaks.push_back(unWordStartPos);
|
|
unPos = unWordStartPos;
|
|
}
|
|
else
|
|
{
|
|
m_vBreaks.push_back(unPos);
|
|
}
|
|
}
|
|
|
|
dX = 0;
|
|
bWord = false;
|
|
dWordWidth = 0;
|
|
bLineStart = true;
|
|
bFirstItemOnLine = true;
|
|
continue;
|
|
}
|
|
|
|
if (bWord)
|
|
{
|
|
dWordWidth += m_pWidths[unPos] * dKoef;
|
|
}
|
|
else
|
|
{
|
|
unWordStartPos = unPos;
|
|
bWord = true;
|
|
dWordWidth = m_pWidths[unPos] * dKoef;
|
|
}
|
|
|
|
bFirstItemOnLine = false;
|
|
}
|
|
|
|
unPos++;
|
|
}
|
|
}
|
|
double ProcessAutoFit(const double& dW, const double& dH)
|
|
{
|
|
double dGoodFontSize = 0;
|
|
|
|
// Параметры подобраны для совместимости с AdobeReader
|
|
double dFontSize = 4;
|
|
double dFontSizeStep = 0.797 / 3.0;
|
|
|
|
while (true)
|
|
{
|
|
CalculateLines(dFontSize, dW);
|
|
if (CheckHeight(dH, dFontSize))
|
|
{
|
|
dGoodFontSize = dFontSize;
|
|
dFontSize += dFontSizeStep;
|
|
|
|
if (dFontSize > 12)
|
|
{
|
|
dFontSize = 12;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dGoodFontSize > 0.001)
|
|
{
|
|
dFontSize = dGoodFontSize;
|
|
break;
|
|
}
|
|
|
|
dFontSize -= dFontSizeStep;
|
|
if (dFontSize < 4)
|
|
{
|
|
dFontSize = 4;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (floor(dFontSize * 1000.0 + 0.5) / 1000.0);
|
|
}
|
|
unsigned int GetLinesCount() const
|
|
{
|
|
return m_vBreaks.size() + 1;
|
|
}
|
|
unsigned int GetLineStartPos(const int& nLineIndex) const
|
|
{
|
|
if (!nLineIndex || nLineIndex > m_vBreaks.size())
|
|
return 0;
|
|
|
|
return m_vBreaks[nLineIndex - 1];
|
|
}
|
|
unsigned int GetLineEndPos(const int& nLineIndex) const
|
|
{
|
|
unsigned int unLineStart = GetLineStartPos(nLineIndex);
|
|
unsigned int unLineEnd = nLineIndex >= m_vBreaks.size() ? m_unLen : m_vBreaks[nLineIndex];
|
|
while (unLineEnd > 0 && unLineEnd > unLineStart && IsNewLine(unLineEnd - 1))
|
|
--unLineEnd;
|
|
|
|
return unLineEnd;
|
|
}
|
|
double GetLineWidth(const int& nLineIndex, const double& dFontSize = 10.0)
|
|
{
|
|
if (nLineIndex < 0 || nLineIndex > m_vBreaks.size())
|
|
return 0;
|
|
|
|
unsigned int unStart = GetLineStartPos(nLineIndex);
|
|
unsigned int unEnd = GetLineEndPos(nLineIndex);
|
|
|
|
double dWidth = 0;
|
|
double dKoef = dFontSize / 1000.0;
|
|
|
|
while (unStart < unEnd)
|
|
{
|
|
if (IsSpace(unStart))
|
|
unStart++;
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (unEnd > unStart && unEnd > 0)
|
|
{
|
|
if (IsSpace(unEnd - 1))
|
|
unEnd--;
|
|
else
|
|
break;
|
|
}
|
|
|
|
for (unsigned int unPos = unStart; unPos < unEnd; ++unPos)
|
|
{
|
|
dWidth += m_pWidths[unPos] * dKoef;
|
|
}
|
|
|
|
return dWidth;
|
|
}
|
|
|
|
private:
|
|
inline bool IsSpace(const unsigned int& unPos) const
|
|
{
|
|
return (m_pCodes[unPos] == m_ushSpaceCode);
|
|
}
|
|
inline bool IsNewLine(const unsigned int& unPos) const
|
|
{
|
|
return (m_pCodes[unPos] == m_ushNewLineCode);
|
|
}
|
|
inline bool CheckHeight(const double& dH, const double& dFontSize) const
|
|
{
|
|
double dKoef = dFontSize / 1000.0;
|
|
return (GetLinesCount() * (m_unLineHeight * dKoef) < (dH - (m_nDescent * dKoef)));
|
|
}
|
|
|
|
private:
|
|
unsigned short* m_pCodes;
|
|
unsigned int* m_pWidths;
|
|
unsigned int m_unLen;
|
|
unsigned short m_ushSpaceCode;
|
|
unsigned short m_ushNewLineCode;
|
|
unsigned int m_unLineHeight;
|
|
int m_nAscent;
|
|
int m_nDescent;
|
|
|
|
std::vector<unsigned int> m_vBreaks;
|
|
};
|
|
#endif // _PDF_WRITER_SRC_STATE_H
|