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
|