1 // Copyright 2016 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "core/fpdfapi/edit/cpdf_pagecontentgenerator.h"
8
9 #include <tuple>
10 #include <utility>
11
12 #include "core/fpdfapi/font/cpdf_font.h"
13 #include "core/fpdfapi/page/cpdf_docpagedata.h"
14 #include "core/fpdfapi/page/cpdf_image.h"
15 #include "core/fpdfapi/page/cpdf_imageobject.h"
16 #include "core/fpdfapi/page/cpdf_page.h"
17 #include "core/fpdfapi/page/cpdf_path.h"
18 #include "core/fpdfapi/page/cpdf_pathobject.h"
19 #include "core/fpdfapi/page/cpdf_textobject.h"
20 #include "core/fpdfapi/parser/cpdf_array.h"
21 #include "core/fpdfapi/parser/cpdf_dictionary.h"
22 #include "core/fpdfapi/parser/cpdf_document.h"
23 #include "core/fpdfapi/parser/cpdf_name.h"
24 #include "core/fpdfapi/parser/cpdf_number.h"
25 #include "core/fpdfapi/parser/cpdf_reference.h"
26 #include "core/fpdfapi/parser/cpdf_stream.h"
27 #include "core/fpdfapi/parser/fpdf_parser_decode.h"
28
29 namespace {
30
operator <<(std::ostream & ar,const CFX_Matrix & matrix)31 std::ostream& operator<<(std::ostream& ar, const CFX_Matrix& matrix) {
32 ar << matrix.a << " " << matrix.b << " " << matrix.c << " " << matrix.d << " "
33 << matrix.e << " " << matrix.f;
34 return ar;
35 }
36
GetColor(const CPDF_Color * pColor,float * rgb)37 bool GetColor(const CPDF_Color* pColor, float* rgb) {
38 int intRGB[3];
39 if (!pColor ||
40 pColor->GetColorSpace() != CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB) ||
41 !pColor->GetRGB(&intRGB[0], &intRGB[1], &intRGB[2])) {
42 return false;
43 }
44 rgb[0] = intRGB[0] / 255.0f;
45 rgb[1] = intRGB[1] / 255.0f;
46 rgb[2] = intRGB[2] / 255.0f;
47 return true;
48 }
49
50 } // namespace
51
CPDF_PageContentGenerator(CPDF_PageObjectHolder * pObjHolder)52 CPDF_PageContentGenerator::CPDF_PageContentGenerator(
53 CPDF_PageObjectHolder* pObjHolder)
54 : m_pObjHolder(pObjHolder), m_pDocument(pObjHolder->m_pDocument.Get()) {
55 for (const auto& pObj : *pObjHolder->GetPageObjectList()) {
56 if (pObj)
57 m_pageObjects.emplace_back(pObj.get());
58 }
59 }
60
~CPDF_PageContentGenerator()61 CPDF_PageContentGenerator::~CPDF_PageContentGenerator() {}
62
GenerateContent()63 void CPDF_PageContentGenerator::GenerateContent() {
64 ASSERT(m_pObjHolder->IsPage());
65
66 CPDF_Document* pDoc = m_pDocument.Get();
67 std::ostringstream buf;
68
69 // Set the default graphic state values
70 buf << "q\n";
71 if (!m_pObjHolder->GetLastCTM().IsIdentity())
72 buf << m_pObjHolder->GetLastCTM().GetInverse() << " cm\n";
73 ProcessDefaultGraphics(&buf);
74
75 // Process the page objects
76 if (!ProcessPageObjects(&buf))
77 return;
78
79 // Return graphics to original state
80 buf << "Q\n";
81
82 // Add buffer to a stream in page's 'Contents'
83 CPDF_Dictionary* pPageDict = m_pObjHolder->m_pFormDict.Get();
84 CPDF_Object* pContent =
85 pPageDict ? pPageDict->GetObjectFor("Contents") : nullptr;
86 CPDF_Stream* pStream = pDoc->NewIndirect<CPDF_Stream>();
87 pStream->SetData(&buf);
88 if (pContent) {
89 CPDF_Array* pArray = ToArray(pContent);
90 if (pArray) {
91 pArray->AddNew<CPDF_Reference>(pDoc, pStream->GetObjNum());
92 return;
93 }
94 CPDF_Reference* pReference = ToReference(pContent);
95 if (!pReference) {
96 pPageDict->SetNewFor<CPDF_Reference>("Contents", m_pDocument.Get(),
97 pStream->GetObjNum());
98 return;
99 }
100 CPDF_Object* pDirectObj = pReference->GetDirect();
101 if (!pDirectObj) {
102 pPageDict->SetNewFor<CPDF_Reference>("Contents", m_pDocument.Get(),
103 pStream->GetObjNum());
104 return;
105 }
106 CPDF_Array* pObjArray = pDirectObj->AsArray();
107 if (pObjArray) {
108 pObjArray->AddNew<CPDF_Reference>(pDoc, pStream->GetObjNum());
109 return;
110 }
111 if (pDirectObj->IsStream()) {
112 CPDF_Array* pContentArray = pDoc->NewIndirect<CPDF_Array>();
113 pContentArray->AddNew<CPDF_Reference>(pDoc, pDirectObj->GetObjNum());
114 pContentArray->AddNew<CPDF_Reference>(pDoc, pStream->GetObjNum());
115 pPageDict->SetNewFor<CPDF_Reference>("Contents", pDoc,
116 pContentArray->GetObjNum());
117 return;
118 }
119 }
120 pPageDict->SetNewFor<CPDF_Reference>("Contents", m_pDocument.Get(),
121 pStream->GetObjNum());
122 }
123
RealizeResource(uint32_t dwResourceObjNum,const ByteString & bsType)124 ByteString CPDF_PageContentGenerator::RealizeResource(
125 uint32_t dwResourceObjNum,
126 const ByteString& bsType) {
127 ASSERT(dwResourceObjNum);
128 if (!m_pObjHolder->m_pResources) {
129 m_pObjHolder->m_pResources = m_pDocument->NewIndirect<CPDF_Dictionary>();
130 m_pObjHolder->m_pFormDict->SetNewFor<CPDF_Reference>(
131 "Resources", m_pDocument.Get(),
132 m_pObjHolder->m_pResources->GetObjNum());
133 }
134 CPDF_Dictionary* pResList = m_pObjHolder->m_pResources->GetDictFor(bsType);
135 if (!pResList)
136 pResList = m_pObjHolder->m_pResources->SetNewFor<CPDF_Dictionary>(bsType);
137
138 ByteString name;
139 int idnum = 1;
140 while (1) {
141 name = ByteString::Format("FX%c%d", bsType[0], idnum);
142 if (!pResList->KeyExist(name))
143 break;
144
145 idnum++;
146 }
147 pResList->SetNewFor<CPDF_Reference>(name, m_pDocument.Get(),
148 dwResourceObjNum);
149 return name;
150 }
151
ProcessPageObjects(std::ostringstream * buf)152 bool CPDF_PageContentGenerator::ProcessPageObjects(std::ostringstream* buf) {
153 bool bDirty = false;
154 for (auto& pPageObj : m_pageObjects) {
155 if (m_pObjHolder->IsPage() && !pPageObj->IsDirty())
156 continue;
157
158 bDirty = true;
159 if (CPDF_ImageObject* pImageObject = pPageObj->AsImage())
160 ProcessImage(buf, pImageObject);
161 else if (CPDF_PathObject* pPathObj = pPageObj->AsPath())
162 ProcessPath(buf, pPathObj);
163 else if (CPDF_TextObject* pTextObj = pPageObj->AsText())
164 ProcessText(buf, pTextObj);
165 pPageObj->SetDirty(false);
166 }
167 return bDirty;
168 }
169
ProcessImage(std::ostringstream * buf,CPDF_ImageObject * pImageObj)170 void CPDF_PageContentGenerator::ProcessImage(std::ostringstream* buf,
171 CPDF_ImageObject* pImageObj) {
172 if ((pImageObj->matrix().a == 0 && pImageObj->matrix().b == 0) ||
173 (pImageObj->matrix().c == 0 && pImageObj->matrix().d == 0)) {
174 return;
175 }
176 *buf << "q " << pImageObj->matrix() << " cm ";
177
178 RetainPtr<CPDF_Image> pImage = pImageObj->GetImage();
179 if (pImage->IsInline())
180 return;
181
182 CPDF_Stream* pStream = pImage->GetStream();
183 if (!pStream)
184 return;
185
186 bool bWasInline = pStream->IsInline();
187 if (bWasInline)
188 pImage->ConvertStreamToIndirectObject();
189
190 uint32_t dwObjNum = pStream->GetObjNum();
191 ByteString name = RealizeResource(dwObjNum, "XObject");
192 if (bWasInline)
193 pImageObj->SetImage(m_pDocument->GetPageData()->GetImage(dwObjNum));
194
195 *buf << "/" << PDF_NameEncode(name) << " Do Q\n";
196 }
197
198 // Processing path with operators from Tables 4.9 and 4.10 of PDF spec 1.7:
199 // "re" appends a rectangle (here, used only if the whole path is a rectangle)
200 // "m" moves current point to the given coordinates
201 // "l" creates a line from current point to the new point
202 // "c" adds a Bezier curve from current to last point, using the two other
203 // points as the Bezier control points
204 // Note: "l", "c" change the current point
205 // "h" closes the subpath (appends a line from current to starting point)
206 // Path painting operators: "S", "n", "B", "f", "B*", "f*", depending on
207 // the filling mode and whether we want stroking the path or not.
208 // "Q" restores the graphics state imposed by the ProcessGraphics method.
ProcessPath(std::ostringstream * buf,CPDF_PathObject * pPathObj)209 void CPDF_PageContentGenerator::ProcessPath(std::ostringstream* buf,
210 CPDF_PathObject* pPathObj) {
211 ProcessGraphics(buf, pPathObj);
212
213 *buf << pPathObj->m_Matrix << " cm ";
214
215 auto& pPoints = pPathObj->m_Path.GetPoints();
216 if (pPathObj->m_Path.IsRect()) {
217 CFX_PointF diff = pPoints[2].m_Point - pPoints[0].m_Point;
218 *buf << pPoints[0].m_Point.x << " " << pPoints[0].m_Point.y << " " << diff.x
219 << " " << diff.y << " re";
220 } else {
221 for (size_t i = 0; i < pPoints.size(); i++) {
222 if (i > 0)
223 *buf << " ";
224 *buf << pPoints[i].m_Point.x << " " << pPoints[i].m_Point.y;
225 FXPT_TYPE pointType = pPoints[i].m_Type;
226 if (pointType == FXPT_TYPE::MoveTo) {
227 *buf << " m";
228 } else if (pointType == FXPT_TYPE::LineTo) {
229 *buf << " l";
230 } else if (pointType == FXPT_TYPE::BezierTo) {
231 if (i + 2 >= pPoints.size() ||
232 !pPoints[i].IsTypeAndOpen(FXPT_TYPE::BezierTo) ||
233 !pPoints[i + 1].IsTypeAndOpen(FXPT_TYPE::BezierTo) ||
234 pPoints[i + 2].m_Type != FXPT_TYPE::BezierTo) {
235 // If format is not supported, close the path and paint
236 *buf << " h";
237 break;
238 }
239 *buf << " " << pPoints[i + 1].m_Point.x << " "
240 << pPoints[i + 1].m_Point.y << " " << pPoints[i + 2].m_Point.x
241 << " " << pPoints[i + 2].m_Point.y << " c";
242 i += 2;
243 }
244 if (pPoints[i].m_CloseFigure)
245 *buf << " h";
246 }
247 }
248 if (pPathObj->m_FillType == 0)
249 *buf << (pPathObj->m_bStroke ? " S" : " n");
250 else if (pPathObj->m_FillType == FXFILL_WINDING)
251 *buf << (pPathObj->m_bStroke ? " B" : " f");
252 else if (pPathObj->m_FillType == FXFILL_ALTERNATE)
253 *buf << (pPathObj->m_bStroke ? " B*" : " f*");
254 *buf << " Q\n";
255 }
256
257 // This method supports color operators rg and RGB from Table 4.24 of PDF spec
258 // 1.7. A color will not be set if the colorspace is not DefaultRGB or the RGB
259 // values cannot be obtained. The method also adds an external graphics
260 // dictionary, as described in Section 4.3.4.
261 // "rg" sets the fill color, "RG" sets the stroke color (using DefaultRGB)
262 // "w" sets the stroke line width.
263 // "ca" sets the fill alpha, "CA" sets the stroke alpha.
264 // "q" saves the graphics state, so that the settings can later be reversed
ProcessGraphics(std::ostringstream * buf,CPDF_PageObject * pPageObj)265 void CPDF_PageContentGenerator::ProcessGraphics(std::ostringstream* buf,
266 CPDF_PageObject* pPageObj) {
267 *buf << "q ";
268 float fillColor[3];
269 if (GetColor(pPageObj->m_ColorState.GetFillColor(), fillColor)) {
270 *buf << fillColor[0] << " " << fillColor[1] << " " << fillColor[2]
271 << " rg ";
272 }
273 float strokeColor[3];
274 if (GetColor(pPageObj->m_ColorState.GetStrokeColor(), strokeColor)) {
275 *buf << strokeColor[0] << " " << strokeColor[1] << " " << strokeColor[2]
276 << " RG ";
277 }
278 float lineWidth = pPageObj->m_GraphState.GetLineWidth();
279 if (lineWidth != 1.0f)
280 *buf << lineWidth << " w ";
281 CFX_GraphStateData::LineCap lineCap = pPageObj->m_GraphState.GetLineCap();
282 if (lineCap != CFX_GraphStateData::LineCapButt)
283 *buf << static_cast<int>(lineCap) << " J ";
284 CFX_GraphStateData::LineJoin lineJoin = pPageObj->m_GraphState.GetLineJoin();
285 if (lineJoin != CFX_GraphStateData::LineJoinMiter)
286 *buf << static_cast<int>(lineJoin) << " j ";
287
288 GraphicsData graphD;
289 graphD.fillAlpha = pPageObj->m_GeneralState.GetFillAlpha();
290 graphD.strokeAlpha = pPageObj->m_GeneralState.GetStrokeAlpha();
291 graphD.blendType = pPageObj->m_GeneralState.GetBlendType();
292 if (graphD.fillAlpha == 1.0f && graphD.strokeAlpha == 1.0f &&
293 (graphD.blendType == FXDIB_BLEND_UNSUPPORTED ||
294 graphD.blendType == FXDIB_BLEND_NORMAL)) {
295 return;
296 }
297
298 ByteString name;
299 auto it = m_pObjHolder->m_GraphicsMap.find(graphD);
300 if (it != m_pObjHolder->m_GraphicsMap.end()) {
301 name = it->second;
302 } else {
303 auto gsDict = pdfium::MakeUnique<CPDF_Dictionary>();
304 if (graphD.fillAlpha != 1.0f)
305 gsDict->SetNewFor<CPDF_Number>("ca", graphD.fillAlpha);
306
307 if (graphD.strokeAlpha != 1.0f)
308 gsDict->SetNewFor<CPDF_Number>("CA", graphD.strokeAlpha);
309
310 if (graphD.blendType != FXDIB_BLEND_UNSUPPORTED &&
311 graphD.blendType != FXDIB_BLEND_NORMAL) {
312 gsDict->SetNewFor<CPDF_Name>("BM",
313 pPageObj->m_GeneralState.GetBlendMode());
314 }
315 CPDF_Object* pDict = m_pDocument->AddIndirectObject(std::move(gsDict));
316 uint32_t dwObjNum = pDict->GetObjNum();
317 name = RealizeResource(dwObjNum, "ExtGState");
318 m_pObjHolder->m_GraphicsMap[graphD] = name;
319 }
320 *buf << "/" << PDF_NameEncode(name) << " gs ";
321 }
322
ProcessDefaultGraphics(std::ostringstream * buf)323 void CPDF_PageContentGenerator::ProcessDefaultGraphics(
324 std::ostringstream* buf) {
325 *buf << "0 0 0 RG 0 0 0 rg 1 w "
326 << static_cast<int>(CFX_GraphStateData::LineCapButt) << " J "
327 << static_cast<int>(CFX_GraphStateData::LineJoinMiter) << " j\n";
328 GraphicsData defaultGraphics;
329 defaultGraphics.fillAlpha = 1.0f;
330 defaultGraphics.strokeAlpha = 1.0f;
331 defaultGraphics.blendType = FXDIB_BLEND_NORMAL;
332 auto it = m_pObjHolder->m_GraphicsMap.find(defaultGraphics);
333 ByteString name;
334 if (it != m_pObjHolder->m_GraphicsMap.end()) {
335 name = it->second;
336 } else {
337 auto gsDict = pdfium::MakeUnique<CPDF_Dictionary>();
338 gsDict->SetNewFor<CPDF_Number>("ca", defaultGraphics.fillAlpha);
339 gsDict->SetNewFor<CPDF_Number>("CA", defaultGraphics.strokeAlpha);
340 gsDict->SetNewFor<CPDF_Name>("BM", "Normal");
341 CPDF_Object* pDict = m_pDocument->AddIndirectObject(std::move(gsDict));
342 uint32_t dwObjNum = pDict->GetObjNum();
343 name = RealizeResource(dwObjNum, "ExtGState");
344 m_pObjHolder->m_GraphicsMap[defaultGraphics] = name;
345 }
346 *buf << "/" << PDF_NameEncode(name).c_str() << " gs ";
347 }
348
349 // This method adds text to the buffer, BT begins the text object, ET ends it.
350 // Tm sets the text matrix (allows positioning and transforming text).
351 // Tf sets the font name (from Font in Resources) and font size.
352 // Tj sets the actual text, <####...> is used when specifying charcodes.
ProcessText(std::ostringstream * buf,CPDF_TextObject * pTextObj)353 void CPDF_PageContentGenerator::ProcessText(std::ostringstream* buf,
354 CPDF_TextObject* pTextObj) {
355 ProcessGraphics(buf, pTextObj);
356 *buf << "BT " << pTextObj->GetTextMatrix() << " Tm ";
357 CPDF_Font* pFont = pTextObj->GetFont();
358 if (!pFont)
359 pFont = CPDF_Font::GetStockFont(m_pDocument.Get(), "Helvetica");
360 FontData fontD;
361 if (pFont->IsType1Font())
362 fontD.type = "Type1";
363 else if (pFont->IsTrueTypeFont())
364 fontD.type = "TrueType";
365 else if (pFont->IsCIDFont())
366 fontD.type = "Type0";
367 else
368 return;
369 fontD.baseFont = pFont->GetBaseFont();
370 auto it = m_pObjHolder->m_FontsMap.find(fontD);
371 ByteString dictName;
372 if (it != m_pObjHolder->m_FontsMap.end()) {
373 dictName = it->second;
374 } else {
375 uint32_t dwObjNum = pFont->GetFontDict()->GetObjNum();
376 if (!dwObjNum) {
377 // In this case we assume it must be a standard font
378 auto fontDict = pdfium::MakeUnique<CPDF_Dictionary>();
379 fontDict->SetNewFor<CPDF_Name>("Type", "Font");
380 fontDict->SetNewFor<CPDF_Name>("Subtype", fontD.type);
381 fontDict->SetNewFor<CPDF_Name>("BaseFont", fontD.baseFont);
382 CPDF_Object* pDict = m_pDocument->AddIndirectObject(std::move(fontDict));
383 dwObjNum = pDict->GetObjNum();
384 }
385 dictName = RealizeResource(dwObjNum, "Font");
386 m_pObjHolder->m_FontsMap[fontD] = dictName;
387 }
388 *buf << "/" << PDF_NameEncode(dictName) << " " << pTextObj->GetFontSize()
389 << " Tf ";
390 ByteString text;
391 for (uint32_t charcode : pTextObj->GetCharCodes()) {
392 if (charcode != CPDF_Font::kInvalidCharCode)
393 pFont->AppendChar(&text, charcode);
394 }
395 *buf << PDF_EncodeString(text, true) << " Tj ET";
396 *buf << " Q\n";
397 }
398