Skip to content

O
onlyoffice_core
Commit f4fde172 authored by Ilya.Kirillov's avatar Ilya.Kirillov Committed by Alexander Trofimov
Browse files
Options

Реализованы градиенты. Реализована прозрачность в градиентах. Сделан конвертер из бинарника в Pdf. 

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@63265 954022d7-b5bf-4e40-9824-e11837661b57
parent 2d5f7b32
Hide whitespace changes
Inline Side-by-side
Showing with 1544 additions and 72 deletions
PdfWriter/OnlineOfficeBinToPdf.cpp 0 → 100644
View file @ f4fde172
#include "OnlineOfficeBinToPdf.h"
#include "../DesktopEditor/common/File.h"
#include "../DesktopEditor/common/Directory.h"
#include "../DesktopEditor/common/Base64.h"
#include "../DesktopEditor/common/String.h"
#ifndef _INT32
typedef int _INT32;
#endif
#ifndef SHORT
typedef unsigned short USHORT;
#endif
#ifndef BYTE
typedef unsigned char BYTE;
#endif
namespace NSOnlineOfficeBinToPdf
{
enum CommandType
{
ctPenXML = 0,
ctPenColor = 1,
ctPenAlpha = 2,
ctPenSize = 3,
ctPenDashStyle = 4,
ctPenLineStartCap = 5,
ctPenLineEndCap = 6,
ctPenLineJoin = 7,
ctPenDashPatern = 8,
ctPenDashPatternCount = 9,
ctPenDashOffset = 10,
ctPenAlign = 11,
ctPenMiterLimit = 12,
// brush
ctBrushXML = 20,
ctBrushType = 21,
ctBrushColor1 = 22,
ctBrushColor2 = 23,
ctBrushAlpha1 = 24,
ctBrushAlpha2 = 25,
ctBrushTexturePath = 26,
ctBrushTextureAlpha = 27,
ctBrushTextureMode = 28,
ctBrushRectable = 29,
ctBrushRectableEnabled = 30,
ctBrushGradient = 31,
// font
ctFontXML = 40,
ctFontName = 41,
ctFontSize = 42,
ctFontStyle = 43,
ctFontPath = 44,
ctFontGID = 45,
ctFontCharSpace = 46,
// shadow
ctShadowXML = 50,
ctShadowVisible = 51,
ctShadowDistanceX = 52,
ctShadowDistanceY = 53,
ctShadowBlurSize = 54,
ctShadowColor = 55,
ctShadowAlpha = 56,
// edge
ctEdgeXML = 70,
ctEdgeVisible = 71,
ctEdgeDistance = 72,
ctEdgeColor = 73,
ctEdgeAlpha = 74,
// text
ctDrawText = 80,
ctDrawTextEx = 81,
// pathcommands
ctPathCommandMoveTo = 91,
ctPathCommandLineTo = 92,
ctPathCommandLinesTo = 93,
ctPathCommandCurveTo = 94,
ctPathCommandCurvesTo = 95,
ctPathCommandArcTo = 96,
ctPathCommandClose = 97,
ctPathCommandEnd = 98,
ctDrawPath = 99,
ctPathCommandStart = 100,
ctPathCommandGetCurrentPoint = 101,
ctPathCommandText = 102,
ctPathCommandTextEx = 103,
// image
ctDrawImage = 110,
ctDrawImageFromFile = 111,
ctSetParams = 120,
ctBeginCommand = 121,
ctEndCommand = 122,
ctSetTransform = 130,
ctResetTransform = 131,
ctClipMode = 140,
ctCommandLong1 = 150,
ctCommandDouble1 = 151,
ctCommandString1 = 152,
ctCommandLong2 = 153,
ctCommandDouble2 = 154,
ctCommandString2 = 155,
ctPageWidth = 200,
ctPageHeight = 201,
ctPageStart = 202,
ctPageEnd = 203,
// gradients
ctGradientFill = 220,
ctGradientFillXML = 221,
ctGradientStroke = 222,
ctGradientStrokeXML = 223,
ctError = 255
};
static inline _INT32 ReadInt(BYTE*& pData, int& nOffset)
{
#ifdef _ARM_ALIGN_
_INT32 ret = 0;
memcpy(&ret, pData, sizeof(_INT32));
pData += 4;
nOffset += 4;
return ret;
#else
_INT32 ret = *((_INT32*)pData);
pData += 4;
nOffset += 4;
return ret;
#endif
}
static inline USHORT ReadUSHORT(BYTE*& pData, int& nOffset)
{
#ifdef _ARM_ALIGN_
USHORT ret = 0;
memcpy(&ret, pData, sizeof(USHORT));
pData += 2;
nOffset += 2;
return ret;
#else
USHORT ret = *((USHORT*)pData);
pData += 2;
nOffset += 2;
return ret;
#endif
}
static inline std::wstring ReadString16(BYTE*& pData, int& nOffset, int nLen)
{
std::wstring wsTempString;
#ifdef _ARM_ALIGN_
if (sizeof(wchar_t) == 4)
{
#if !defined(_WIN32) && !defined(_WIN64)
int len = nLen / 2;
UTF16* buf = new UTF16[len];
memcpy(buf, pData, nLen);
wsTempString = stringUtf16ToWString(buf, len);
RELEASEARRAYOBJECTS(buf);
#endif
}
else
{
int len = nLen / 2;
wchar_t* buf = new wchar_t[len];
memcpy(buf, pData, nLen);
wsTempString = std::wstring(buf, len);
RELEASEARRAYOBJECTS(buf);
}
#else
if (sizeof(wchar_t) == 4)
{
#if !defined(_WIN32) && !defined(_WIN64)
wsTempString = stringUtf16ToWString((UTF16*)pData, nLen / 2);
#endif
}
else
{
wsTempString = std::wstring((wchar_t*)pData, nLen / 2);
}
#endif
pData += nLen;
nOffset += nLen;
return wsTempString;
}
static std::wstring ReadImagePath(CPdfRenderer* pPdf, const std::wstring& wsHtmlPlace, BYTE*& pData, int& nOffset)
{
int _sLen = 2 * ReadUSHORT(pData, nOffset);
std::wstring wsTempString = ReadString16(pData, nOffset, _sLen);
if (0 == wsTempString.find(L"data:"))
{
try
{
int nFind = wsTempString.find(L",");
wsTempString = wsTempString.substr(nFind + 1);
std::wstring wsBase64TempFile = pPdf->GetTempFile();
std::string sBase64MultyByte(wsTempString.begin(), wsTempString.end());
int nBufferLen = NSBase64::Base64DecodeGetRequiredLength(sBase64MultyByte.length());
BYTE* pImageBuffer = new BYTE[nBufferLen + 64];
if (NSBase64::Base64Decode(sBase64MultyByte.c_str(), sBase64MultyByte.length(), pImageBuffer, &nBufferLen))
{
NSFile::CFileBinary oFile;
if (oFile.CreateFileW(wsBase64TempFile))
{
oFile.WriteFile(pImageBuffer, nBufferLen);
oFile.CloseFile();
wsTempString = wsBase64TempFile;
}
}
else throw;
}
catch (...)
{
}
}
else
{
if (0 != wsTempString.find(L"http:")
&& 0 != wsTempString.find(L"https:")
&& 0 != wsTempString.find(L"ftp:")
&& 0 != wsTempString.find(L"file:"))
{
if (0 == wsTempString.find(L"theme"))
{
std::wstring wsThemesPlace = pPdf->GetThemesPlace();
if (L"" != wsThemesPlace)
wsTempString = wsThemesPlace + L"/" + wsTempString;
}
else
{
if (wsHtmlPlace.length() > 0)
wsTempString = wsHtmlPlace + L"/" + wsTempString;
std::wstring wsSvgExt(L".svg");
if (0 == wsTempString.compare(wsTempString.length() - wsSvgExt.length(), std::wstring::npos, wsSvgExt))
{
std::wstring wsTestPath = wsTempString.substr(0, wsTempString.length() - wsSvgExt.length());
if (NSFile::CFileBinary::Exists(wsTestPath + L".emf"))
wsTempString = wsTestPath + L".emf";
else if (NSFile::CFileBinary::Exists(wsTestPath + L".wmf"))
wsTempString = wsTestPath + L".wmf";
}
}
NSString::Replace(wsTempString, L"\\", L"/");
}
if (0 == wsTempString.find(L"file:///"))
{
NSString::Replace(wsTempString, L"file:///", L"");
NSString::Replace(wsTempString, L"\\", L"/");
}
}
return wsTempString;
}
static bool ConvertBufferToPdf(CPdfRenderer* pPdf, BYTE* pBuffer, LONG lBufferLen, const std::wstring& wsHtmlPlace)
{
CommandType eCommand = ctError;
bool bIsPathOpened = false;
int curindex = 0;
BYTE* current = pBuffer;
while (curindex < lBufferLen)
{
eCommand = (CommandType)(*current);
current++;
curindex++;
switch (eCommand)
{
case ctPageWidth:
{
pPdf->put_Width(ReadInt(current, curindex) / 100000.0);
break;
}
case ctPageHeight:
{
pPdf->put_Height(ReadInt(current, curindex) / 100000.0);
break;
}
case ctPageStart:
{
pPdf->NewPage();
pPdf->BeginCommand(c_nPageType);
break;
}
case ctPageEnd:
{
if (bIsPathOpened)
{
pPdf->PathCommandEnd();
pPdf->EndCommand(c_nPathType);
}
bIsPathOpened = false;
pPdf->EndCommand(c_nPageType);
break;
}
case ctPenColor:
{
pPdf->put_PenColor(ReadInt(current, curindex));
break;
}
case ctPenAlpha:
{
pPdf->put_PenAlpha(*current);
current++;
curindex++;
break;
}
case ctPenSize:
{
pPdf->put_PenSize(ReadInt(current, curindex) / 100000.0);
break;
}
case ctPenLineJoin:
{
pPdf->put_PenLineJoin(*current);
current++;
curindex++;
break;
}
case ctBrushType:
{
pPdf->put_BrushType(ReadInt(current, curindex));
break;
}
case ctBrushColor1:
{
pPdf->put_BrushColor1(ReadInt(current, curindex));
break;
}
case ctBrushAlpha1:
{
pPdf->put_BrushAlpha1(*current);
current++;
curindex++;
break;
}
case ctBrushColor2:
{
pPdf->put_BrushColor1(ReadInt(current, curindex));
break;
}
case ctBrushAlpha2:
{
pPdf->put_BrushAlpha2(*current);
current++;
curindex++;
break;
}
case ctBrushRectable:
{
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
double m3 = ReadInt(current, curindex) / 100000.0;
double m4 = ReadInt(current, curindex) / 100000.0;
pPdf->BrushRect(0, m1, m2, m3, m4);
break;
}
case ctBrushRectableEnabled:
{
bool bEnable = (1 == *current) ? true : false;
pPdf->EnableBrushRect(bEnable);
current += 1;
curindex += 1;
break;
}
case ctBrushTexturePath:
{
std::wstring wsTempString = ReadImagePath(pPdf, wsHtmlPlace, current, curindex);
pPdf->put_BrushTexturePath(wsTempString);
break;
}
case ctBrushGradient:
{
current++;
curindex++;
while (true)
{
BYTE _command = *current;
current++;
curindex++;
if (251 == _command)
break;
switch (_command)
{
case 0:
{
current += 5;
curindex += 5;
double x0 = ReadInt(current, curindex) / 100000.0;
double y0 = ReadInt(current, curindex) / 100000.0;
double x1 = ReadInt(current, curindex) / 100000.0;
double y1 = ReadInt(current, curindex) / 100000.0;
pPdf->SetLinearGradient(x0, y0, x1, y1);
break;
}
case 1:
{
current++;
curindex++;
double x0 = ReadInt(current, curindex) / 100000.0;
double y0 = ReadInt(current, curindex) / 100000.0;
double x1 = ReadInt(current, curindex) / 100000.0;
double y1 = ReadInt(current, curindex) / 100000.0;
double r0 = ReadInt(current, curindex) / 100000.0;
double r1 = ReadInt(current, curindex) / 100000.0;
pPdf->SetRadialGradient(x0, y0, r0, x1, y1, r1);
break;
}
case 2:
{
LONG lColorsCount = (LONG)ReadInt(current, curindex);
LONG* pColors = new LONG[lColorsCount];
double* pPositions = new double[lColorsCount];
if (!pColors)
break;
if (!pPositions)
{
delete[] pColors;
break;
}
for (LONG lIndex = 0; lIndex < lColorsCount; lIndex++)
{
pPositions[lIndex] = ReadInt(current, curindex) / 100000.0;
pColors[lIndex] = ReadInt(current, curindex);
//BYTE _r = *current++;
//BYTE _g = *current++;
//BYTE _b = *current++;
//BYTE _a = *current++;
//curindex += 4;
//int _color = ((_b << 16) & 0xFF0000) | ((_g << 8) & 0xFF00) | _r;
//CString sColor;
//sColor.Format(L"<stop stop-color='%d' stop-opacity='%f' offset='%f' />", _color, _a / 255.0, dPos);
//strColors += sColor;
}
pPdf->put_BrushGradientColors(pColors, pPositions, lColorsCount);
delete[] pColors;
delete[] pPositions;
break;
}
default:
{
break;
}
};
}
break;
}
case ctBrushTextureMode:
{
LONG lMode = (LONG)(*current);
pPdf->put_BrushTextureMode(lMode);
current += 1;
curindex += 1;
break;
}
case ctBrushTextureAlpha:
{
LONG lAlpha = (LONG)(*current);
pPdf->put_BrushTextureAlpha(lAlpha);
current += 1;
curindex += 1;
break;
}
case ctSetTransform:
{
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
double m3 = ReadInt(current, curindex) / 100000.0;
double m4 = ReadInt(current, curindex) / 100000.0;
double m5 = ReadInt(current, curindex) / 100000.0;
double m6 = ReadInt(current, curindex) / 100000.0;
pPdf->SetTransform(m1, m2, m3, m4, m5, m6);
break;
}
case ctPathCommandStart:
{
if (bIsPathOpened)
{
pPdf->PathCommandEnd();
pPdf->EndCommand(c_nPathType);
}
pPdf->BeginCommand(c_nPathType);
pPdf->PathCommandStart();
bIsPathOpened = true;
break;
}
case ctPathCommandMoveTo:
{
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
pPdf->PathCommandMoveTo(m1, m2);
break;
}
case ctPathCommandLineTo:
{
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
pPdf->PathCommandLineTo(m1, m2);
break;
}
case ctPathCommandCurveTo:
{
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
double m3 = ReadInt(current, curindex) / 100000.0;
double m4 = ReadInt(current, curindex) / 100000.0;
double m5 = ReadInt(current, curindex) / 100000.0;
double m6 = ReadInt(current, curindex) / 100000.0;
pPdf->PathCommandCurveTo(m1, m2, m3, m4, m5, m6);
break;
}
case ctPathCommandClose:
{
pPdf->PathCommandClose();
break;
}
case ctPathCommandEnd:
{
if (bIsPathOpened)
{
pPdf->PathCommandEnd();
pPdf->EndCommand(c_nPathType);
bIsPathOpened = false;
}
break;
}
case ctDrawPath:
{
pPdf->DrawPath(ReadInt(current, curindex));
break;
}
case ctDrawImageFromFile:
{
std::wstring wsTempString = ReadImagePath(pPdf, wsHtmlPlace, current, curindex);
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
double m3 = ReadInt(current, curindex) / 100000.0;
double m4 = ReadInt(current, curindex) / 100000.0;
pPdf->DrawImageFromFile(wsTempString, m1, m2, m3, m4);
break;
}
case ctFontName:
{
int _sLen = 2 * (int)ReadUSHORT(current, curindex);
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
pPdf->put_FontName(wsTempString);
break;
}
case ctFontSize:
{
double m1 = ReadInt(current, curindex) / 100000.0;
pPdf->put_FontSize(m1);
break;
}
case ctFontStyle:
{
pPdf->put_FontStyle(ReadInt(current, curindex));
break;
}
case ctDrawText:
{
int _sLen = 2 * (int)ReadUSHORT(current, curindex);
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
double m1 = ReadInt(current, curindex) / 100000.0;
double m2 = ReadInt(current, curindex) / 100000.0;
pPdf->CommandDrawText(wsTempString, m1, m2, 0, 0, 0);
break;
}
case ctBeginCommand:
{
if (bIsPathOpened)
{
pPdf->PathCommandEnd();
pPdf->EndCommand(4);
bIsPathOpened = false;
}
pPdf->BeginCommand((DWORD)(ReadInt(current, curindex)));
break;
}
case ctEndCommand:
{
if (bIsPathOpened)
{
pPdf->PathCommandEnd();
pPdf->EndCommand(4);
bIsPathOpened = false;
}
pPdf->EndCommand((DWORD)(ReadInt(current, curindex)));
pPdf->PathCommandEnd();
break;
}
case ctGradientFill:
{
// TODO:
_INT32 gradientType = ReadInt(current, curindex);
std::wstring sXml, sXmlStop;
if (0 == gradientType) // linearGradient
{
double x1 = ReadInt(current, curindex) / 100000.0;
double x2 = ReadInt(current, curindex) / 100000.0;
double y1 = ReadInt(current, curindex) / 100000.0;
double y2 = ReadInt(current, curindex) / 100000.0;
int stops = ReadInt(current, curindex);
for (int i = 0; i < stops; ++i)
{
_INT32 color = static_cast<_INT32>(*current);
double opacity = static_cast<double>(static_cast<_INT32>(*(current + 1))) / 255.0;
double offset = static_cast<double>(static_cast<_INT32>(*(current + 2))) / 255.0;
current += 6 * 4; // 4 + 1 + 1
curindex += 6 * 4;
}
}
else if (1 == gradientType)
{
double cx = ReadInt(current, curindex) / 100000.0;
double cy = ReadInt(current, curindex) / 100000.0;
double r = ReadInt(current, curindex) / 100000.0;
double fx = ReadInt(current, curindex) / 100000.0;
double fy = ReadInt(current, curindex) / 100000.0;
int stops = ReadInt(current, curindex);
for (int i = 0; i < stops; ++i)
{
_INT32 color = static_cast<_INT32>(*current);
double opacity = static_cast<double>(static_cast<_INT32>(*(current + 1))) / 255.0;
double offset = static_cast<double>(static_cast<_INT32>(*(current + 2))) / 255.0;
current += 6 * 4; // 4 + 1 + 1
curindex += 6 * 4;
}
}
break;
}
case ctGradientFillXML:
{
// TODO:
_INT32 gradientType = ReadInt(current, curindex);
int _sLen = ReadInt(current, curindex);
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
break;
}
case ctGradientStroke:
{
// TODO:
_INT32 gradientType = ReadInt(current, curindex);
if (0 == gradientType) // linearGradient
{
double x1 = ReadInt(current, curindex) / 100000.0;
double x2 = ReadInt(current, curindex) / 100000.0;
double y1 = ReadInt(current, curindex) / 100000.0;
double y2 = ReadInt(current, curindex) / 100000.0;
int stops = ReadInt(current, curindex);
for (int i = 0; i < stops; ++i)
{
_INT32 color = static_cast<_INT32>(*current);
double opacity = static_cast<double>(static_cast<_INT32>(*(current + 1))) / 255.0;
double offset = static_cast<double>(static_cast<_INT32>(*(current + 2))) / 255.0;
current += 6 * 4; // 4 + 1 + 1
curindex += 6 * 4;
}
}
else if (1 == gradientType)
{
double cx = ReadInt(current, curindex) / 100000.0;
double cy = ReadInt(current, curindex) / 100000.0;
double r = ReadInt(current, curindex) / 100000.0;
double fx = ReadInt(current, curindex) / 100000.0;
double fy = ReadInt(current, curindex) / 100000.0;
int stops = ReadInt(current, curindex);
for (int i = 0; i < stops; ++i)
{
_INT32 color = static_cast<_INT32>(*current);
double opacity = static_cast<double>(static_cast<_INT32>(*(current + 1))) / 255.0;
double offset = static_cast<double>(static_cast<_INT32>(*(current + 2))) / 255.0;
current += 6 * 4; // 4 + 1 + 1
curindex += 6 * 4;
}
}
break;
}
case ctGradientStrokeXML:
{
// TODO:
_INT32 gradientType = ReadInt(current, curindex);
int _sLen = (int)ReadInt(current, curindex);
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
break;
}
default:
{
break;
}
}; // switch (eCommand)
} // while (curindex < len)
return true;
}
bool ConvertBinToPdf(CPdfRenderer* pPdf, const std::wstring& wsSrcFile, const std::wstring& wsDstFile, bool bBinary)
{
NSFile::CFileBinary oFile;
if (!oFile.OpenFile(wsSrcFile))
return false;
DWORD dwFileSize = oFile.GetFileSize();
BYTE* pFileContent = new BYTE[dwFileSize];
if (!pFileContent)
{
oFile.CloseFile();
return false;
}
DWORD dwReaded;
oFile.ReadFile(pFileContent, dwFileSize, dwReaded);
oFile.CloseFile();
std::wstring wsHtmlPlace = NSDirectory::GetFolderPath(wsSrcFile);
if (bBinary)
{
ConvertBufferToPdf(pPdf, pFileContent, dwFileSize, wsHtmlPlace);
}
else
{
int nBufferLen = NSBase64::Base64DecodeGetRequiredLength(dwFileSize);
BYTE* pBuffer = new BYTE[nBufferLen];
if (!pBuffer)
{
RELEASEARRAYOBJECTS(pFileContent);
return false;
}
if (NSBase64::Base64Decode((const char*)pFileContent, dwFileSize, pBuffer, &nBufferLen))
{
ConvertBufferToPdf(pPdf, pBuffer, nBufferLen, wsHtmlPlace);
}
else
{
RELEASEARRAYOBJECTS(pBuffer);
RELEASEARRAYOBJECTS(pFileContent);
return false;
}
RELEASEARRAYOBJECTS(pBuffer);
}
RELEASEARRAYOBJECTS(pFileContent);
pPdf->SaveToFile(wsDstFile);
return true;
}
}
\ No newline at end of file
PdfWriter/OnlineOfficeBinToPdf.h 0 → 100644
View file @ f4fde172
#ifndef _PDF_WRITER_ONLINEOFFICEBINTOPDF_H
#define _PDF_WRITER_ONLINEOFFICEBINTOPDF_H
#include <string>
#include "PdfRenderer.h"
namespace NSOnlineOfficeBinToPdf
{
bool ConvertBinToPdf(CPdfRenderer* pPdf, const std::wstring& wsSrcFile, const std::wstring& wsDstFile, bool bBinary);
};
#endif // _PDF_WRITER_ONLINEOFFICEBINTOPDF_H
PdfWriter/PdfRenderer.cpp
View file @ f4fde172
...@@ -15,6 +15,9 @@ ...@@ -15,6 +15,9 @@
#include "../DesktopEditor/fontengine/FontManager.h" #include "../DesktopEditor/fontengine/FontManager.h"
#include "../DesktopEditor/common/File.h" #include "../DesktopEditor/common/File.h"
#include "../DesktopEditor/common/Directory.h"
#include "OnlineOfficeBinToPdf.h"
#define MM_2_PT(X) ((X) * 72.0 / 25.4) #define MM_2_PT(X) ((X) * 72.0 / 25.4)
...@@ -37,6 +40,10 @@ using namespace PdfWriter; ...@@ -37,6 +40,10 @@ using namespace PdfWriter;
#define LO_SURROGATE_START 0xDC00 #define LO_SURROGATE_START 0xDC00
#define LO_SURROGATE_END 0xDFFF #define LO_SURROGATE_END 0xDFFF
// , ,
static const long c_BrushTypeLinearGradient = 8001;
static const long c_BrushTypeRadialGradient = 8002;
CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts) CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts)
{ {
m_pAppFonts = pAppFonts; m_pAppFonts = pAppFonts;
...@@ -54,6 +61,8 @@ CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts) ...@@ -54,6 +61,8 @@ CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts)
return; return;
} }
//m_pDocument->SetCompressionMode(COMP_ALL);
m_bValid = true; m_bValid = true;
m_dPageHeight = 297; m_dPageHeight = 297;
m_dPageWidth = 210; m_dPageWidth = 210;
...@@ -61,6 +70,8 @@ CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts) ...@@ -61,6 +70,8 @@ CPdfRenderer::CPdfRenderer(CApplicationFonts* pAppFonts)
m_pFont = NULL; m_pFont = NULL;
m_nCounter = 0; m_nCounter = 0;
SetTempFolder(NSFile::CFileBinary::GetTempPath());
} }
CPdfRenderer::~CPdfRenderer() CPdfRenderer::~CPdfRenderer()
{ {
...@@ -74,6 +85,22 @@ void CPdfRenderer::SaveToFile(const std::wstring& wsPath) ...@@ -74,6 +85,22 @@ void CPdfRenderer::SaveToFile(const std::wstring& wsPath)
m_pDocument->SaveToFile(wsPath); m_pDocument->SaveToFile(wsPath);
} }
void CPdfRenderer::SetTempFolder(const std::wstring& wsPath)
{
m_wsTempFolder = wsPath;
}
std::wstring CPdfRenderer::GetTempFile()
{
return NSFile::CFileBinary::CreateTempFileWithUniqueName(m_wsTempFolder, L"PDF");
}
void CPdfRenderer::SetThemesPlace(const std::wstring& wsThemesPlace)
{
m_wsThemesPlace = wsThemesPlace;
}
std::wstring CPdfRenderer::GetThemesPlace()
{
return m_wsThemesPlace;
}
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// //
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -102,6 +129,11 @@ HRESULT CPdfRenderer::NewPage() ...@@ -102,6 +129,11 @@ HRESULT CPdfRenderer::NewPage()
m_pPage->SetHeight(m_dPageHeight); m_pPage->SetHeight(m_dPageHeight);
m_oPen.Reset(); m_oPen.Reset();
m_oBrush.Reset();
m_oFont.Reset();
m_oPath.Clear();
m_lClipDepth = 0;
return S_OK; return S_OK;
} }
...@@ -344,19 +376,21 @@ HRESULT CPdfRenderer::put_BrushLinearAngle(const double& dAngle) ...@@ -344,19 +376,21 @@ HRESULT CPdfRenderer::put_BrushLinearAngle(const double& dAngle)
m_oBrush.SetLinearAngle(dAngle); m_oBrush.SetLinearAngle(dAngle);
return S_OK; return S_OK;
} }
HRESULT CPdfRenderer::BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height) HRESULT CPdfRenderer::BrushRect(const INT& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight)
{ {
// TODO: // , EnableBrushRect, ,
// .
m_oBrush.SetBrushRect(nVal, dLeft, dTop, dWidth, dHeight);
return S_OK; return S_OK;
} }
HRESULT CPdfRenderer::BrushBounds(const double& left, const double& top, const double& width, const double& height) HRESULT CPdfRenderer::BrushBounds(const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight)
{ {
// TODO: // TODO:
return S_OK; return S_OK;
} }
HRESULT CPdfRenderer::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG lCount) HRESULT CPdfRenderer::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG lCount)
{ {
m_oBrush.SetShadingColors(lColors, pPositions, lCount); m_oBrush.SetGradientColors(lColors, pPositions, lCount);
return S_OK; return S_OK;
} }
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -541,8 +575,30 @@ HRESULT CPdfRenderer::BeginCommand(const DWORD& dwType) ...@@ -541,8 +575,30 @@ HRESULT CPdfRenderer::BeginCommand(const DWORD& dwType)
} }
HRESULT CPdfRenderer::EndCommand(const DWORD& dwType) HRESULT CPdfRenderer::EndCommand(const DWORD& dwType)
{ {
if (!IsPageValid())
return S_FALSE;
// 2 : // 2 :
// TODO: if (c_nClipType == dwType)
{
m_pPage->GrSave();
m_lClipDepth++;
UpdateTransform();
if (c_nClipRegionTypeWinding == c_nClipRegionTypeWinding)
m_oPath.Clip(m_pPage, false);
else
m_oPath.Clip(m_pPage, true);
}
else if (c_nResetClipType == dwType)
{
while (m_lClipDepth)
{
m_pPage->GrRestore();
m_lClipDepth--;
}
}
return S_OK; return S_OK;
} }
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -563,16 +619,41 @@ HRESULT CPdfRenderer::DrawPath(const LONG& lType) ...@@ -563,16 +619,41 @@ HRESULT CPdfRenderer::DrawPath(const LONG& lType)
if (!IsPageValid()) if (!IsPageValid())
return S_FALSE; return S_FALSE;
m_pPage->GrSave();
UpdateTransform();
UpdatePen();
UpdateBrush();
bool bStroke = LONG_2_BOOL(lType & c_nStroke); bool bStroke = LONG_2_BOOL(lType & c_nStroke);
bool bFill = LONG_2_BOOL(lType & c_nWindingFillMode); bool bFill = LONG_2_BOOL(lType & c_nWindingFillMode);
bool bEoFill = LONG_2_BOOL(lType & c_nEvenOddFillMode); bool bEoFill = LONG_2_BOOL(lType & c_nEvenOddFillMode);
m_oPath.Draw(m_pPage, bStroke, bFill, bEoFill); m_pPage->GrSave();
UpdateTransform();
if (bStroke)
UpdatePen();
if (bFill || bEoFill)
UpdateBrush();
if (!m_pShading)
{
m_oPath.Draw(m_pPage, bStroke, bFill, bEoFill);
}
else
{
if (bFill || bEoFill)
{
m_pPage->GrSave();
m_oPath.Clip(m_pPage, bEoFill);
if (NULL != m_pShadingExtGrState)
m_pPage->SetExtGrState(m_pShadingExtGrState);
m_pPage->DrawShading(m_pShading);
m_pPage->GrRestore();
}
if (bStroke)
m_oPath.Draw(m_pPage, bStroke, false, false);
}
m_pPage->GrRestore(); m_pPage->GrRestore();
return S_OK; return S_OK;
...@@ -763,6 +844,23 @@ HRESULT CPdfRenderer::DrawImage1bpp(Pix* pImageBuffer, const unsigned int& unWid ...@@ -763,6 +844,23 @@ HRESULT CPdfRenderer::DrawImage1bpp(Pix* pImageBuffer, const unsigned int& unWid
m_pPage->GrRestore(); m_pPage->GrRestore();
return S_OK; return S_OK;
} }
HRESULT CPdfRenderer::EnableBrushRect(const LONG& lEnable)
{
m_oBrush.EnableBrushRect(LONG_2_BOOL(lEnable));
return S_OK;
}
HRESULT CPdfRenderer::SetLinearGradient(const double& dX0, const double& dY0, const double& dX1, const double& dY1)
{
m_oBrush.SetType(c_BrushTypeLinearGradient);
m_oBrush.SetLinearGradientPattern(dX0, dY0, dX1, dY1);
return S_OK;
}
HRESULT CPdfRenderer::SetRadialGradient(const double& dX0, const double& dY0, const double& dR0, const double& dX1, const double& dY1, const double& dR1)
{
m_oBrush.SetType(c_BrushTypeRadialGradient);
m_oBrush.SetRadialGradientPattern(dX0, dY0, dR0, dX1, dY1, dR1);
return S_OK;
}
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// //
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -778,6 +876,10 @@ PdfWriter::CImageDict* CPdfRenderer::LoadImage(Aggplus::CImage* pImage, const BY ...@@ -778,6 +876,10 @@ PdfWriter::CImageDict* CPdfRenderer::LoadImage(Aggplus::CImage* pImage, const BY
if (nImageH < 100 || nImageW < 100) if (nImageH < 100 || nImageW < 100)
bJpeg = true; bJpeg = true;
// TODO: CxImage Jpeg2000,
// .. .
bJpeg = true;
// - // -
bool bAlpha = false; bool bAlpha = false;
for (int nIndex = 0, nSize = nImageW * nImageH; nIndex < nSize; nIndex++) for (int nIndex = 0, nSize = nImageW * nImageH; nIndex < nSize; nIndex++)
...@@ -793,6 +895,8 @@ PdfWriter::CImageDict* CPdfRenderer::LoadImage(Aggplus::CImage* pImage, const BY ...@@ -793,6 +895,8 @@ PdfWriter::CImageDict* CPdfRenderer::LoadImage(Aggplus::CImage* pImage, const BY
if (!oCxImage.CreateFromArray(pData, nImageW, nImageH, 32, nStride, (pImage->GetStride() >= 0) ? true : false)) if (!oCxImage.CreateFromArray(pData, nImageW, nImageH, 32, nStride, (pImage->GetStride() >= 0) ? true : false))
return NULL; return NULL;
oCxImage.SetJpegQualityF(85.0f);
BYTE* pBuffer = NULL; BYTE* pBuffer = NULL;
int nBufferSize = 0; int nBufferSize = 0;
if (!oCxImage.Encode(pBuffer, nBufferSize, bJpeg ? CXIMAGE_FORMAT_JPG : CXIMAGE_FORMAT_JP2)) if (!oCxImage.Encode(pBuffer, nBufferSize, bJpeg ? CXIMAGE_FORMAT_JPG : CXIMAGE_FORMAT_JP2))
...@@ -847,7 +951,6 @@ void CPdfRenderer::UpdateFont() ...@@ -847,7 +951,6 @@ void CPdfRenderer::UpdateFont()
if (L"" != wsFontPath) if (L"" != wsFontPath)
{ {
// TODO: , TrueType, OpenType // TODO: , TrueType, OpenType
LONG lFaceIndex = m_oFont.GetFaceIndex();
m_pFontManager->LoadFontFromFile(wsFontPath, lFaceIndex, 10, 72, 72); m_pFontManager->LoadFontFromFile(wsFontPath, lFaceIndex, 10, 72, 72);
std::wstring wsFontType = m_pFontManager->GetFontType(); std::wstring wsFontType = m_pFontManager->GetFontType();
if (L"TrueType" == wsFontType || L"OpenType" == wsFontType || L"CFF" == wsFontType) if (L"TrueType" == wsFontType || L"OpenType" == wsFontType || L"CFF" == wsFontType)
...@@ -863,6 +966,7 @@ void CPdfRenderer::UpdatePen() ...@@ -863,6 +966,7 @@ void CPdfRenderer::UpdatePen()
{ {
TColor& oColor = m_oPen.GetTColor(); TColor& oColor = m_oPen.GetTColor();
m_pPage->SetStrokeColor(oColor.r, oColor.g, oColor.b); m_pPage->SetStrokeColor(oColor.r, oColor.g, oColor.b);
m_pPage->SetStrokeAlpha((unsigned char)m_oPen.GetAlpha());
m_pPage->SetLineWidth(MM_2_PT(m_oPen.GetSize())); m_pPage->SetLineWidth(MM_2_PT(m_oPen.GetSize()));
LONG lDashCount = 0; LONG lDashCount = 0;
...@@ -920,7 +1024,11 @@ void CPdfRenderer::UpdatePen() ...@@ -920,7 +1024,11 @@ void CPdfRenderer::UpdatePen()
} }
void CPdfRenderer::UpdateBrush() void CPdfRenderer::UpdateBrush()
{ {
m_pShading = NULL;
m_pShadingExtGrState = NULL;
LONG lBrushType = m_oBrush.GetType(); LONG lBrushType = m_oBrush.GetType();
m_pDocument->GetExtGState();
if (c_BrushTypeTexture == lBrushType) if (c_BrushTypeTexture == lBrushType)
{ {
std::wstring& wsTexturePath = m_oBrush.GetTexturePath(); std::wstring& wsTexturePath = m_oBrush.GetTexturePath();
...@@ -959,11 +1067,13 @@ void CPdfRenderer::UpdateBrush() ...@@ -959,11 +1067,13 @@ void CPdfRenderer::UpdateBrush()
double dW = 10; double dW = 10;
double dH = 10; double dH = 10;
double dL, dR, dT, dB;
m_oPath.GetBounds(dL, dT, dR, dB);
if (c_BrushTextureModeStretch == lTextureMode) if (c_BrushTextureModeStretch == lTextureMode)
{ {
// //
double dL, dR, dT, dB;
m_oPath.GetBounds(dL, dT, dR, dB);
dW = max(10, dR - dL); dW = max(10, dR - dL);
dH = max(10, dB - dT); dH = max(10, dB - dT);
} }
...@@ -972,9 +1082,15 @@ void CPdfRenderer::UpdateBrush() ...@@ -972,9 +1082,15 @@ void CPdfRenderer::UpdateBrush()
// . - . // . - .
dW = nImageW * 72 / 96; dW = nImageW * 72 / 96;
dH = nImageH * 72 / 96; dH = nImageH * 72 / 96;
} }
m_pPage->SetPatternColorSpace(m_pDocument->CreateImageTilePattern(dW, dH, pImage)); // , .
CMatrix* pMatrix = m_pPage->GetTransform();
pMatrix->Apply(dL, dB);
CMatrix oPatternMatrix = *pMatrix;
oPatternMatrix.x = dL;
oPatternMatrix.y = dB;
m_pPage->SetPatternColorSpace(m_pDocument->CreateImageTilePattern(dW, dH, pImage, &oPatternMatrix));
} }
} }
else if (c_BrushTypeHatch1 == lBrushType) else if (c_BrushTypeHatch1 == lBrushType)
...@@ -991,12 +1107,65 @@ void CPdfRenderer::UpdateBrush() ...@@ -991,12 +1107,65 @@ void CPdfRenderer::UpdateBrush()
m_pPage->SetPatternColorSpace(m_pDocument->CreateHatchPattern(dW, dH, oColor1.r, oColor1.g, oColor1.b, nAlpha1, oColor2.r, oColor2.g, oColor2.b, nAlpha2, wsHatchType)); m_pPage->SetPatternColorSpace(m_pDocument->CreateHatchPattern(dW, dH, oColor1.r, oColor1.g, oColor1.b, nAlpha1, oColor2.r, oColor2.g, oColor2.b, nAlpha2, wsHatchType));
} }
else if (c_BrushTypeRadialGradient == lBrushType || c_BrushTypeLinearGradient == lBrushType)
{
TColor* pGradientColors;
double* pPoints;
LONG lCount;
m_oBrush.GetGradientColors(pGradientColors, pPoints, lCount);
if (lCount > 0)
{
unsigned char* pColors = new unsigned char[3 * lCount];
unsigned char* pAlphas = new unsigned char[lCount];
if (pColors)
{
for (LONG lIndex = 0; lIndex < lCount; lIndex++)
{
pColors[3 * lIndex + 0] = pGradientColors[lIndex].r;
pColors[3 * lIndex + 1] = pGradientColors[lIndex].g;
pColors[3 * lIndex + 2] = pGradientColors[lIndex].b;
pAlphas[lIndex] = pGradientColors[lIndex].a;
}
if (c_BrushTypeLinearGradient == lBrushType)
{
double dX0, dY0, dX1, dY1;
m_oBrush.GetLinearGradientPattern(dX0, dY0, dX1, dY1);
m_pShading = m_pDocument->CreateAxialShading(m_pPage, MM_2_PT(dX0), MM_2_PT(m_dPageHeight - dY0), MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), pColors, pAlphas, pPoints, lCount, m_pShadingExtGrState);
}
else //if (c_BrushTypeRadialGradient == lBrushType)
{
double dX0, dY0, dR0, dX1, dY1, dR1;
m_oBrush.GetRadialGradientPattern(dX0, dY0, dR0, dX1, dY1, dR1);
m_pShading = m_pDocument->CreateRadialShading(m_pPage, MM_2_PT(dX0), MM_2_PT(m_dPageHeight - dY0), MM_2_PT(dR0), MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), MM_2_PT(dR1), pColors, pAlphas, pPoints, lCount, m_pShadingExtGrState);
}
delete[] pColors;
}
}
}
else// if (c_BrushTypeSolid == lBrushType) else// if (c_BrushTypeSolid == lBrushType)
{ {
TColor& oColor1 = m_oBrush.GetTColor1(); TColor& oColor1 = m_oBrush.GetTColor1();
m_pPage->SetFillColor(oColor1.r, oColor1.g, oColor1.b); m_pPage->SetFillColor(oColor1.r, oColor1.g, oColor1.b);
m_pPage->SetFillAlpha((unsigned char)m_oBrush.GetAlpha1());
} }
} }
HRESULT CPdfRenderer::OnlineWordToPdf (const std::wstring& wsSrcFile, const std::wstring& wsDstFile)
{
if (!NSOnlineOfficeBinToPdf::ConvertBinToPdf(this, wsSrcFile, wsDstFile, false))
return S_FALSE;
return S_OK;
}
HRESULT CPdfRenderer::OnlineWordToPdfFromBinary(const std::wstring& wsSrcFile, const std::wstring& wsDstFile)
{
if (!NSOnlineOfficeBinToPdf::ConvertBinToPdf(this, wsSrcFile, wsDstFile, true))
return S_FALSE;
return S_OK;
}
static inline void UpdateMaxMinPoints(double& dMinX, double& dMinY, double& dMaxX, double& dMaxY, const double& dX, const double& dY) static inline void UpdateMaxMinPoints(double& dMinX, double& dMinY, double& dMaxX, double& dMaxY, const double& dX, const double& dY)
{ {
...@@ -1033,6 +1202,21 @@ void CPdfRenderer::CPath::Draw(PdfWriter::CPage* pPage, bool bStroke, bool bFill ...@@ -1033,6 +1202,21 @@ void CPdfRenderer::CPath::Draw(PdfWriter::CPage* pPage, bool bStroke, bool bFill
else else
pPage->EndPath(); pPage->EndPath();
} }
void CPdfRenderer::CPath::Clip(PdfWriter::CPage* pPage, bool bEvenOdd)
{
for (int nIndex = 0, nCount = m_vCommands.size(); nIndex < nCount; nIndex++)
{
CPathCommandBase* pCommand = m_vCommands.at(nIndex);
pCommand->Draw(pPage);
}
if (bEvenOdd)
pPage->Eoclip();
else
pPage->Clip();
pPage->EndPath();
}
void CPdfRenderer::CPath::GetLastPoint(double& dX, double& dY) void CPdfRenderer::CPath::GetLastPoint(double& dX, double& dY)
{ {
dX = 0; dX = 0;
...@@ -1143,4 +1327,27 @@ void CPdfRenderer::CPath::CPathTextEx::Draw(PdfWriter::CPage* pPage) ...@@ -1143,4 +1327,27 @@ void CPdfRenderer::CPath::CPathTextEx::Draw(PdfWriter::CPage* pPage)
void CPdfRenderer::CPath::CPathTextEx::UpdateBounds(double& dL, double& dT, double& dR, double& dB) void CPdfRenderer::CPath::CPathTextEx::UpdateBounds(double& dL, double& dT, double& dR, double& dB)
{ {
// TODO: // TODO:
}
void CPdfRenderer::CBrushState::Reset()
{
m_lType = c_BrushTypeSolid;
m_oColor1.Set(0);
m_oColor2.Set(0);
m_nAlpha1 = 255;
m_nAlpha2 = 255;
m_wsTexturePath = L"";
m_lTextureMode = c_BrushTextureModeStretch;
m_nTextureAlpha = 255;
m_dLinearAngle = 0;
m_oRect.Reset();
if (m_pShadingColors)
delete[] m_pShadingColors;
if (m_pShadingPoints)
delete[] m_pShadingPoints;
m_pShadingColors = NULL;
m_pShadingPoints = NULL;
m_lShadingPointsCount = 0;
} }
\ No newline at end of file
PdfWriter/PdfRenderer.h
View file @ f4fde172
...@@ -14,6 +14,8 @@ namespace PdfWriter ...@@ -14,6 +14,8 @@ namespace PdfWriter
class CPage; class CPage;
class CFontCidTrueType; class CFontCidTrueType;
class CImageDict; class CImageDict;
class CShading;
class CExtGrState;
} }
namespace Aggplus namespace Aggplus
...@@ -29,7 +31,11 @@ class CPdfRenderer : public IRenderer ...@@ -29,7 +31,11 @@ class CPdfRenderer : public IRenderer
public: public:
CPdfRenderer(CApplicationFonts* pAppFonts); CPdfRenderer(CApplicationFonts* pAppFonts);
~CPdfRenderer(); ~CPdfRenderer();
void SaveToFile(const std::wstring& wsPath); void SaveToFile(const std::wstring& wsPath);
void SetTempFolder(const std::wstring& wsPath);
std::wstring GetTempFile();
void SetThemesPlace(const std::wstring& wsThemesPlace);
std::wstring GetThemesPlace();
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// //
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -89,8 +95,8 @@ public: ...@@ -89,8 +95,8 @@ public:
virtual HRESULT put_BrushTextureAlpha(const LONG& lAlpha); virtual HRESULT put_BrushTextureAlpha(const LONG& lAlpha);
virtual HRESULT get_BrushLinearAngle(double* dAngle); virtual HRESULT get_BrushLinearAngle(double* dAngle);
virtual HRESULT put_BrushLinearAngle(const double& dAngle); virtual HRESULT put_BrushLinearAngle(const double& dAngle);
virtual HRESULT BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height); virtual HRESULT BrushRect(const INT& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight);
virtual HRESULT BrushBounds(const double& left, const double& top, const double& width, const double& height); virtual HRESULT BrushBounds(const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight);
virtual HRESULT put_BrushGradientColors(LONG* pColors, double* pPositions, LONG lCount); virtual HRESULT put_BrushGradientColors(LONG* pColors, double* pPositions, LONG lCount);
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// //
...@@ -164,12 +170,18 @@ public: ...@@ -164,12 +170,18 @@ public:
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// Pdf // Pdf
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
virtual HRESULT CommandDrawTextPdf(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const std::wstring& wsSrcCodeText, const double& dX, const double& dY, const double& dW, const double& dH, const double& dBaselineOffset, const DWORD& dwFlags); HRESULT CommandDrawTextPdf(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const std::wstring& wsSrcCodeText, const double& dX, const double& dY, const double& dW, const double& dH, const double& dBaselineOffset, const DWORD& dwFlags);
virtual HRESULT PathCommandTextPdf(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const std::wstring& bsSrcCodeText, const double& dX, const double& dY, const double& dW, const double& dH, const double& dBaselineOffset, const DWORD& dwFlags); HRESULT PathCommandTextPdf(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const std::wstring& bsSrcCodeText, const double& dX, const double& dY, const double& dW, const double& dH, const double& dBaselineOffset, const DWORD& dwFlags);
virtual HRESULT DrawImage1bpp(Pix* pImageBuffer, const unsigned int& unWidth, const unsigned int& unHeight, const double& dX, const double& dY, const double& dW, const double& dH); HRESULT DrawImage1bpp(Pix* pImageBuffer, const unsigned int& unWidth, const unsigned int& unHeight, const double& dX, const double& dY, const double& dW, const double& dH);
HRESULT EnableBrushRect(const LONG& lEnable);
HRESULT SetLinearGradient(const double& dX1, const double& dY1, const double& dX2, const double& dY2);
HRESULT SetRadialGradient(const double& dX1, const double& dY1, const double& dR1, const double& dX2, const double& dY2, const double& dR2);
HRESULT OnlineWordToPdf (const std::wstring& wsSrcFile, const std::wstring& wsDstFile);
HRESULT OnlineWordToPdfFromBinary(const std::wstring& wsSrcFile, const std::wstring& wsDstFile);
private: private:
void OnlineWordToPdfInternal(BYTE* dstArray, LONG lLen, const std::wstring& wsHtmlPlace, std::wstring& wsHypers, int& nCountPages, const std::wstring& wsTempLogo, LONG lReg);
PdfWriter::CImageDict* LoadImage(Aggplus::CImage* pImage, const BYTE& nAlpha); PdfWriter::CImageDict* LoadImage(Aggplus::CImage* pImage, const BYTE& nAlpha);
bool DrawImage(Aggplus::CImage* pImage, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha); bool DrawImage(Aggplus::CImage* pImage, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha);
void UpdateFont(); void UpdateFont();
...@@ -202,10 +214,11 @@ private: ...@@ -202,10 +214,11 @@ private:
r = 0; r = 0;
g = 0; g = 0;
b = 0; b = 0;
a = 255;
} }
TColor(const LONG& lColor) TColor(const LONG& _lColor)
{ {
Set(lColor); Set(_lColor);
} }
void Set(const LONG& _lColor) void Set(const LONG& _lColor)
...@@ -215,24 +228,27 @@ private: ...@@ -215,24 +228,27 @@ private:
r = (unsigned char)(lColor & 0xFF); r = (unsigned char)(lColor & 0xFF);
g = (unsigned char)((lColor >> 8) & 0xFF); g = (unsigned char)((lColor >> 8) & 0xFF);
b = (unsigned char)((lColor >> 16) & 0xFF); b = (unsigned char)((lColor >> 16) & 0xFF);
a = (unsigned char)((lColor >> 24) & 0xFF);
} }
void operator=(const LONG& _lColor) void operator=(const LONG& _lColor)
{ {
Set(lColor); Set(_lColor);
} }
void Set(BYTE _r, BYTE _g, BYTE _b) void Set(BYTE _r, BYTE _g, BYTE _b, BYTE _a = 255)
{ {
r = _r; r = _r;
g = _g; g = _g;
b = _b; b = _b;
a = _a;
lColor = (LONG)(((LONG)r) | ((LONG)g << 8) | ((LONG)b << 16) | ((LONG)0 << 24)); lColor = (LONG)(((LONG)r) | ((LONG)g << 8) | ((LONG)b << 16) | ((LONG)a << 24));
} }
LONG lColor; LONG lColor;
BYTE r; BYTE r;
BYTE g; BYTE g;
BYTE b; BYTE b;
BYTE a;
}; };
class CPenState class CPenState
{ {
...@@ -369,9 +385,16 @@ private: ...@@ -369,9 +385,16 @@ private:
delete[] m_pDashPattern; delete[] m_pDashPattern;
m_oColor.Set(0); m_oColor.Set(0);
m_dSize = 0; m_dSize = 0;
m_nAlpha = 255; m_nAlpha = 255;
m_nDashStyle = 0; m_nStartCapStyle = Aggplus::LineCapRound;
m_nEndCapStyle = Aggplus::LineCapRound;
m_nJoinStyle = Aggplus::LineJoinRound;
m_lAlign = 0;
m_dMiter = 0;
m_nDashStyle = Aggplus::DashStyleSolid;
m_lDashPatternSize = 0; m_lDashPatternSize = 0;
m_pDashPattern = NULL; m_pDashPattern = NULL;
} }
...@@ -402,6 +425,7 @@ private: ...@@ -402,6 +425,7 @@ private:
m_pShadingColors = NULL; m_pShadingColors = NULL;
m_pShadingPoints = NULL; m_pShadingPoints = NULL;
m_lShadingPointsCount = 0; m_lShadingPointsCount = 0;
Reset();
} }
~CBrushState() ~CBrushState()
{ {
...@@ -410,6 +434,7 @@ private: ...@@ -410,6 +434,7 @@ private:
if (m_pShadingPoints) if (m_pShadingPoints)
delete[] m_pShadingPoints; delete[] m_pShadingPoints;
} }
void Reset();
inline LONG GetType() inline LONG GetType()
{ {
return m_lType; return m_lType;
...@@ -490,7 +515,7 @@ private: ...@@ -490,7 +515,7 @@ private:
{ {
m_dLinearAngle = dAngle; m_dLinearAngle = dAngle;
} }
inline void SetShadingColors(LONG* pColors, double* pPoints, const LONG& lCount) inline void SetGradientColors(LONG* pColors, double* pPoints, const LONG& lCount)
{ {
// , 0 1 . // , 0 1 .
if (m_pShadingColors) if (m_pShadingColors)
...@@ -539,8 +564,8 @@ private: ...@@ -539,8 +564,8 @@ private:
if (-1 == lMinIn || dPoint < vPoints.at(lMinIn).dPoint) if (-1 == lMinIn || dPoint < vPoints.at(lMinIn).dPoint)
lMinIn = lIndex; lMinIn = lIndex;
if (-1 == lMaxOut || dPoint > vPoints.at(lMaxOut).dPoint) if (-1 == lMaxIn || dPoint > vPoints.at(lMaxIn).dPoint)
lMaxOut = lIndex; lMaxIn = lIndex;
} }
else if (dPoint < 0) else if (dPoint < 0)
{ {
...@@ -689,6 +714,56 @@ private: ...@@ -689,6 +714,56 @@ private:
} }
} }
} }
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;
}
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;
}
private: private:
...@@ -728,9 +803,10 @@ private: ...@@ -728,9 +803,10 @@ private:
BYTE r = (BYTE)max(0, min(255, (oColor1.r + (oColor2.r - oColor1.r) / dDiff * (dDstPoint - dPoint1)))); BYTE r = (BYTE)max(0, min(255, (oColor1.r + (oColor2.r - oColor1.r) / dDiff * (dDstPoint - dPoint1))));
BYTE g = (BYTE)max(0, min(255, (oColor1.g + (oColor2.g - oColor1.g) / dDiff * (dDstPoint - dPoint1)))); BYTE g = (BYTE)max(0, min(255, (oColor1.g + (oColor2.g - oColor1.g) / dDiff * (dDstPoint - dPoint1))));
BYTE b = (BYTE)max(0, min(255, (oColor1.b + (oColor2.b - oColor1.b) / dDiff * (dDstPoint - dPoint1)))); BYTE b = (BYTE)max(0, min(255, (oColor1.b + (oColor2.b - oColor1.b) / dDiff * (dDstPoint - dPoint1))));
BYTE a = (BYTE)max(0, min(255, (oColor1.a + (oColor2.a - oColor1.a) / dDiff * (dDstPoint - dPoint1))));
TColor oResColor; TColor oResColor;
oResColor.Set(r, g, b); oResColor.Set(r, g, b, a);
return oResColor.lColor; return oResColor.lColor;
} }
...@@ -738,6 +814,30 @@ private: ...@@ -738,6 +814,30 @@ private:
double dPoint; double dPoint;
bool bUse; 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;
};
private: private:
...@@ -750,10 +850,12 @@ private: ...@@ -750,10 +850,12 @@ private:
LONG m_lTextureMode; LONG m_lTextureMode;
BYTE m_nTextureAlpha; BYTE m_nTextureAlpha;
double m_dLinearAngle; double m_dLinearAngle;
TBrushRect m_oRect;
TColor* m_pShadingColors; TColor* m_pShadingColors;
double* m_pShadingPoints; double* m_pShadingPoints;
LONG m_lShadingPointsCount; LONG m_lShadingPointsCount;
double m_pShadingPattern[6]; // x0, y0, x1, y1 (2 ), x0, y0, r0, x1, y1, r1
}; };
class CFontState class CFontState
{ {
...@@ -764,6 +866,19 @@ private: ...@@ -764,6 +866,19 @@ private:
{ {
} }
void Reset()
{
m_wsPath = L"";
m_wsName = L"Arial";
m_lStyle = 0;
m_bBold = false;
m_bItalic = false;
m_dCharSpace = 0;
m_lFaceIndex = 0;
m_dSize = 10;
m_bGid = false;
}
inline std::wstring GetName() inline std::wstring GetName()
{ {
return m_wsName; return m_wsName;
...@@ -1228,6 +1343,7 @@ private: ...@@ -1228,6 +1343,7 @@ private:
} }
void GetLastPoint(double& dX, double& dY); void GetLastPoint(double& dX, double& dY);
void Draw(PdfWriter::CPage* pPage, bool bStroke, bool bFill, bool bEoFill); 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 GetBounds(double& dL, double& dT, double& dR, double& dB);
private: private:
...@@ -1290,10 +1406,14 @@ private: ...@@ -1290,10 +1406,14 @@ private:
CApplicationFonts* m_pAppFonts; CApplicationFonts* m_pAppFonts;
CFontManager* m_pFontManager; CFontManager* m_pFontManager;
std::wstring m_wsTempFolder;
std::wstring m_wsThemesPlace;
PdfWriter::CDocument* m_pDocument; PdfWriter::CDocument* m_pDocument;
PdfWriter::CPage* m_pPage; PdfWriter::CPage* m_pPage;
PdfWriter::CFontCidTrueType* m_pFont; PdfWriter::CFontCidTrueType* m_pFont;
PdfWriter::CShading* m_pShading;
PdfWriter::CExtGrState* m_pShadingExtGrState;
CPenState m_oPen; CPenState m_oPen;
CBrushState m_oBrush; CBrushState m_oBrush;
...@@ -1303,6 +1423,7 @@ private: ...@@ -1303,6 +1423,7 @@ private:
LONG m_lClipMode; LONG m_lClipMode;
double m_dPageHeight; double m_dPageHeight;
double m_dPageWidth; double m_dPageWidth;
LONG m_lClipDepth;
bool m_bValid; bool m_bValid;
......
PdfWriter/PdfWriter.vcxproj
View file @ f4fde172
...@@ -141,6 +141,7 @@ ...@@ -141,6 +141,7 @@
<Text Include="ReadMe.txt" /> <Text Include="ReadMe.txt" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="OnlineOfficeBinToPdf.cpp" />
<ClCompile Include="PdfRenderer.cpp" /> <ClCompile Include="PdfRenderer.cpp" />
<ClCompile Include="Src\Annotation.cpp" /> <ClCompile Include="Src\Annotation.cpp" />
<ClCompile Include="Src\Catalog.cpp" /> <ClCompile Include="Src\Catalog.cpp" />
...@@ -164,6 +165,7 @@ ...@@ -164,6 +165,7 @@
<ClCompile Include="Src\Utils.cpp" /> <ClCompile Include="Src\Utils.cpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="OnlineOfficeBinToPdf.h" />
<ClInclude Include="PdfRenderer.h" /> <ClInclude Include="PdfRenderer.h" />
<ClInclude Include="Src\Annotation.h" /> <ClInclude Include="Src\Annotation.h" />
<ClInclude Include="Src\Catalog.h" /> <ClInclude Include="Src\Catalog.h" />
......
PdfWriter/PdfWriter.vcxproj.filters
View file @ f4fde172
...@@ -90,6 +90,9 @@ ...@@ -90,6 +90,9 @@
<ClCompile Include="PdfRenderer.cpp"> <ClCompile Include="PdfRenderer.cpp">
<Filter>Src</Filter> <Filter>Src</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="OnlineOfficeBinToPdf.cpp">
<Filter>Src</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="Src\Annotation.h"> <ClInclude Include="Src\Annotation.h">
...@@ -161,5 +164,8 @@ ...@@ -161,5 +164,8 @@
<ClInclude Include="PdfRenderer.h"> <ClInclude Include="PdfRenderer.h">
<Filter>Src</Filter> <Filter>Src</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="OnlineOfficeBinToPdf.h">
<Filter>Src</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>
\ No newline at end of file
PdfWriter/PdfWriterTest/PdfWriterTest.cpp
View file @ f4fde172
...@@ -381,7 +381,9 @@ void TestDocument3() ...@@ -381,7 +381,9 @@ void TestDocument3()
pPage->ClosePath(); pPage->ClosePath();
pPage->EoFillStroke(); pPage->EoFillStroke();
pPage->SetExtGrState(oPdf.GetExtGState(0.8, 0.8)); //pPage->SetExtGrState(oPdf.GetExtGState(0.8, 0.8));
pPage->SetStrokeAlpha(20);
pPage->SetFillAlpha(20);
pPage->SetFillColor(15, 15, 120); pPage->SetFillColor(15, 15, 120);
pPage->MoveTo(230, 210); pPage->MoveTo(230, 210);
pPage->LineTo(320, 210); pPage->LineTo(320, 210);
...@@ -404,7 +406,9 @@ void TestDocument3() ...@@ -404,7 +406,9 @@ void TestDocument3()
pPage->Clip(); pPage->Clip();
pPage->EndPath(); pPage->EndPath();
pPage->SetExtGrState(oPdf.GetExtGState(0.5, 0.5)); pPage->SetStrokeAlpha(122);
pPage->SetFillAlpha(122);
//pPage->SetExtGrState(oPdf.GetExtGState(0.5, 0.5));
pPage->MoveTo(230, 310); pPage->MoveTo(230, 310);
pPage->LineTo(320, 310); pPage->LineTo(320, 310);
pPage->LineTo(320, 340); pPage->LineTo(320, 340);
...@@ -749,9 +753,11 @@ void TestDocument8() ...@@ -749,9 +753,11 @@ void TestDocument8()
0, 0, 255 0, 0, 255
}; };
double pPoints[] ={0, 1}; unsigned char pAlphas[] ={ 255, 255 };
CExtGrState* pExtGrState = NULL;
CShading* pShading = oPdf.CreateAxialShading(200, 150, 200, 250, pColors, pPoints, 2); double pPoints[] ={0, 1};
CShading* pShading = oPdf.CreateAxialShading(pPage, 200, 150, 200, 250, pColors, pAlphas, pPoints, 2, pExtGrState);
pPage->DrawShading(pShading); pPage->DrawShading(pShading);
pPage->GrRestore(); pPage->GrRestore();
...@@ -768,10 +774,11 @@ void TestDocument8() ...@@ -768,10 +774,11 @@ void TestDocument8()
255, 255, 255, 255, 255, 255,
0, 0, 255 0, 0, 255
}; };
unsigned char pAlphas2[] ={ 255, 255, 255, 255 };
double pPoints2[] ={ 0, 0.3, 0.7, 1 }; double pPoints2[] ={ 0, 0.3, 0.7, 1 };
CShading* pShading2 = oPdf.CreateAxialShading(400, 150, 400, 250, pColors2, pPoints2, nCount2); CShading* pShading2 = oPdf.CreateAxialShading(pPage, 400, 150, 400, 250, pColors2, pAlphas2, pPoints2, nCount2, pExtGrState);
pPage->DrawShading(pShading2); pPage->DrawShading(pShading2);
pPage->GrRestore(); pPage->GrRestore();
...@@ -788,10 +795,11 @@ void TestDocument8() ...@@ -788,10 +795,11 @@ void TestDocument8()
255, 255, 0, 255, 255, 0,
0, 0, 255 0, 0, 255
}; };
unsigned char pAlphas3[] ={ 255, 255, 255 };
double pPoints3[] ={ 0, 0.5, 1 }; double pPoints3[] ={ 0, 0.5, 1 };
CShading* pShading3 = oPdf.CreateRaidalShading(200, 375, 20, 200, 425, 100, pColors3, pPoints3, nCount3); CShading* pShading3 = oPdf.CreateRadialShading(pPage, 200, 375, 20, 200, 425, 100, pColors3, pAlphas3, pPoints3, nCount3, pExtGrState);
pPage->DrawShading(pShading3); pPage->DrawShading(pShading3);
pPage->GrRestore(); pPage->GrRestore();
...@@ -814,7 +822,7 @@ void TestDocument9() ...@@ -814,7 +822,7 @@ void TestDocument9()
CImageDict* pJpegImage = oPdf.CreateImage(); CImageDict* pJpegImage = oPdf.CreateImage();
pJpegImage->LoadJpeg(L"D:/Test Files/Test.jpg", 600, 400); pJpegImage->LoadJpeg(L"D:/Test Files/Test.jpg", 600, 400);
CImageTilePattern* pPattern = oPdf.CreateImageTilePattern(70, 70, pJpegImage, imagetilepatterntype_InverseX); CImageTilePattern* pPattern = oPdf.CreateImageTilePattern(70, 70, pJpegImage, NULL, imagetilepatterntype_InverseX);
pPage->GrSave(); pPage->GrSave();
pPage->SetPatternColorSpace(pPattern); pPage->SetPatternColorSpace(pPattern);
...@@ -908,6 +916,27 @@ void TestMetafile() ...@@ -908,6 +916,27 @@ void TestMetafile()
//ConvertFolder(L"D://Test Files//Emf//", MetaFile::c_lMetaEmf); //ConvertFolder(L"D://Test Files//Emf//", MetaFile::c_lMetaEmf);
ConvertFolder(L"D://Test Files//Wmf//", MetaFile::c_lMetaWmf); ConvertFolder(L"D://Test Files//Wmf//", MetaFile::c_lMetaWmf);
} }
void TestOnlineBin()
{
std::wstring wsFolderPath = L"D://Test Files//Txt//";
CApplicationFonts oFonts;
oFonts.Initialize();
double dPx2Mm = 25.4 / 96;
std::vector<std::wstring> vFiles = GetAllFilesInFolder(wsFolderPath, L"txt");
for (int nIndex = 0; nIndex < vFiles.size(); nIndex++)
{
std::wstring wsFilePath = wsFolderPath;
wsFilePath.append(vFiles.at(nIndex));
std::wstring wsOutPath = wsFolderPath + L"Out.pdf";
CPdfRenderer oRenderer(&oFonts);
oRenderer.OnlineWordToPdf(wsFilePath, wsOutPath);
printf("%d of %d %S\n", nIndex, vFiles.size(), vFiles.at(nIndex).c_str());
}
}
void main() void main()
{ {
...@@ -924,6 +953,6 @@ void main() ...@@ -924,6 +953,6 @@ void main()
//TestDocument7(); //TestDocument7();
//TestDocument8(); //TestDocument8();
//TestDocument9(); //TestDocument9();
//TestMetafile();
TestMetafile(); TestOnlineBin();
} }
PdfWriter/Src/Document.cpp
View file @ f4fde172
...@@ -43,6 +43,7 @@ namespace PdfWriter ...@@ -43,6 +43,7 @@ namespace PdfWriter
m_unCompressMode = COMP_NONE; m_unCompressMode = COMP_NONE;
m_pJbig2 = NULL; m_pJbig2 = NULL;
memset((void*)m_sTTFontTag, 0x00, 8); memset((void*)m_sTTFontTag, 0x00, 8);
m_pTransparencyGroup = NULL;
} }
CDocument::~CDocument() CDocument::~CDocument()
{ {
...@@ -65,7 +66,7 @@ namespace PdfWriter ...@@ -65,7 +66,7 @@ namespace PdfWriter
return false; return false;
m_pCatalog->SetPageMode(pagemode_UseNone); m_pCatalog->SetPageMode(pagemode_UseNone);
m_pCatalog->SetPageLayout(pagelayout_Single); m_pCatalog->SetPageLayout(pagelayout_OneColumn);
m_pPageTree = m_pCatalog->GetRoot(); m_pPageTree = m_pCatalog->GetRoot();
if (!m_pPageTree) if (!m_pPageTree)
...@@ -81,6 +82,11 @@ namespace PdfWriter ...@@ -81,6 +82,11 @@ namespace PdfWriter
m_nCurPageNum = -1; m_nCurPageNum = -1;
m_vPages.clear(); m_vPages.clear();
m_vExtGrStates.clear();
m_vFillAlpha.clear();
m_vStrokeAlpha.clear();
m_pTransparencyGroup = NULL;
return true; return true;
} }
...@@ -186,7 +192,7 @@ namespace PdfWriter ...@@ -186,7 +192,7 @@ namespace PdfWriter
} }
CPage* CDocument::AddPage() CPage* CDocument::AddPage()
{ {
CPage* pPage = new CPage(m_pXref, m_pPageTree); CPage* pPage = new CPage(m_pXref, m_pPageTree, this);
m_pPageTree->AddPage(pPage); m_pPageTree->AddPage(pPage);
m_pCurPage = pPage; m_pCurPage = pPage;
m_vPages.push_back(pPage); m_vPages.push_back(pPage);
...@@ -330,6 +336,44 @@ namespace PdfWriter ...@@ -330,6 +336,44 @@ namespace PdfWriter
return pExtGrState; return pExtGrState;
} }
CExtGrState* CDocument::GetStrokeAlpha(double dAlpha)
{
CExtGrState* pExtGrState = NULL;
for (unsigned int unIndex = 0, unCount = m_vStrokeAlpha.size(); unIndex < unCount; unIndex++)
{
pExtGrState = m_vStrokeAlpha.at(unIndex);
if (abs(dAlpha - pExtGrState->GetAlphaStroke()) < 0.001)
return pExtGrState;
}
pExtGrState = new CExtGrState(m_pXref);
if (!pExtGrState)
return NULL;
pExtGrState->SetAlphaStroke(dAlpha);
m_vStrokeAlpha.push_back(pExtGrState);
return pExtGrState;
}
CExtGrState* CDocument::GetFillAlpha(double dAlpha)
{
CExtGrState* pExtGrState = NULL;
for (unsigned int unIndex = 0, unCount = m_vFillAlpha.size(); unIndex < unCount; unIndex++)
{
pExtGrState = m_vFillAlpha.at(unIndex);
if (abs(dAlpha == pExtGrState->GetAlphaFill()) < 0.001)
return pExtGrState;
}
pExtGrState = new CExtGrState(m_pXref);
if (!pExtGrState)
return NULL;
pExtGrState->SetAlphaFill(dAlpha);
m_vFillAlpha.push_back(pExtGrState);
return pExtGrState;
}
CAnnotation* CDocument::CreateTextAnnot(unsigned int unPageNum, TRect oRect, const char* sText) CAnnotation* CDocument::CreateTextAnnot(unsigned int unPageNum, TRect oRect, const char* sText)
{ {
CAnnotation* pAnnot = new CTextAnnotation(m_pXref, oRect, sText); CAnnotation* pAnnot = new CTextAnnotation(m_pXref, oRect, sText);
...@@ -423,6 +467,96 @@ namespace PdfWriter ...@@ -423,6 +467,96 @@ namespace PdfWriter
return m_pJbig2; return m_pJbig2;
} }
CShading* CDocument::CreateShading(CPage* pPage, double *pPattern, bool bAxial, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState)
{
pExtGrState = NULL;
bool bNeedAlpha = false;
unsigned char* pA = new unsigned char[3 * nCount];
if (!pA)
return NULL;
for (int nIndex = 0; nIndex < nCount; nIndex++)
{
pA[3 * nIndex + 0] = pAlphas[nIndex];
pA[3 * nIndex + 1] = pAlphas[nIndex];
pA[3 * nIndex + 2] = pAlphas[nIndex];
if (255 != pAlphas[nIndex])
bNeedAlpha = true;
}
if (!bNeedAlpha)
{
delete[] pA;
if (bAxial)
return CreateAxialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pColors, pPoints, nCount);
else
return CreateRadialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pPattern[4], pPattern[5], pColors, pPoints, nCount);
}
// Создаем 2 shading-объекта, один цветной RGB, второй серый со значениями альфа-канала
CShading* pColorShading = NULL;
CShading* pAlphaShading = NULL;
if (bAxial)
{
pColorShading = CreateAxialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pColors, pPoints, nCount);
pAlphaShading = CreateAxialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pA, pPoints, nCount);
}
else
{
pColorShading = CreateRadialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pPattern[4], pPattern[5], pColors, pPoints, nCount);
pAlphaShading = CreateRadialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pPattern[4], pPattern[5], pA, pPoints, nCount);
}
delete[] pA;
if (!m_pTransparencyGroup)
{
m_pTransparencyGroup = new CDictObject();
m_pTransparencyGroup->Add("Type", "Group");
m_pTransparencyGroup->Add("S", "Transparency");
m_pTransparencyGroup->Add("CS", "DeviceRGB");
}
pPage->Add("Group", m_pTransparencyGroup);
double dWidth = pPage->GetWidth();
double dHeight = pPage->GetHeight();
// Создаем графический объект, который будет альфа-маской
CDictObject* pXObject = new CDictObject(m_pXref, true);
pXObject->Add("Type", "XObject");
pXObject->Add("Subtype", "Form");
pXObject->Add("BBox", CArrayObject::CreateBox(0, 0, dWidth, dHeight));
pXObject->Add("Group", m_pTransparencyGroup);
CDictObject* pResources = new CDictObject();
pXObject->Add("Resources", pResources);
CDictObject* pResShadings = new CDictObject();
pResources->Add("Shading", pResShadings);
pResShadings->Add("S1", pAlphaShading);
CStream* pStream = pXObject->GetStream();
pStream->WriteStr("0 0 ");
pStream->WriteReal(dWidth);
pStream->WriteChar(' ');
pStream->WriteReal(dHeight);
pStream->WriteStr(" re\012W\012\n\012/S1 sh\012");
// Создаем обект-маску для графического состояние
CDictObject* pMask = new CDictObject();
m_pXref->Add(pMask);
pMask->Add("Type", "Mask");
pMask->Add("S", "Luminosity");
pMask->Add("G", pXObject);
// Создаем ExtGState объект, в который мы запишем альфа-маску
pExtGrState = new CExtGrState(m_pXref);
pExtGrState->Add("BM", "Normal");
pExtGrState->Add("ca", 1);
pExtGrState->Add("SMask", pMask);
return pColorShading;
}
CShading* CDocument::CreateAxialShading(double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, double* pPoints, int nCount) CShading* CDocument::CreateAxialShading(double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, double* pPoints, int nCount)
{ {
for (int nIndex = 0, nShadingsCount = m_vShadings.size(); nIndex < nShadingsCount; nIndex++) for (int nIndex = 0, nShadingsCount = m_vShadings.size(); nIndex < nShadingsCount; nIndex++)
...@@ -430,7 +564,7 @@ namespace PdfWriter ...@@ -430,7 +564,7 @@ namespace PdfWriter
CShading* pShading = m_vShadings.at(nIndex); CShading* pShading = m_vShadings.at(nIndex);
if (shadingtype_Axial == pShading->GetShadingType() if (shadingtype_Axial == pShading->GetShadingType()
&& ((CAxialShading*)pShading)->Compare(dX0, dY0, dX1, dY1) && ((CAxialShading*)pShading)->Compare(dX0, dY0, dX1, dY1)
&& pShading->CompareColors(pColors, pPoints, nCount) && pShading->CompareColors(pColors, pPoints, nCount, true)
&& pShading->CompareExtend(true, true)) && pShading->CompareExtend(true, true))
return pShading; return pShading;
} }
...@@ -439,21 +573,21 @@ namespace PdfWriter ...@@ -439,21 +573,21 @@ namespace PdfWriter
if (!pShading) if (!pShading)
return NULL; return NULL;
pShading->SetColors(pColors, pPoints, nCount); pShading->SetRgbColors(pColors, pPoints, nCount);
pShading->SetExtend(true, true); pShading->SetExtend(true, true);
m_vShadings.push_back(pShading); m_vShadings.push_back(pShading);
return pShading; return pShading;
} }
CShading* CDocument::CreateRaidalShading(double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, double* pPoints, int nCount) CShading* CDocument::CreateRadialShading(double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, double* pPoints, int nCount)
{ {
for (int nIndex = 0, nShadingsCount = m_vShadings.size(); nIndex < nShadingsCount; nIndex++) for (int nIndex = 0, nShadingsCount = m_vShadings.size(); nIndex < nShadingsCount; nIndex++)
{ {
CShading* pShading = m_vShadings.at(nIndex); CShading* pShading = m_vShadings.at(nIndex);
if (shadingtype_Radial == pShading->GetShadingType() if (shadingtype_Radial == pShading->GetShadingType()
&& ((CRadialShading*)pShading)->Compare(dX0, dY0, dR0, dX1, dY1, dR1) && ((CRadialShading*)pShading)->Compare(dX0, dY0, dR0, dX1, dY1, dR1)
&& pShading->CompareColors(pColors, pPoints, nCount) && pShading->CompareColors(pColors, pPoints, nCount, true)
&& pShading->CompareExtend(true, true)) && pShading->CompareExtend(true, true))
return pShading; return pShading;
} }
...@@ -462,16 +596,16 @@ namespace PdfWriter ...@@ -462,16 +596,16 @@ namespace PdfWriter
if (!pShading) if (!pShading)
return NULL; return NULL;
pShading->SetColors(pColors, pPoints, nCount); pShading->SetRgbColors(pColors, pPoints, nCount);
pShading->SetExtend(true, true); pShading->SetExtend(true, true);
m_vShadings.push_back(pShading); m_vShadings.push_back(pShading);
return pShading; return pShading;
} }
CImageTilePattern*CDocument::CreateImageTilePattern(double dW, double dH, CImageDict* pImageDict, EImageTilePatternType eType) CImageTilePattern*CDocument::CreateImageTilePattern(double dW, double dH, CImageDict* pImageDict, CMatrix* pMatrix, EImageTilePatternType eType)
{ {
return new CImageTilePattern(m_pXref, dW, dH, pImageDict, eType); return new CImageTilePattern(m_pXref, dW, dH, pImageDict, pMatrix, eType);
} }
CImageTilePattern*CDocument::CreateHatchPattern(double dW, double dH, const BYTE& nR1, const BYTE& nG1, const BYTE& nB1, const BYTE& nAlpha1, const BYTE& nR2, const BYTE& nG2, const BYTE& nB2, const BYTE& nAlpha2, const std::wstring& wsHatch) CImageTilePattern*CDocument::CreateHatchPattern(double dW, double dH, const BYTE& nR1, const BYTE& nG1, const BYTE& nB1, const BYTE& nAlpha1, const BYTE& nR2, const BYTE& nG2, const BYTE& nB2, const BYTE& nAlpha2, const std::wstring& wsHatch)
{ {
...@@ -499,6 +633,16 @@ namespace PdfWriter ...@@ -499,6 +633,16 @@ namespace PdfWriter
} }
} }
return CreateImageTilePattern(dW, dH, pImage, imagetilepatterntype_Default); return CreateImageTilePattern(dW, dH, pImage, NULL, imagetilepatterntype_Default);
}
CShading* CDocument::CreateAxialShading(CPage* pPage, double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState)
{
double pPattern[] ={ dX0, dY0, dX1, dY1 };
return CreateShading(pPage, pPattern, true, pColors, pAlphas, pPoints, nCount, pExtGrState);
}
CShading* CDocument::CreateRadialShading(CPage* pPage, double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState)
{
double pPattern[] ={ dX0, dY0, dR0, dX1, dY1, dR1 };
return CreateShading(pPage, pPattern, false, pColors, pAlphas, pPoints, nCount, pExtGrState);
} }
} }
PdfWriter/Src/Document.h
View file @ f4fde172
...@@ -32,6 +32,7 @@ namespace PdfWriter ...@@ -32,6 +32,7 @@ namespace PdfWriter
class CJbig2Global; class CJbig2Global;
class CShading; class CShading;
class CImageTilePattern; class CImageTilePattern;
class CPattern;
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// CDocument // CDocument
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -58,6 +59,8 @@ namespace PdfWriter ...@@ -58,6 +59,8 @@ namespace PdfWriter
CDestination* CreateDestination(unsigned int unPageIndex); CDestination* CreateDestination(unsigned int unPageIndex);
CExtGrState* GetExtGState(double dAlphaStroke = -1, double dAlphaFill = -1, EBlendMode eMode = blendmode_Unknown, int nStrokeAdjustment = -1); CExtGrState* GetExtGState(double dAlphaStroke = -1, double dAlphaFill = -1, EBlendMode eMode = blendmode_Unknown, int nStrokeAdjustment = -1);
CExtGrState* GetStrokeAlpha(double dAlpha);
CExtGrState* GetFillAlpha(double dAlpha);
CJbig2Global* GetJbig2Global(); CJbig2Global* GetJbig2Global();
CAnnotation* CreateTextAnnot(unsigned int unPageNum, TRect oRect, const char* sText); CAnnotation* CreateTextAnnot(unsigned int unPageNum, TRect oRect, const char* sText);
...@@ -68,10 +71,10 @@ namespace PdfWriter ...@@ -68,10 +71,10 @@ namespace PdfWriter
CFont14* CreateFont14(EStandard14Fonts eType); CFont14* CreateFont14(EStandard14Fonts eType);
CFontCidTrueType* CreateTrueTypeFont(const std::wstring& wsFontPath, unsigned int unIndex); CFontCidTrueType* CreateTrueTypeFont(const std::wstring& wsFontPath, unsigned int unIndex);
CShading* CreateAxialShading(double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, double* pPoints, int nCount); CImageTilePattern*CreateImageTilePattern(double dW, double dH, CImageDict* pImageDict, CMatrix* pMatrix = NULL, EImageTilePatternType eType = imagetilepatterntype_Default);
CShading* CreateRaidalShading(double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, double* pPoints, int nCount);
CImageTilePattern*CreateImageTilePattern(double dW, double dH, CImageDict* pImageDict, EImageTilePatternType eType = imagetilepatterntype_Default);
CImageTilePattern*CreateHatchPattern(double dW, double dH, const BYTE& nR1, const BYTE& nG1, const BYTE& nB1, const BYTE& nAlpha1, const BYTE& nR2, const BYTE& nG2, const BYTE& nB2, const BYTE& nAlpha2, const std::wstring& wsHatch); CImageTilePattern*CreateHatchPattern(double dW, double dH, const BYTE& nR1, const BYTE& nG1, const BYTE& nB1, const BYTE& nAlpha1, const BYTE& nR2, const BYTE& nG2, const BYTE& nB2, const BYTE& nAlpha2, const std::wstring& wsHatch);
CShading* CreateAxialShading(CPage* pPage, double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState);
CShading* CreateRadialShading(CPage* pPage, double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState);
private: private:
...@@ -80,6 +83,9 @@ namespace PdfWriter ...@@ -80,6 +83,9 @@ namespace PdfWriter
void SaveToStream(CStream* pStream); void SaveToStream(CStream* pStream);
void PrepareEncryption(); void PrepareEncryption();
CDictObject* CreatePageLabel(EPageNumStyle eStyle, unsigned int unFirstPage, const char* sPrefix); CDictObject* CreatePageLabel(EPageNumStyle eStyle, unsigned int unFirstPage, const char* sPrefix);
CShading* CreateShading(CPage* pPage, double *pPattern, bool bAxial, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState);
CShading* CreateAxialShading(double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, double* pPoints, int nCount);
CShading* CreateRadialShading(double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, double* pPoints, int nCount);
private: private:
...@@ -111,10 +117,13 @@ namespace PdfWriter ...@@ -111,10 +117,13 @@ namespace PdfWriter
unsigned int m_unCompressMode; unsigned int m_unCompressMode;
std::vector<CPage*> m_vPages; std::vector<CPage*> m_vPages;
std::vector<CExtGrState*> m_vExtGrStates; std::vector<CExtGrState*> m_vExtGrStates;
std::vector<CExtGrState*> m_vStrokeAlpha;
std::vector<CExtGrState*> m_vFillAlpha;
char m_sTTFontTag[8]; // 6 символов + '+' + 0x00 ("BAAAAA+/0") char m_sTTFontTag[8]; // 6 символов + '+' + 0x00 ("BAAAAA+/0")
CJbig2Global* m_pJbig2; CJbig2Global* m_pJbig2;
std::vector<CShading*> m_vShadings; std::vector<CShading*> m_vShadings;
std::vector<TFontInfo> m_vTTFonts; std::vector<TFontInfo> m_vTTFonts;
CDictObject* m_pTransparencyGroup;
friend class CFontCidTrueType; friend class CFontCidTrueType;
}; };
......
PdfWriter/Src/Pages.cpp
View file @ f4fde172
...@@ -8,6 +8,7 @@ ...@@ -8,6 +8,7 @@
#include "Image.h" #include "Image.h"
#include "Shading.h" #include "Shading.h"
#include "Pattern.h" #include "Pattern.h"
#include "Document.h"
#ifdef DrawText #ifdef DrawText
#undef DrawText #undef DrawText
...@@ -165,11 +166,12 @@ namespace PdfWriter ...@@ -165,11 +166,12 @@ namespace PdfWriter
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// CPage // CPage
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
CPage::CPage(CXref* pXref, CPageTree* pParent) CPage::CPage(CXref* pXref, CPageTree* pParent, CDocument* pDocument)
{ {
pXref->Add(this); pXref->Add(this);
m_pXref = pXref; m_pXref = pXref;
m_pDocument = pDocument;
m_pContents = new CDictObject(pXref); m_pContents = new CDictObject(pXref);
m_pStream = m_pContents->GetStream(); m_pStream = m_pContents->GetStream();
m_eGrMode = grmode_PAGE; m_eGrMode = grmode_PAGE;
...@@ -1087,6 +1089,18 @@ namespace PdfWriter ...@@ -1087,6 +1089,18 @@ namespace PdfWriter
m_pStream->WriteEscapeName(sShadingName); m_pStream->WriteEscapeName(sShadingName);
m_pStream->WriteStr(" sh\012"); m_pStream->WriteStr(" sh\012");
} }
void CPage::SetStrokeAlpha(unsigned char unAlpha)
{
CExtGrState* pExtGrState = m_pDocument->GetStrokeAlpha((double)(unAlpha / 255.0));
if (pExtGrState)
SetExtGrState(pExtGrState);
}
void CPage::SetFillAlpha(unsigned char unAlpha)
{
CExtGrState* pExtGrState = m_pDocument->GetFillAlpha((double)(unAlpha / 255.0));
if (pExtGrState)
SetExtGrState(pExtGrState);
}
const char* CPage::GetLocalShadingName(CShading* pShading) const char* CPage::GetLocalShadingName(CShading* pShading)
{ {
if (!m_pShadings) if (!m_pShadings)
...@@ -1162,4 +1176,17 @@ namespace PdfWriter ...@@ -1162,4 +1176,17 @@ namespace PdfWriter
m_pStream->WriteEscapeName(sPatternName); m_pStream->WriteEscapeName(sPatternName);
m_pStream->WriteStr(" scn\012"); m_pStream->WriteStr(" scn\012");
} }
void CPage::SetFilter(unsigned int unFiler)
{
if (m_pContents)
m_pContents->SetFilter(unFiler);
}
CMatrix* CPage::GetTransform()
{
return &m_pGrState->m_oMatrix;
}
void CPage::AddGroup(CDictObject* pDict)
{
Add("Group", pDict);
}
} }
\ No newline at end of file
PdfWriter/Src/Pages.h
View file @ f4fde172
...@@ -18,6 +18,7 @@ namespace PdfWriter ...@@ -18,6 +18,7 @@ namespace PdfWriter
class CImageDict; class CImageDict;
class CShading; class CShading;
class CImageTilePattern; class CImageTilePattern;
class CDocument;
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// CPageTree // CPageTree
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
...@@ -40,7 +41,7 @@ namespace PdfWriter ...@@ -40,7 +41,7 @@ namespace PdfWriter
class CPage : public CDictObject class CPage : public CDictObject
{ {
public: public:
CPage(CXref* pXref, CPageTree* pParent); CPage(CXref* pXref, CPageTree* pParent, CDocument* pDocument);
~CPage(); ~CPage();
void SetHeight(double dHeight); void SetHeight(double dHeight);
...@@ -82,6 +83,8 @@ namespace PdfWriter ...@@ -82,6 +83,8 @@ namespace PdfWriter
void SetExtGrState(CExtGrState* pExtGrState); void SetExtGrState(CExtGrState* pExtGrState);
void AddAnnotation(CAnnotation* pAnnot); void AddAnnotation(CAnnotation* pAnnot);
void DrawShading(CShading* pShading); void DrawShading(CShading* pShading);
void SetStrokeAlpha(unsigned char unAlpha);
void SetFillAlpha(unsigned char unAlpha);
void BeginText(); void BeginText();
void EndText(); void EndText();
...@@ -97,6 +100,9 @@ namespace PdfWriter ...@@ -97,6 +100,9 @@ namespace PdfWriter
void ExecuteXObject(CXObject* pXObject); void ExecuteXObject(CXObject* pXObject);
void DrawImage(CImageDict* pImage, double dX, double dY, double dWidth, double dHeight); void DrawImage(CImageDict* pImage, double dX, double dY, double dWidth, double dHeight);
void SetPatternColorSpace(CImageTilePattern* pPattern); void SetPatternColorSpace(CImageTilePattern* pPattern);
void SetFilter(unsigned int unFiler);
CMatrix* GetTransform();
void AddGroup(CDictObject* pDict);
private: private:
...@@ -119,6 +125,7 @@ namespace PdfWriter ...@@ -119,6 +125,7 @@ namespace PdfWriter
private: private:
CDocument* m_pDocument;
CPageTree* m_pParent; CPageTree* m_pParent;
CXref* m_pXref; CXref* m_pXref;
CPoint m_oStartPos; // Позиция начала текущего пата CPoint m_oStartPos; // Позиция начала текущего пата
......
PdfWriter/Src/Pattern.cpp
View file @ f4fde172
...@@ -13,13 +13,28 @@ namespace PdfWriter ...@@ -13,13 +13,28 @@ namespace PdfWriter
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
// CImageTilePattern // CImageTilePattern
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
CImageTilePattern::CImageTilePattern(CXref* pXref, const double& dW, const double& dH, CImageDict* pImageDict, EImageTilePatternType eType) : CPattern(pXref) CImageTilePattern::CImageTilePattern(CXref* pXref, const double& dW, const double& dH, CImageDict* pImageDict, CMatrix* pMatrix, EImageTilePatternType eType) : CPattern(pXref)
{ {
Add("Type", "Pattern"); Add("Type", "Pattern");
Add("PatternType", 1); Add("PatternType", 1);
Add("PaintType", 1); // Uncolored Add("PaintType", 1); // Uncolored
Add("TilingType", 1); // No distortion Add("TilingType", 1); // No distortion
if (pMatrix)
{
CArrayObject* pMatrixArray = new CArrayObject();
if (!pMatrixArray)
return;
pMatrixArray->Add(pMatrix->m11);
pMatrixArray->Add(pMatrix->m12);
pMatrixArray->Add(pMatrix->m21);
pMatrixArray->Add(pMatrix->m22);
pMatrixArray->Add(pMatrix->x);
pMatrixArray->Add(pMatrix->y);
Add("Matrix", pMatrixArray);
}
CDictObject* pResources = new CDictObject(); CDictObject* pResources = new CDictObject();
if (!pResources) if (!pResources)
return; return;
......
PdfWriter/Src/Pattern.h
View file @ f4fde172
...@@ -20,7 +20,7 @@ namespace PdfWriter ...@@ -20,7 +20,7 @@ namespace PdfWriter
class CImageTilePattern : public CPattern class CImageTilePattern : public CPattern
{ {
public: public:
CImageTilePattern(CXref* pXref, const double& dW, const double& dH, CImageDict* pImageDict, EImageTilePatternType eType = imagetilepatterntype_Default); CImageTilePattern(CXref* pXref, const double& dW, const double& dH, CImageDict* pImageDict, CMatrix* pMatrix = NULL, EImageTilePatternType eType = imagetilepatterntype_Default);
}; };
} }
......
PdfWriter/Src/Shading.cpp
View file @ f4fde172
...@@ -105,6 +105,7 @@ namespace PdfWriter ...@@ -105,6 +105,7 @@ namespace PdfWriter
m_pXref = pXref; m_pXref = pXref;
pXref->Add(this); pXref->Add(this);
m_bRgb = true;
m_pColors = NULL; m_pColors = NULL;
m_pColorsPoints = NULL; m_pColorsPoints = NULL;
m_nColorsCount = 0; m_nColorsCount = 0;
...@@ -119,11 +120,12 @@ namespace PdfWriter ...@@ -119,11 +120,12 @@ namespace PdfWriter
if (m_pColorsPoints) if (m_pColorsPoints)
delete[] m_pColorsPoints; delete[] m_pColorsPoints;
} }
void CShading::SetColors(unsigned char* pColors, double* pPoints, int nCount) void CShading::SetRgbColors(unsigned char* pColors, double* pPoints, int nCount)
{ {
if (!pColors || !pPoints || nCount <= 1) if (!pColors || !pPoints || nCount <= 1)
return; return;
m_bRgb = true;
m_pColors = new unsigned char[3 * nCount]; m_pColors = new unsigned char[3 * nCount];
m_pColorsPoints = new double[nCount]; m_pColorsPoints = new double[nCount];
m_nColorsCount = nCount; m_nColorsCount = nCount;
...@@ -193,6 +195,53 @@ namespace PdfWriter ...@@ -193,6 +195,53 @@ namespace PdfWriter
delete[] ppValues; delete[] ppValues;
} }
} }
void CShading::SetGrayColors(unsigned char* pColors, double* pPoints, int nCount)
{
if (!pColors || !pPoints || nCount <= 1)
return;
m_bRgb = false;
m_pColors = new unsigned char[nCount];
m_pColorsPoints = new double[nCount];
m_nColorsCount = nCount;
if (!m_pColors || !m_pColorsPoints)
return;
memcpy(m_pColors, pColors, nCount);
Add("ColorSpace", "DeviceGray");
CArrayObject* pDomain = new CArrayObject();
if (!pDomain)
return;
pDomain->Add(0.0);
pDomain->Add(1.0);
Add("Domain", pDomain);
if (nCount <= 2)
{
double pC0Values = pColors[0] / 255.0;
double pC1Values = pColors[1] / 255.0;
CLinearFuntion* pFunction = new CLinearFuntion(m_pXref, &pC0Values, &pC1Values, 1);
Add("Function", pFunction);
}
else
{
double* pValues = new double[(nCount - 1) * 2];
for (int nIndex = 0; nIndex < nCount - 1; nIndex++)
{
pValues[2 * nIndex + 0] = pColors[nIndex] / 255.0;
pValues[2 * nIndex + 1] = pColors[nIndex + 1] / 255.0;
}
CLineSegmentFuntion* pFunction = new CLineSegmentFuntion(m_pXref, &pValues, pPoints + 1, nCount - 1, 1);
Add("Function", pFunction);
delete[] pValues;
}
}
void CShading::SetExtend(bool bBegin, bool bEnd) void CShading::SetExtend(bool bBegin, bool bEnd)
{ {
CArrayObject* pExtend = new CArrayObject(); CArrayObject* pExtend = new CArrayObject();
...@@ -206,22 +255,35 @@ namespace PdfWriter ...@@ -206,22 +255,35 @@ namespace PdfWriter
m_bBeginExtend = bBegin; m_bBeginExtend = bBegin;
m_bEndExtend = bEnd; m_bEndExtend = bEnd;
} }
bool CShading::CompareColors(unsigned char* pColors, double* pPoints, int nCount) bool CShading::CompareColors(unsigned char* pColors, double* pPoints, int nCount, bool bRgb)
{ {
if (nCount != m_nColorsCount if (nCount != m_nColorsCount
|| (pColors && !m_pColors) || (pColors && !m_pColors)
|| (pPoints && !m_pColorsPoints) || (pPoints && !m_pColorsPoints)
|| (!pColors && m_pColors) || (!pColors && m_pColors)
|| (!pPoints && m_pColorsPoints)) || (!pPoints && m_pColorsPoints)
|| bRgb != m_bRgb)
return false; return false;
for (int nIndex = 0; nIndex < nCount; nIndex++) if (m_bRgb)
{ {
if (pColors[3 * nIndex + 0] != m_pColors[3 * nIndex + 0] for (int nIndex = 0; nIndex < nCount; nIndex++)
|| pColors[3 * nIndex + 1] != m_pColors[3 * nIndex + 1] {
|| pColors[3 * nIndex + 2] != m_pColors[3 * nIndex + 2] if (pColors[3 * nIndex + 0] != m_pColors[3 * nIndex + 0]
|| abs(pPoints[nIndex] - m_pColorsPoints[nIndex]) > 0.01) || pColors[3 * nIndex + 1] != m_pColors[3 * nIndex + 1]
return false; || pColors[3 * nIndex + 2] != m_pColors[3 * nIndex + 2]
|| abs(pPoints[nIndex] - m_pColorsPoints[nIndex]) > 0.01)
return false;
}
}
else
{
for (int nIndex = 0; nIndex < nCount; nIndex++)
{
if (pColors[nIndex] != m_pColors[nIndex]
|| abs(pPoints[nIndex] - m_pColorsPoints[nIndex]) > 0.01)
return false;
}
} }
return true; return true;
......
PdfWriter/Src/Shading.h
View file @ f4fde172
...@@ -2,6 +2,7 @@ ...@@ -2,6 +2,7 @@
#define _PDF_WRITER_SRC_STREAMS_H #define _PDF_WRITER_SRC_STREAMS_H
#include "Objects.h" #include "Objects.h"
#include "Pattern.h"
namespace PdfWriter namespace PdfWriter
{ {
...@@ -20,9 +21,10 @@ namespace PdfWriter ...@@ -20,9 +21,10 @@ namespace PdfWriter
CShading(CXref* pXref); CShading(CXref* pXref);
virtual ~CShading(); virtual ~CShading();
void SetColors(unsigned char* pColors, double* dPoints, int nCount); void SetRgbColors(unsigned char* pColors, double* dPoints, int nCount);
void SetGrayColors(unsigned char* pColors, double* dPoints, int nCount);
void SetExtend(bool bBeing, bool bEnd); void SetExtend(bool bBeing, bool bEnd);
bool CompareColors(unsigned char* pColors, double* pPoints, int nCount); bool CompareColors(unsigned char* pColors, double* pPoints, int nCount, bool bRgb);
bool CompareExtend(bool bBeing, bool bEnd); bool CompareExtend(bool bBeing, bool bEnd);
virtual EShadingType GetShadingType() virtual EShadingType GetShadingType()
...@@ -36,6 +38,7 @@ namespace PdfWriter ...@@ -36,6 +38,7 @@ namespace PdfWriter
private: private:
bool m_bRgb; // Rgb Gray
unsigned char* m_pColors; unsigned char* m_pColors;
double* m_pColorsPoints; double* m_pColorsPoints;
int m_nColorsCount; int m_nColorsCount;
......
PdfWriter/Src/Types.h
View file @ f4fde172
...@@ -59,6 +59,27 @@ namespace PdfWriter ...@@ -59,6 +59,27 @@ namespace PdfWriter
y = 0; y = 0;
} }
void Apply(double& dX, double& dY)
{
double _x = dX;
double _y = dY;
dX = _x * m11 + _y * m21 + x;
dY = _x * m12 + _y * m22 + y;
}
bool operator==(const CMatrix& oMatrix)
{
if (abs(oMatrix.m11 - m11) > 0.001
|| abs(oMatrix.m12 - m12) > 0.001
|| abs(oMatrix.m21 - m21) > 0.001
|| abs(oMatrix.m22 - m22) > 0.001
|| abs(oMatrix.x - x) > 0.001
|| abs(oMatrix.y - y) > 0.001)
return false;
return true;
}
public: public:
double m11; double m11;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7