Revert "Revert "Add type cast definitions for CPDF_Dictionary.""
[pdfium.git] / core / src / fpdfapi / fpdf_page / fpdf_page_parser.cpp
1 // Copyright 2014 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 "../../../include/fpdfapi/fpdf_page.h"
8 #include "../../../include/fpdfapi/fpdf_module.h"
9 #include "../../../include/fpdfapi/fpdf_serial.h"
10 #include "pageint.h"
11
12 #define REQUIRE_PARAMS(count)  \
13   if (m_ParamCount != count) { \
14     return;                    \
15   }
16
17 CPDF_StreamContentParser::CPDF_StreamContentParser(
18     CPDF_Document* pDocument,
19     CPDF_Dictionary* pPageResources,
20     CPDF_Dictionary* pParentResources,
21     CFX_AffineMatrix* pmtContentToUser,
22     CPDF_PageObjects* pObjList,
23     CPDF_Dictionary* pResources,
24     CPDF_Rect* pBBox,
25     CPDF_ParseOptions* pOptions,
26     CPDF_AllStates* pStates,
27     int level)
28     : m_pDocument(pDocument),
29       m_pPageResources(pPageResources),
30       m_pParentResources(pParentResources),
31       m_pResources(pResources),
32       m_pObjectList(pObjList),
33       m_Level(level),
34       m_ParamStartPos(0),
35       m_ParamCount(0),
36       m_pCurStates(new CPDF_AllStates),
37       m_pLastTextObject(nullptr),
38       m_DefFontSize(0),
39       m_pPathPoints(nullptr),
40       m_PathPointCount(0),
41       m_PathAllocSize(0),
42       m_PathCurrentX(0.0f),
43       m_PathCurrentY(0.0f),
44       m_PathClipType(0),
45       m_pLastImage(nullptr),
46       m_pLastImageDict(nullptr),
47       m_pLastCloneImageDict(nullptr),
48       m_bReleaseLastDict(TRUE),
49       m_bColored(FALSE),
50       m_bResourceMissing(FALSE) {
51   if (pmtContentToUser) {
52     m_mtContentToUser = *pmtContentToUser;
53   }
54   if (pOptions) {
55     m_Options = *pOptions;
56   }
57   if (!m_pResources) {
58     m_pResources = m_pParentResources;
59   }
60   if (!m_pResources) {
61     m_pResources = m_pPageResources;
62   }
63   if (pBBox) {
64     m_BBox = *pBBox;
65   }
66   if (pStates) {
67     m_pCurStates->Copy(*pStates);
68   } else {
69     m_pCurStates->m_GeneralState.New();
70     m_pCurStates->m_GraphState.New();
71     m_pCurStates->m_TextState.New();
72     m_pCurStates->m_ColorState.New();
73   }
74   for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
75     m_Type3Data[i] = 0.0;
76   }
77 }
78
79 CPDF_StreamContentParser::~CPDF_StreamContentParser() {
80   ClearAllParams();
81   for (int i = 0; i < m_StateStack.GetSize(); ++i) {
82     delete (CPDF_AllStates*)m_StateStack[i];
83   }
84   FX_Free(m_pPathPoints);
85   if (m_pLastImageDict) {
86     m_pLastImageDict->Release();
87   }
88   if (m_pLastCloneImageDict) {
89     m_pLastCloneImageDict->Release();
90   }
91 }
92 int CPDF_StreamContentParser::GetNextParamPos() {
93   if (m_ParamCount == PARAM_BUF_SIZE) {
94     m_ParamStartPos++;
95     if (m_ParamStartPos == PARAM_BUF_SIZE) {
96       m_ParamStartPos = 0;
97     }
98     if (m_ParamBuf1[m_ParamStartPos].m_Type == 0) {
99       if (CPDF_Object* pObject = m_ParamBuf1[m_ParamStartPos].m_pObject)
100         pObject->Release();
101     }
102     return m_ParamStartPos;
103   }
104   int index = m_ParamStartPos + m_ParamCount;
105   if (index >= PARAM_BUF_SIZE) {
106     index -= PARAM_BUF_SIZE;
107   }
108   m_ParamCount++;
109   return index;
110 }
111 void CPDF_StreamContentParser::AddNameParam(const FX_CHAR* name, int len) {
112   int index = GetNextParamPos();
113   if (len > 32) {
114     m_ParamBuf1[index].m_Type = 0;
115     m_ParamBuf1[index].m_pObject =
116         CPDF_Name::Create(PDF_NameDecode(CFX_ByteStringC(name, len)));
117   } else {
118     m_ParamBuf1[index].m_Type = PDFOBJ_NAME;
119     if (FXSYS_memchr(name, '#', len) == NULL) {
120       FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, name, len);
121       m_ParamBuf1[index].m_Name.m_Len = len;
122     } else {
123       CFX_ByteString str = PDF_NameDecode(CFX_ByteStringC(name, len));
124       FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, str.c_str(),
125                    str.GetLength());
126       m_ParamBuf1[index].m_Name.m_Len = str.GetLength();
127     }
128   }
129 }
130 void CPDF_StreamContentParser::AddNumberParam(const FX_CHAR* str, int len) {
131   int index = GetNextParamPos();
132   m_ParamBuf1[index].m_Type = PDFOBJ_NUMBER;
133   FX_atonum(CFX_ByteStringC(str, len), m_ParamBuf1[index].m_Number.m_bInteger,
134             &m_ParamBuf1[index].m_Number.m_Integer);
135 }
136 void CPDF_StreamContentParser::AddObjectParam(CPDF_Object* pObj) {
137   int index = GetNextParamPos();
138   m_ParamBuf1[index].m_Type = 0;
139   m_ParamBuf1[index].m_pObject = pObj;
140 }
141 void CPDF_StreamContentParser::ClearAllParams() {
142   FX_DWORD index = m_ParamStartPos;
143   for (FX_DWORD i = 0; i < m_ParamCount; i++) {
144     if (m_ParamBuf1[index].m_Type == 0) {
145       if (CPDF_Object* pObject = m_ParamBuf1[index].m_pObject)
146         pObject->Release();
147     }
148     index++;
149     if (index == PARAM_BUF_SIZE) {
150       index = 0;
151     }
152   }
153   m_ParamStartPos = 0;
154   m_ParamCount = 0;
155 }
156 CPDF_Object* CPDF_StreamContentParser::GetObject(FX_DWORD index) {
157   if (index >= m_ParamCount) {
158     return NULL;
159   }
160   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
161   if (real_index >= PARAM_BUF_SIZE) {
162     real_index -= PARAM_BUF_SIZE;
163   }
164   _ContentParam& param = m_ParamBuf1[real_index];
165   if (param.m_Type == PDFOBJ_NUMBER) {
166     CPDF_Number* pNumber = CPDF_Number::Create(param.m_Number.m_bInteger,
167                                                &param.m_Number.m_Integer);
168     param.m_Type = 0;
169     param.m_pObject = pNumber;
170     return pNumber;
171   }
172   if (param.m_Type == PDFOBJ_NAME) {
173     CPDF_Name* pName = CPDF_Name::Create(
174         CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len));
175     param.m_Type = 0;
176     param.m_pObject = pName;
177     return pName;
178   }
179   if (param.m_Type == 0) {
180     return param.m_pObject;
181   }
182   ASSERT(FALSE);
183   return NULL;
184 }
185 CFX_ByteString CPDF_StreamContentParser::GetString(FX_DWORD index) {
186   if (index >= m_ParamCount) {
187     return CFX_ByteString();
188   }
189   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
190   if (real_index >= PARAM_BUF_SIZE) {
191     real_index -= PARAM_BUF_SIZE;
192   }
193   _ContentParam& param = m_ParamBuf1[real_index];
194   if (param.m_Type == PDFOBJ_NAME) {
195     return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
196   }
197   if (param.m_Type == 0 && param.m_pObject) {
198     return param.m_pObject->GetString();
199   }
200   return CFX_ByteString();
201 }
202 FX_FLOAT CPDF_StreamContentParser::GetNumber(FX_DWORD index) {
203   if (index >= m_ParamCount) {
204     return 0;
205   }
206   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
207   if (real_index >= PARAM_BUF_SIZE) {
208     real_index -= PARAM_BUF_SIZE;
209   }
210   _ContentParam& param = m_ParamBuf1[real_index];
211   if (param.m_Type == PDFOBJ_NUMBER) {
212     return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
213                                      : param.m_Number.m_Float;
214   }
215   if (param.m_Type == 0 && param.m_pObject) {
216     return param.m_pObject->GetNumber();
217   }
218   return 0;
219 }
220 FX_FLOAT CPDF_StreamContentParser::GetNumber16(FX_DWORD index) {
221   return GetNumber(index);
222 }
223 void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
224                                                 FX_BOOL bColor,
225                                                 FX_BOOL bText,
226                                                 FX_BOOL bGraph) {
227   pObj->m_GeneralState = m_pCurStates->m_GeneralState;
228   pObj->m_ClipPath = m_pCurStates->m_ClipPath;
229   pObj->m_ContentMark = m_CurContentMark;
230   if (bColor) {
231     pObj->m_ColorState = m_pCurStates->m_ColorState;
232   }
233   if (bGraph) {
234     pObj->m_GraphState = m_pCurStates->m_GraphState;
235   }
236   if (bText) {
237     pObj->m_TextState = m_pCurStates->m_TextState;
238   }
239 }
240
241 const CPDF_StreamContentParser::OpCode CPDF_StreamContentParser::g_OpCodes[] = {
242     {FXBSTR_ID('"', 0, 0, 0),
243      &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
244     {FXBSTR_ID('\'', 0, 0, 0),
245      &CPDF_StreamContentParser::Handle_NextLineShowText},
246     {FXBSTR_ID('B', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillStrokePath},
247     {FXBSTR_ID('B', '*', 0, 0),
248      &CPDF_StreamContentParser::Handle_EOFillStrokePath},
249     {FXBSTR_ID('B', 'D', 'C', 0),
250      &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
251     {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
252     {FXBSTR_ID('B', 'M', 'C', 0),
253      &CPDF_StreamContentParser::Handle_BeginMarkedContent},
254     {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
255     {FXBSTR_ID('B', 'X', 0, 0),
256      &CPDF_StreamContentParser::Handle_BeginSectionUndefined},
257     {FXBSTR_ID('C', 'S', 0, 0),
258      &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
259     {FXBSTR_ID('D', 'P', 0, 0),
260      &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
261     {FXBSTR_ID('D', 'o', 0, 0),
262      &CPDF_StreamContentParser::Handle_ExecuteXObject},
263     {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
264     {FXBSTR_ID('E', 'M', 'C', 0),
265      &CPDF_StreamContentParser::Handle_EndMarkedContent},
266     {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
267     {FXBSTR_ID('E', 'X', 0, 0),
268      &CPDF_StreamContentParser::Handle_EndSectionUndefined},
269     {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
270     {FXBSTR_ID('G', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Stroke},
271     {FXBSTR_ID('I', 'D', 0, 0),
272      &CPDF_StreamContentParser::Handle_BeginImageData},
273     {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
274     {FXBSTR_ID('K', 0, 0, 0),
275      &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
276     {FXBSTR_ID('M', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetMiterLimit},
277     {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
278     {FXBSTR_ID('Q', 0, 0, 0),
279      &CPDF_StreamContentParser::Handle_RestoreGraphState},
280     {FXBSTR_ID('R', 'G', 0, 0),
281      &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
282     {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
283     {FXBSTR_ID('S', 'C', 0, 0),
284      &CPDF_StreamContentParser::Handle_SetColor_Stroke},
285     {FXBSTR_ID('S', 'C', 'N', 0),
286      &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
287     {FXBSTR_ID('T', '*', 0, 0),
288      &CPDF_StreamContentParser::Handle_MoveToNextLine},
289     {FXBSTR_ID('T', 'D', 0, 0),
290      &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
291     {FXBSTR_ID('T', 'J', 0, 0),
292      &CPDF_StreamContentParser::Handle_ShowText_Positioning},
293     {FXBSTR_ID('T', 'L', 0, 0),
294      &CPDF_StreamContentParser::Handle_SetTextLeading},
295     {FXBSTR_ID('T', 'c', 0, 0), &CPDF_StreamContentParser::Handle_SetCharSpace},
296     {FXBSTR_ID('T', 'd', 0, 0),
297      &CPDF_StreamContentParser::Handle_MoveTextPoint},
298     {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
299     {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
300     {FXBSTR_ID('T', 'm', 0, 0),
301      &CPDF_StreamContentParser::Handle_SetTextMatrix},
302     {FXBSTR_ID('T', 'r', 0, 0),
303      &CPDF_StreamContentParser::Handle_SetTextRenderMode},
304     {FXBSTR_ID('T', 's', 0, 0), &CPDF_StreamContentParser::Handle_SetTextRise},
305     {FXBSTR_ID('T', 'w', 0, 0), &CPDF_StreamContentParser::Handle_SetWordSpace},
306     {FXBSTR_ID('T', 'z', 0, 0), &CPDF_StreamContentParser::Handle_SetHorzScale},
307     {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
308     {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
309     {FXBSTR_ID('b', 0, 0, 0),
310      &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
311     {FXBSTR_ID('b', '*', 0, 0),
312      &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
313     {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
314     {FXBSTR_ID('c', 'm', 0, 0), &CPDF_StreamContentParser::Handle_ConcatMatrix},
315     {FXBSTR_ID('c', 's', 0, 0),
316      &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
317     {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
318     {FXBSTR_ID('d', '0', 0, 0), &CPDF_StreamContentParser::Handle_SetCharWidth},
319     {FXBSTR_ID('d', '1', 0, 0),
320      &CPDF_StreamContentParser::Handle_SetCachedDevice},
321     {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
322     {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
323     {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
324     {FXBSTR_ID('g', 's', 0, 0),
325      &CPDF_StreamContentParser::Handle_SetExtendGraphState},
326     {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
327     {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
328     {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
329     {FXBSTR_ID('k', 0, 0, 0),
330      &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
331     {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
332     {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
333     {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
334     {FXBSTR_ID('q', 0, 0, 0), &CPDF_StreamContentParser::Handle_SaveGraphState},
335     {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
336     {FXBSTR_ID('r', 'g', 0, 0),
337      &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
338     {FXBSTR_ID('r', 'i', 0, 0),
339      &CPDF_StreamContentParser::Handle_SetRenderIntent},
340     {FXBSTR_ID('s', 0, 0, 0),
341      &CPDF_StreamContentParser::Handle_CloseStrokePath},
342     {FXBSTR_ID('s', 'c', 0, 0),
343      &CPDF_StreamContentParser::Handle_SetColor_Fill},
344     {FXBSTR_ID('s', 'c', 'n', 0),
345      &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
346     {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
347     {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
348     {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
349     {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
350 };
351 FX_BOOL CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
352   int i = 0;
353   FX_DWORD opid = 0;
354   while (i < 4 && op[i]) {
355     opid = (opid << 8) + op[i];
356     i++;
357   }
358   while (i < 4) {
359     opid <<= 8;
360     i++;
361   };
362   int low = 0, high = sizeof g_OpCodes / sizeof(OpCode) - 1;
363   while (low <= high) {
364     int middle = (low + high) / 2;
365     int compare = opid - g_OpCodes[middle].m_OpId;
366     if (compare == 0) {
367       (this->*g_OpCodes[middle].m_OpHandler)();
368       return TRUE;
369     }
370     if (compare < 0) {
371       high = middle - 1;
372     } else {
373       low = middle + 1;
374     }
375   }
376   return m_CompatCount != 0;
377 }
378 void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
379   if (m_Options.m_bTextOnly) {
380     return;
381   }
382   Handle_ClosePath();
383   AddPathObject(FXFILL_WINDING, TRUE);
384 }
385 void CPDF_StreamContentParser::Handle_FillStrokePath() {
386   if (m_Options.m_bTextOnly) {
387     return;
388   }
389   AddPathObject(FXFILL_WINDING, TRUE);
390 }
391 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
392   if (m_Options.m_bTextOnly) {
393     return;
394   }
395   AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
396   AddPathObject(FXFILL_ALTERNATE, TRUE);
397 }
398 void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
399   if (m_Options.m_bTextOnly) {
400     return;
401   }
402   AddPathObject(FXFILL_ALTERNATE, TRUE);
403 }
404 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
405   if (!m_Options.m_bMarkedContent) {
406     return;
407   }
408   CFX_ByteString tag = GetString(1);
409   CPDF_Object* pProperty = GetObject(0);
410   if (pProperty == NULL) {
411     return;
412   }
413   FX_BOOL bDirect = TRUE;
414   if (pProperty->GetType() == PDFOBJ_NAME) {
415     pProperty = FindResourceObj(FX_BSTRC("Properties"), pProperty->GetString());
416     if (pProperty == NULL) {
417       return;
418     }
419     bDirect = FALSE;
420   }
421   if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
422     m_CurContentMark.GetModify()->AddMark(tag, pDict, bDirect);
423   }
424 }
425 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
426   if (!m_Options.m_bMarkedContent) {
427     return;
428   }
429   CFX_ByteString tag = GetString(0);
430   m_CurContentMark.GetModify()->AddMark(tag, NULL, FALSE);
431 }
432 struct _FX_BSTR {
433   const FX_CHAR* m_Ptr;
434   int m_Size;
435 };
436 #define _FX_BSTRC(str) \
437   { str, sizeof(str) - 1 }
438 const _FX_BSTR _PDF_InlineKeyAbbr[] = {
439     _FX_BSTRC("BitsPerComponent"),
440     _FX_BSTRC("BPC"),
441     _FX_BSTRC("ColorSpace"),
442     _FX_BSTRC("CS"),
443     _FX_BSTRC("Decode"),
444     _FX_BSTRC("D"),
445     _FX_BSTRC("DecodeParms"),
446     _FX_BSTRC("DP"),
447     _FX_BSTRC("Filter"),
448     _FX_BSTRC("F"),
449     _FX_BSTRC("Height"),
450     _FX_BSTRC("H"),
451     _FX_BSTRC("ImageMask"),
452     _FX_BSTRC("IM"),
453     _FX_BSTRC("Interpolate"),
454     _FX_BSTRC("I"),
455     _FX_BSTRC("Width"),
456     _FX_BSTRC("W"),
457 };
458 const _FX_BSTR _PDF_InlineValueAbbr[] = {
459     _FX_BSTRC("DeviceGray"),      _FX_BSTRC("G"),
460     _FX_BSTRC("DeviceRGB"),       _FX_BSTRC("RGB"),
461     _FX_BSTRC("DeviceCMYK"),      _FX_BSTRC("CMYK"),
462     _FX_BSTRC("Indexed"),         _FX_BSTRC("I"),
463     _FX_BSTRC("ASCIIHexDecode"),  _FX_BSTRC("AHx"),
464     _FX_BSTRC("ASCII85Decode"),   _FX_BSTRC("A85"),
465     _FX_BSTRC("LZWDecode"),       _FX_BSTRC("LZW"),
466     _FX_BSTRC("FlateDecode"),     _FX_BSTRC("Fl"),
467     _FX_BSTRC("RunLengthDecode"), _FX_BSTRC("RL"),
468     _FX_BSTRC("CCITTFaxDecode"),  _FX_BSTRC("CCF"),
469     _FX_BSTRC("DCTDecode"),       _FX_BSTRC("DCT"),
470 };
471 static CFX_ByteStringC _PDF_FindFullName(const _FX_BSTR* table,
472                                          int count,
473                                          const CFX_ByteStringC& abbr) {
474   int i = 0;
475   while (i < count) {
476     if (abbr.GetLength() == table[i + 1].m_Size &&
477         FXSYS_memcmp(abbr.GetPtr(), table[i + 1].m_Ptr, abbr.GetLength()) ==
478             0) {
479       return CFX_ByteStringC(table[i].m_Ptr, table[i].m_Size);
480     }
481     i += 2;
482   }
483   return CFX_ByteStringC();
484 }
485 void _PDF_ReplaceAbbr(CPDF_Object* pObj) {
486   switch (pObj->GetType()) {
487     case PDFOBJ_DICTIONARY: {
488       CPDF_Dictionary* pDict = pObj->AsDictionary();
489       FX_POSITION pos = pDict->GetStartPos();
490       while (pos) {
491         CFX_ByteString key;
492         CPDF_Object* value = pDict->GetNextElement(pos, key);
493         CFX_ByteStringC fullname = _PDF_FindFullName(
494             _PDF_InlineKeyAbbr, sizeof _PDF_InlineKeyAbbr / sizeof(_FX_BSTR),
495             key);
496         if (!fullname.IsEmpty()) {
497           pDict->ReplaceKey(key, fullname);
498           key = fullname;
499         }
500         if (value->GetType() == PDFOBJ_NAME) {
501           CFX_ByteString name = value->GetString();
502           fullname = _PDF_FindFullName(
503               _PDF_InlineValueAbbr,
504               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
505           if (!fullname.IsEmpty()) {
506             pDict->SetAtName(key, fullname);
507           }
508         } else {
509           _PDF_ReplaceAbbr(value);
510         }
511       }
512       break;
513     }
514     case PDFOBJ_ARRAY: {
515       CPDF_Array* pArray = (CPDF_Array*)pObj;
516       for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
517         CPDF_Object* pElement = pArray->GetElement(i);
518         if (pElement->GetType() == PDFOBJ_NAME) {
519           CFX_ByteString name = pElement->GetString();
520           CFX_ByteStringC fullname = _PDF_FindFullName(
521               _PDF_InlineValueAbbr,
522               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
523           if (!fullname.IsEmpty()) {
524             pArray->SetAt(i, CPDF_Name::Create(fullname));
525           }
526         } else {
527           _PDF_ReplaceAbbr(pElement);
528         }
529       }
530       break;
531     }
532   }
533 }
534 static CFX_ByteStringC _PDF_FindAbbrName(const _FX_BSTR* table,
535                                          int count,
536                                          const CFX_ByteStringC& fullName) {
537   int i = 0;
538   while (i < count) {
539     if (fullName.GetLength() == table[i].m_Size &&
540         FXSYS_memcmp(fullName.GetPtr(), table[i].m_Ptr, fullName.GetLength()) ==
541             0) {
542       return CFX_ByteStringC(table[i + 1].m_Ptr, table[i + 1].m_Size);
543     }
544     i += 2;
545   }
546   return CFX_ByteStringC();
547 }
548 void _PDF_ReplaceFull(CPDF_Object* pObj) {
549   switch (pObj->GetType()) {
550     case PDFOBJ_DICTIONARY: {
551       CPDF_Dictionary* pDict = pObj->AsDictionary();
552       FX_POSITION pos = pDict->GetStartPos();
553       while (pos) {
554         CFX_ByteString key;
555         CPDF_Object* value = pDict->GetNextElement(pos, key);
556         CFX_ByteStringC abbrName = _PDF_FindAbbrName(
557             _PDF_InlineKeyAbbr, sizeof(_PDF_InlineKeyAbbr) / sizeof(_FX_BSTR),
558             key);
559         if (!abbrName.IsEmpty()) {
560           pDict->ReplaceKey(key, abbrName);
561           key = abbrName;
562         }
563         if (value->GetType() == PDFOBJ_NAME) {
564           CFX_ByteString name = value->GetString();
565           abbrName = _PDF_FindAbbrName(
566               _PDF_InlineValueAbbr,
567               sizeof(_PDF_InlineValueAbbr) / sizeof(_FX_BSTR), name);
568           if (!abbrName.IsEmpty()) {
569             pDict->SetAtName(key, abbrName);
570           }
571         } else {
572           _PDF_ReplaceFull(value);
573         }
574       }
575       break;
576     }
577     case PDFOBJ_ARRAY: {
578       CPDF_Array* pArray = (CPDF_Array*)pObj;
579       for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
580         CPDF_Object* pElement = pArray->GetElement(i);
581         if (pElement->GetType() == PDFOBJ_NAME) {
582           CFX_ByteString name = pElement->GetString();
583           CFX_ByteStringC abbrName = _PDF_FindAbbrName(
584               _PDF_InlineValueAbbr,
585               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
586           if (!abbrName.IsEmpty()) {
587             pArray->SetAt(i, CPDF_Name::Create(abbrName));
588           }
589         } else {
590           _PDF_ReplaceFull(pElement);
591         }
592       }
593       break;
594     }
595   }
596 }
597 void CPDF_StreamContentParser::Handle_BeginText() {
598   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
599   OnChangeTextMatrix();
600   m_pCurStates->m_TextX = 0;
601   m_pCurStates->m_TextY = 0;
602   m_pCurStates->m_TextLineX = 0;
603   m_pCurStates->m_TextLineY = 0;
604 }
605 void CPDF_StreamContentParser::Handle_BeginSectionUndefined() {
606   m_CompatCount++;
607 }
608 void CPDF_StreamContentParser::Handle_CurveTo_123() {
609   if (m_Options.m_bTextOnly) {
610     return;
611   }
612   AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
613   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
614   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
615 }
616 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
617   FX_FLOAT a2 = GetNumber16(5), b2 = GetNumber16(4), c2 = GetNumber16(3),
618            d2 = GetNumber16(2);
619   FX_FLOAT e2 = GetNumber(1), f2 = GetNumber(0);
620   CFX_AffineMatrix new_matrix(a2, b2, c2, d2, e2, f2);
621   new_matrix.Concat(m_pCurStates->m_CTM);
622   m_pCurStates->m_CTM = new_matrix;
623   OnChangeTextMatrix();
624 }
625 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
626   if (m_Options.m_bTextOnly) {
627     return;
628   }
629   CFX_ByteString csname = GetString(0);
630   CPDF_ColorSpace* pCS = FindColorSpace(csname);
631   if (pCS == NULL) {
632     return;
633   }
634   m_pCurStates->m_ColorState.GetModify()->m_FillColor.SetColorSpace(pCS);
635 }
636 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
637   if (m_Options.m_bTextOnly) {
638     return;
639   }
640   CFX_ByteString csname = GetString(0);
641   CPDF_ColorSpace* pCS = FindColorSpace(csname);
642   if (pCS == NULL) {
643     return;
644   }
645   m_pCurStates->m_ColorState.GetModify()->m_StrokeColor.SetColorSpace(pCS);
646 }
647 void CPDF_StreamContentParser::Handle_SetDash() {
648   if (m_Options.m_bTextOnly) {
649     return;
650   }
651   CPDF_Array* pArray = GetObject(1) ? GetObject(1)->GetArray() : NULL;
652   if (pArray == NULL) {
653     return;
654   }
655   m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
656 }
657 void CPDF_StreamContentParser::Handle_SetCharWidth() {
658   m_Type3Data[0] = GetNumber(1);
659   m_Type3Data[1] = GetNumber(0);
660   m_bColored = TRUE;
661 }
662 void CPDF_StreamContentParser::Handle_SetCachedDevice() {
663   for (int i = 0; i < 6; i++) {
664     m_Type3Data[i] = GetNumber(5 - i);
665   }
666   m_bColored = FALSE;
667 }
668 void CPDF_StreamContentParser::Handle_ExecuteXObject() {
669   CFX_ByteString name = GetString(0);
670   if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
671       m_pLastImage->GetStream()->GetObjNum()) {
672     AddImage(NULL, m_pLastImage, FALSE);
673     return;
674   }
675   if (m_Options.m_bTextOnly) {
676     CPDF_Object* pRes = NULL;
677     if (m_pResources == NULL) {
678       return;
679     }
680     if (m_pResources == m_pPageResources) {
681       CPDF_Dictionary* pList = m_pResources->GetDict(FX_BSTRC("XObject"));
682       if (pList == NULL) {
683         return;
684       }
685       pRes = pList->GetElement(name);
686       if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
687         return;
688       }
689     } else {
690       CPDF_Dictionary* pList = m_pResources->GetDict(FX_BSTRC("XObject"));
691       if (pList == NULL) {
692         if (m_pPageResources == NULL) {
693           return;
694         }
695         CPDF_Dictionary* pList = m_pPageResources->GetDict(FX_BSTRC("XObject"));
696         if (pList == NULL) {
697           return;
698         }
699         pRes = pList->GetElement(name);
700         if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
701           return;
702         }
703       } else {
704         pRes = pList->GetElement(name);
705         if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
706           return;
707         }
708       }
709     }
710     FX_BOOL bForm;
711     if (m_pDocument->IsFormStream(((CPDF_Reference*)pRes)->GetRefObjNum(),
712                                   bForm) &&
713         !bForm) {
714       return;
715     }
716   }
717   CPDF_Stream* pXObject =
718       (CPDF_Stream*)FindResourceObj(FX_BSTRC("XObject"), name);
719   if (pXObject == NULL || pXObject->GetType() != PDFOBJ_STREAM) {
720     m_bResourceMissing = TRUE;
721     return;
722   }
723   CFX_ByteStringC type =
724       pXObject->GetDict()
725           ? pXObject->GetDict()->GetConstString(FX_BSTRC("Subtype"))
726           : CFX_ByteStringC();
727   if (type == FX_BSTRC("Image")) {
728     if (m_Options.m_bTextOnly) {
729       return;
730     }
731     CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
732     m_LastImageName = name;
733     m_pLastImage = pObj->m_pImage;
734   } else if (type == FX_BSTRC("Form")) {
735     AddForm(pXObject);
736   } else {
737     return;
738   }
739 }
740 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
741   if (!m_Options.m_bSeparateForm) {
742     CPDF_Dictionary* pResources =
743         pStream->GetDict()->GetDict(FX_BSTRC("Resources"));
744     CFX_AffineMatrix form_matrix =
745         pStream->GetDict()->GetMatrix(FX_BSTRC("Matrix"));
746     form_matrix.Concat(m_pCurStates->m_CTM);
747     CPDF_Array* pBBox = pStream->GetDict()->GetArray(FX_BSTRC("BBox"));
748     CFX_FloatRect form_bbox;
749     CPDF_Path ClipPath;
750     if (pBBox) {
751       form_bbox = pStream->GetDict()->GetRect(FX_BSTRC("BBox"));
752       ClipPath.New();
753       ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
754                           form_bbox.top);
755       ClipPath.Transform(&form_matrix);
756       form_bbox.Transform(&form_matrix);
757     }
758     CPDF_StreamContentParser parser(m_pDocument, m_pPageResources, m_pResources,
759                                     &m_mtContentToUser, m_pObjectList,
760                                     pResources, &form_bbox, &m_Options,
761                                     m_pCurStates.get(), m_Level + 1);
762     parser.m_pCurStates->m_CTM = form_matrix;
763     if (ClipPath.NotNull()) {
764       parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
765                                                  TRUE);
766     }
767     CPDF_StreamAcc stream;
768     stream.LoadAllData(pStream, FALSE);
769     if (stream.GetSize() == 0) {
770       return;
771     }
772     parser.Parse(stream.GetData(), stream.GetSize(), 0);
773     return;
774   }
775   CPDF_FormObject* pFormObj = new CPDF_FormObject;
776   pFormObj->m_pForm =
777       new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources);
778   pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
779   pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
780   CPDF_AllStates status;
781   status.m_GeneralState = m_pCurStates->m_GeneralState;
782   status.m_GraphState = m_pCurStates->m_GraphState;
783   status.m_ColorState = m_pCurStates->m_ColorState;
784   status.m_TextState = m_pCurStates->m_TextState;
785   pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
786   if (!m_pObjectList->m_bBackgroundAlphaNeeded &&
787       pFormObj->m_pForm->m_bBackgroundAlphaNeeded) {
788     m_pObjectList->m_bBackgroundAlphaNeeded = TRUE;
789   }
790   pFormObj->CalcBoundingBox();
791   SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
792   m_pObjectList->m_ObjectList.AddTail(pFormObj);
793 }
794 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream,
795                                                      CPDF_Image* pImage,
796                                                      FX_BOOL bInline) {
797   if (pStream == NULL && pImage == NULL) {
798     return NULL;
799   }
800   CFX_AffineMatrix ImageMatrix;
801   ImageMatrix.Copy(m_pCurStates->m_CTM);
802   ImageMatrix.Concat(m_mtContentToUser);
803   CPDF_ImageObject* pImageObj = new CPDF_ImageObject;
804   if (pImage) {
805     pImageObj->m_pImage =
806         m_pDocument->GetPageData()->GetImage(pImage->GetStream());
807   } else if (pStream->GetObjNum()) {
808     pImageObj->m_pImage = m_pDocument->LoadImageF(pStream);
809   } else {
810     pImageObj->m_pImage = new CPDF_Image(m_pDocument);
811     pImageObj->m_pImage->LoadImageF(pStream, bInline);
812   }
813   SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), FALSE, FALSE);
814   pImageObj->m_Matrix = ImageMatrix;
815   pImageObj->CalcBoundingBox();
816   m_pObjectList->m_ObjectList.AddTail(pImageObj);
817   return pImageObj;
818 }
819 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
820 void CPDF_StreamContentParser::Handle_EndImage() {}
821 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
822   if (!m_Options.m_bMarkedContent) {
823     return;
824   }
825   if (m_CurContentMark.IsNull()) {
826     return;
827   }
828   int count = m_CurContentMark.GetObject()->CountItems();
829   if (count == 1) {
830     m_CurContentMark.SetNull();
831     return;
832   }
833   m_CurContentMark.GetModify()->DeleteLastMark();
834 }
835 void CPDF_StreamContentParser::Handle_EndText() {
836   int count = m_ClipTextList.GetSize();
837   if (count == 0) {
838     return;
839   }
840   if (m_pCurStates->m_TextState.GetObject()->m_TextMode < 4) {
841     for (int i = 0; i < count; i++) {
842       CPDF_TextObject* pText = (CPDF_TextObject*)m_ClipTextList.GetAt(i);
843       delete pText;
844     }
845   } else {
846     m_pCurStates->m_ClipPath.AppendTexts(
847         (CPDF_TextObject**)m_ClipTextList.GetData(), count);
848   }
849   m_ClipTextList.RemoveAll();
850 }
851 void CPDF_StreamContentParser::Handle_EndSectionUndefined() {
852   if (m_CompatCount) {
853     m_CompatCount--;
854   }
855 }
856 void CPDF_StreamContentParser::Handle_FillPath() {
857   if (m_Options.m_bTextOnly) {
858     return;
859   }
860   AddPathObject(FXFILL_WINDING, FALSE);
861 }
862 void CPDF_StreamContentParser::Handle_FillPathOld() {
863   if (m_Options.m_bTextOnly) {
864     return;
865   }
866   AddPathObject(FXFILL_WINDING, FALSE);
867 }
868 void CPDF_StreamContentParser::Handle_EOFillPath() {
869   if (m_Options.m_bTextOnly) {
870     return;
871   }
872   AddPathObject(FXFILL_ALTERNATE, FALSE);
873 }
874 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
875   FX_FLOAT value = GetNumber(0);
876   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
877   m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
878 }
879 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
880   FX_FLOAT value = GetNumber(0);
881   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
882   m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
883 }
884 void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
885   CFX_ByteString name = GetString(0);
886   CPDF_Dictionary* pGS =
887       ToDictionary(FindResourceObj(FX_BSTRC("ExtGState"), name));
888   if (!pGS) {
889     m_bResourceMissing = TRUE;
890     return;
891   }
892   m_pCurStates->ProcessExtGS(pGS, this);
893 }
894 void CPDF_StreamContentParser::Handle_ClosePath() {
895   if (m_Options.m_bTextOnly) {
896     return;
897   }
898   if (m_PathPointCount == 0) {
899     return;
900   }
901   if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
902     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
903   } else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
904     m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
905   }
906 }
907 void CPDF_StreamContentParser::Handle_SetFlat() {
908   m_pCurStates->m_GeneralState.GetModify()->m_Flatness = GetNumber(0);
909 }
910 void CPDF_StreamContentParser::Handle_BeginImageData() {}
911 void CPDF_StreamContentParser::Handle_SetLineJoin() {
912   m_pCurStates->m_GraphState.GetModify()->m_LineJoin =
913       (CFX_GraphStateData::LineJoin)GetInteger(0);
914 }
915 void CPDF_StreamContentParser::Handle_SetLineCap() {
916   m_pCurStates->m_GraphState.GetModify()->m_LineCap =
917       (CFX_GraphStateData::LineCap)GetInteger(0);
918 }
919 void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
920   REQUIRE_PARAMS(4);
921   FX_FLOAT values[4];
922   for (int i = 0; i < 4; i++) {
923     values[i] = GetNumber(3 - i);
924   }
925   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
926   m_pCurStates->m_ColorState.SetFillColor(pCS, values, 4);
927 }
928 void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
929   REQUIRE_PARAMS(4);
930   FX_FLOAT values[4];
931   for (int i = 0; i < 4; i++) {
932     values[i] = GetNumber(3 - i);
933   }
934   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
935   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
936 }
937 void CPDF_StreamContentParser::Handle_LineTo() {
938   REQUIRE_PARAMS(2);
939   if (m_Options.m_bTextOnly) {
940     return;
941   }
942   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
943 }
944 void CPDF_StreamContentParser::Handle_MoveTo() {
945   REQUIRE_PARAMS(2);
946   if (m_Options.m_bTextOnly) {
947     m_pSyntax->SkipPathObject();
948     return;
949   }
950   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
951   ParsePathObject();
952 }
953 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
954   m_pCurStates->m_GraphState.GetModify()->m_MiterLimit = GetNumber(0);
955 }
956 void CPDF_StreamContentParser::Handle_MarkPlace() {}
957 void CPDF_StreamContentParser::Handle_EndPath() {
958   if (m_Options.m_bTextOnly) {
959     return;
960   }
961   AddPathObject(0, FALSE);
962 }
963 void CPDF_StreamContentParser::Handle_SaveGraphState() {
964   CPDF_AllStates* pStates = new CPDF_AllStates;
965   pStates->Copy(*m_pCurStates);
966   m_StateStack.Add(pStates);
967 }
968 void CPDF_StreamContentParser::Handle_RestoreGraphState() {
969   int size = m_StateStack.GetSize();
970   if (size == 0) {
971     return;
972   }
973   CPDF_AllStates* pStates = (CPDF_AllStates*)m_StateStack.GetAt(size - 1);
974   m_pCurStates->Copy(*pStates);
975   delete pStates;
976   m_StateStack.RemoveAt(size - 1);
977 }
978 void CPDF_StreamContentParser::Handle_Rectangle() {
979   if (m_Options.m_bTextOnly) {
980     return;
981   }
982   FX_FLOAT x = GetNumber(3), y = GetNumber(2);
983   FX_FLOAT w = GetNumber(1), h = GetNumber(0);
984   AddPathRect(x, y, w, h);
985 }
986 void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
987                                            FX_FLOAT y,
988                                            FX_FLOAT w,
989                                            FX_FLOAT h) {
990   AddPathPoint(x, y, FXPT_MOVETO);
991   AddPathPoint(x + w, y, FXPT_LINETO);
992   AddPathPoint(x + w, y + h, FXPT_LINETO);
993   AddPathPoint(x, y + h, FXPT_LINETO);
994   AddPathPoint(x, y, FXPT_LINETO | FXPT_CLOSEFIGURE);
995 }
996 void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
997   REQUIRE_PARAMS(3);
998   FX_FLOAT values[3];
999   for (int i = 0; i < 3; i++) {
1000     values[i] = GetNumber(2 - i);
1001   }
1002   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1003   m_pCurStates->m_ColorState.SetFillColor(pCS, values, 3);
1004 }
1005 void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
1006   REQUIRE_PARAMS(3);
1007   FX_FLOAT values[3];
1008   for (int i = 0; i < 3; i++) {
1009     values[i] = GetNumber(2 - i);
1010   }
1011   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1012   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
1013 }
1014 void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
1015 void CPDF_StreamContentParser::Handle_CloseStrokePath() {
1016   if (m_Options.m_bTextOnly) {
1017     return;
1018   }
1019   Handle_ClosePath();
1020   AddPathObject(0, TRUE);
1021 }
1022 void CPDF_StreamContentParser::Handle_StrokePath() {
1023   if (m_Options.m_bTextOnly) {
1024     return;
1025   }
1026   AddPathObject(0, TRUE);
1027 }
1028 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
1029   if (m_Options.m_bTextOnly) {
1030     return;
1031   }
1032   FX_FLOAT values[4];
1033   int nargs = m_ParamCount;
1034   if (nargs > 4) {
1035     nargs = 4;
1036   }
1037   for (int i = 0; i < nargs; i++) {
1038     values[i] = GetNumber(nargs - i - 1);
1039   }
1040   m_pCurStates->m_ColorState.SetFillColor(NULL, values, nargs);
1041 }
1042 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
1043   if (m_Options.m_bTextOnly) {
1044     return;
1045   }
1046   FX_FLOAT values[4];
1047   int nargs = m_ParamCount;
1048   if (nargs > 4) {
1049     nargs = 4;
1050   }
1051   for (int i = 0; i < nargs; i++) {
1052     values[i] = GetNumber(nargs - i - 1);
1053   }
1054   m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nargs);
1055 }
1056 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
1057   if (m_Options.m_bTextOnly) {
1058     return;
1059   }
1060   CPDF_Object* pLastParam = GetObject(0);
1061   if (pLastParam == NULL) {
1062     return;
1063   }
1064   int nargs = m_ParamCount;
1065   int nvalues = nargs;
1066   if (pLastParam->GetType() == PDFOBJ_NAME) {
1067     nvalues--;
1068   }
1069   FX_FLOAT* values = NULL;
1070   if (nvalues) {
1071     values = FX_Alloc(FX_FLOAT, nvalues);
1072     for (int i = 0; i < nvalues; i++) {
1073       values[i] = GetNumber(nargs - i - 1);
1074     }
1075   }
1076   if (nvalues != nargs) {
1077     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
1078     if (pPattern) {
1079       m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
1080     }
1081   } else {
1082     m_pCurStates->m_ColorState.SetFillColor(NULL, values, nvalues);
1083   }
1084   FX_Free(values);
1085 }
1086 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
1087   if (m_Options.m_bTextOnly) {
1088     return;
1089   }
1090   CPDF_Object* pLastParam = GetObject(0);
1091   if (pLastParam == NULL) {
1092     return;
1093   }
1094   int nargs = m_ParamCount;
1095   int nvalues = nargs;
1096   if (pLastParam->GetType() == PDFOBJ_NAME) {
1097     nvalues--;
1098   }
1099   FX_FLOAT* values = NULL;
1100   if (nvalues) {
1101     values = FX_Alloc(FX_FLOAT, nvalues);
1102     for (int i = 0; i < nvalues; i++) {
1103       values[i] = GetNumber(nargs - i - 1);
1104     }
1105   }
1106   if (nvalues != nargs) {
1107     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
1108     if (pPattern) {
1109       m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
1110     }
1111   } else {
1112     m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nvalues);
1113   }
1114   FX_Free(values);
1115 }
1116 CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream,
1117                               int type,
1118                               const CFX_AffineMatrix* pMatrix,
1119                               CPDF_Function** pFuncs,
1120                               int nFuncs,
1121                               CPDF_ColorSpace* pCS);
1122 void CPDF_StreamContentParser::Handle_ShadeFill() {
1123   if (m_Options.m_bTextOnly) {
1124     return;
1125   }
1126   CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
1127   if (pPattern == NULL) {
1128     return;
1129   }
1130   if (pPattern->m_PatternType != PATTERN_SHADING) {
1131     return;
1132   }
1133   CPDF_ShadingPattern* pShading = (CPDF_ShadingPattern*)pPattern;
1134   if (!pShading->m_bShadingObj) {
1135     return;
1136   }
1137   if (!pShading->Load()) {
1138     return;
1139   }
1140   CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
1141   pObj->m_pShading = pShading;
1142   SetGraphicStates(pObj, FALSE, FALSE, FALSE);
1143   pObj->m_Matrix = m_pCurStates->m_CTM;
1144   pObj->m_Matrix.Concat(m_mtContentToUser);
1145   CFX_FloatRect bbox;
1146   if (!pObj->m_ClipPath.IsNull()) {
1147     bbox = pObj->m_ClipPath.GetClipBox();
1148   } else {
1149     bbox = m_BBox;
1150   }
1151   if (pShading->m_ShadingType >= 4) {
1152     bbox.Intersect(_GetShadingBBox((CPDF_Stream*)pShading->m_pShadingObj,
1153                                    pShading->m_ShadingType, &pObj->m_Matrix,
1154                                    pShading->m_pFunctions, pShading->m_nFuncs,
1155                                    pShading->m_pCS));
1156   }
1157   pObj->m_Left = bbox.left;
1158   pObj->m_Right = bbox.right;
1159   pObj->m_Top = bbox.top;
1160   pObj->m_Bottom = bbox.bottom;
1161   m_pObjectList->m_ObjectList.AddTail(pObj);
1162 }
1163 void CPDF_StreamContentParser::Handle_SetCharSpace() {
1164   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(0);
1165 }
1166 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
1167   m_pCurStates->m_TextLineX += GetNumber(1);
1168   m_pCurStates->m_TextLineY += GetNumber(0);
1169   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1170   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1171 }
1172 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
1173   Handle_MoveTextPoint();
1174   m_pCurStates->m_TextLeading = -GetNumber(0);
1175 }
1176 void CPDF_StreamContentParser::Handle_SetFont() {
1177   FX_FLOAT fs = GetNumber(0);
1178   if (fs == 0) {
1179     fs = m_DefFontSize;
1180   }
1181   m_pCurStates->m_TextState.GetModify()->m_FontSize = fs;
1182   CPDF_Font* pFont = FindFont(GetString(1));
1183   if (pFont) {
1184     m_pCurStates->m_TextState.SetFont(pFont);
1185   }
1186 }
1187 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
1188     const CFX_ByteStringC& type,
1189     const CFX_ByteString& name) {
1190   if (m_pResources == NULL) {
1191     return NULL;
1192   }
1193   if (m_pResources == m_pPageResources) {
1194     CPDF_Dictionary* pList = m_pResources->GetDict(type);
1195     if (pList == NULL) {
1196       return NULL;
1197     }
1198     CPDF_Object* pRes = pList->GetElementValue(name);
1199     return pRes;
1200   }
1201   CPDF_Dictionary* pList = m_pResources->GetDict(type);
1202   if (pList == NULL) {
1203     if (m_pPageResources == NULL) {
1204       return NULL;
1205     }
1206     CPDF_Dictionary* pList = m_pPageResources->GetDict(type);
1207     if (pList == NULL) {
1208       return NULL;
1209     }
1210     CPDF_Object* pRes = pList->GetElementValue(name);
1211     return pRes;
1212   }
1213   CPDF_Object* pRes = pList->GetElementValue(name);
1214   return pRes;
1215 }
1216 CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
1217   CPDF_Dictionary* pFontDict =
1218       ToDictionary(FindResourceObj(FX_BSTRC("Font"), name));
1219   if (!pFontDict) {
1220     m_bResourceMissing = TRUE;
1221     return CPDF_Font::GetStockFont(m_pDocument, FX_BSTRC("Helvetica"));
1222   }
1223
1224   CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
1225   if (pFont && pFont->GetType3Font()) {
1226     pFont->GetType3Font()->SetPageResources(m_pResources);
1227     pFont->GetType3Font()->CheckType3FontMetrics();
1228   }
1229   return pFont;
1230 }
1231 CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
1232     const CFX_ByteString& name) {
1233   if (name == FX_BSTRC("Pattern")) {
1234     return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
1235   }
1236   if (name == FX_BSTRC("DeviceGray") || name == FX_BSTRC("DeviceCMYK") ||
1237       name == FX_BSTRC("DeviceRGB")) {
1238     CFX_ByteString defname = "Default";
1239     defname += name.Mid(7);
1240     CPDF_Object* pDefObj = FindResourceObj(FX_BSTRC("ColorSpace"), defname);
1241     if (pDefObj == NULL) {
1242       if (name == FX_BSTRC("DeviceGray")) {
1243         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
1244       }
1245       if (name == FX_BSTRC("DeviceRGB")) {
1246         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1247       }
1248       return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
1249     }
1250     return m_pDocument->LoadColorSpace(pDefObj);
1251   }
1252   CPDF_Object* pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
1253   if (pCSObj == NULL) {
1254     m_bResourceMissing = TRUE;
1255     return NULL;
1256   }
1257   return m_pDocument->LoadColorSpace(pCSObj);
1258 }
1259 CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
1260                                                     FX_BOOL bShading) {
1261   CPDF_Object* pPattern = FindResourceObj(
1262       bShading ? FX_BSTRC("Shading") : FX_BSTRC("Pattern"), name);
1263   if (pPattern == NULL ||
1264       (!pPattern->IsDictionary() && pPattern->GetType() != PDFOBJ_STREAM)) {
1265     m_bResourceMissing = TRUE;
1266     return NULL;
1267   }
1268   return m_pDocument->LoadPattern(pPattern, bShading,
1269                                   &m_pCurStates->m_ParentMatrix);
1270 }
1271 void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
1272   m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
1273   ConvertUserSpace(x, y);
1274 }
1275 void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
1276   m_pCurStates->m_CTM.Transform(x, y, x, y);
1277   m_mtContentToUser.Transform(x, y, x, y);
1278 }
1279 void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
1280                                              FX_FLOAT fInitKerning,
1281                                              FX_FLOAT* pKerning,
1282                                              int nsegs) {
1283   CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
1284   if (pFont == NULL) {
1285     return;
1286   }
1287   if (fInitKerning != 0) {
1288     if (!pFont->IsVertWriting()) {
1289       m_pCurStates->m_TextX -=
1290           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1291           1000;
1292     } else {
1293       m_pCurStates->m_TextY -=
1294           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1295           1000;
1296     }
1297   }
1298   if (nsegs == 0) {
1299     return;
1300   }
1301   int textmode;
1302   if (pFont->GetFontType() == PDFFONT_TYPE3) {
1303     textmode = 0;
1304   } else {
1305     textmode = m_pCurStates->m_TextState.GetObject()->m_TextMode;
1306   }
1307   CPDF_TextObject* pText = new CPDF_TextObject;
1308   m_pLastTextObject = pText;
1309   SetGraphicStates(pText, TRUE, TRUE, TRUE);
1310   if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
1311     FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
1312     pCTM[0] = m_pCurStates->m_CTM.a;
1313     pCTM[1] = m_pCurStates->m_CTM.c;
1314     pCTM[2] = m_pCurStates->m_CTM.b;
1315     pCTM[3] = m_pCurStates->m_CTM.d;
1316   }
1317   pText->SetSegments(pStrs, pKerning, nsegs);
1318   pText->m_PosX = m_pCurStates->m_TextX;
1319   pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
1320   ConvertTextSpace(pText->m_PosX, pText->m_PosY);
1321   FX_FLOAT x_advance, y_advance;
1322   pText->CalcPositionData(&x_advance, &y_advance, m_pCurStates->m_TextHorzScale,
1323                           m_Level);
1324   m_pCurStates->m_TextX += x_advance;
1325   m_pCurStates->m_TextY += y_advance;
1326   if (textmode > 3) {
1327     CPDF_TextObject* pCopy = new CPDF_TextObject;
1328     pCopy->Copy(pText);
1329     m_ClipTextList.Add(pCopy);
1330   }
1331   m_pObjectList->m_ObjectList.AddTail(pText);
1332   if (pKerning && pKerning[nsegs - 1] != 0) {
1333     if (!pFont->IsVertWriting()) {
1334       m_pCurStates->m_TextX -=
1335           FXSYS_Mul(pKerning[nsegs - 1],
1336                     m_pCurStates->m_TextState.GetFontSize()) /
1337           1000;
1338     } else {
1339       m_pCurStates->m_TextY -=
1340           FXSYS_Mul(pKerning[nsegs - 1],
1341                     m_pCurStates->m_TextState.GetFontSize()) /
1342           1000;
1343     }
1344   }
1345 }
1346 void CPDF_StreamContentParser::Handle_ShowText() {
1347   CFX_ByteString str = GetString(0);
1348   if (str.IsEmpty()) {
1349     return;
1350   }
1351   AddTextObject(&str, 0, NULL, 1);
1352 }
1353 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
1354   CPDF_Array* pArray = GetObject(0) ? GetObject(0)->GetArray() : NULL;
1355   if (pArray == NULL) {
1356     return;
1357   }
1358   int n = pArray->GetCount(), nsegs = 0, i;
1359   for (i = 0; i < n; i++) {
1360     CPDF_Object* pObj = pArray->GetElementValue(i);
1361     if (pObj->GetType() == PDFOBJ_STRING) {
1362       nsegs++;
1363     }
1364   }
1365   if (nsegs == 0) {
1366     for (i = 0; i < n; i++) {
1367       m_pCurStates->m_TextX -=
1368           FXSYS_Mul(pArray->GetNumber(i),
1369                     m_pCurStates->m_TextState.GetFontSize()) /
1370           1000;
1371     };
1372     return;
1373   }
1374   CFX_ByteString* pStrs = new CFX_ByteString[nsegs];
1375   FX_FLOAT* pKerning = FX_Alloc(FX_FLOAT, nsegs);
1376   int iSegment = 0;
1377   FX_FLOAT fInitKerning = 0;
1378   for (i = 0; i < n; i++) {
1379     CPDF_Object* pObj = pArray->GetElementValue(i);
1380     if (pObj->GetType() == PDFOBJ_STRING) {
1381       CFX_ByteString str = pObj->GetString();
1382       if (str.IsEmpty()) {
1383         continue;
1384       }
1385       pStrs[iSegment] = str;
1386       pKerning[iSegment++] = 0;
1387     } else {
1388       FX_FLOAT num = pObj ? pObj->GetNumber() : 0;
1389       if (iSegment == 0) {
1390         fInitKerning += num;
1391       } else {
1392         pKerning[iSegment - 1] += num;
1393       }
1394     }
1395   }
1396   AddTextObject(pStrs, fInitKerning, pKerning, iSegment);
1397   delete[] pStrs;
1398   FX_Free(pKerning);
1399 }
1400 void CPDF_StreamContentParser::Handle_SetTextLeading() {
1401   m_pCurStates->m_TextLeading = GetNumber(0);
1402 }
1403 void CPDF_StreamContentParser::Handle_SetTextMatrix() {
1404   m_pCurStates->m_TextMatrix.Set(GetNumber16(5), GetNumber16(4), GetNumber16(3),
1405                                  GetNumber16(2), GetNumber(1), GetNumber(0));
1406   OnChangeTextMatrix();
1407   m_pCurStates->m_TextX = 0;
1408   m_pCurStates->m_TextY = 0;
1409   m_pCurStates->m_TextLineX = 0;
1410   m_pCurStates->m_TextLineY = 0;
1411 }
1412 void CPDF_StreamContentParser::OnChangeTextMatrix() {
1413   CFX_AffineMatrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f,
1414                                0.0f, 0.0f);
1415   text_matrix.Concat(m_pCurStates->m_TextMatrix);
1416   text_matrix.Concat(m_pCurStates->m_CTM);
1417   text_matrix.Concat(m_mtContentToUser);
1418   FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetModify()->m_Matrix;
1419   pTextMatrix[0] = text_matrix.a;
1420   pTextMatrix[1] = text_matrix.c;
1421   pTextMatrix[2] = text_matrix.b;
1422   pTextMatrix[3] = text_matrix.d;
1423 }
1424 void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
1425   int mode = GetInteger(0);
1426   if (mode < 0 || mode > 7) {
1427     return;
1428   }
1429   m_pCurStates->m_TextState.GetModify()->m_TextMode = mode;
1430 }
1431 void CPDF_StreamContentParser::Handle_SetTextRise() {
1432   m_pCurStates->m_TextRise = GetNumber(0);
1433 }
1434 void CPDF_StreamContentParser::Handle_SetWordSpace() {
1435   m_pCurStates->m_TextState.GetModify()->m_WordSpace = GetNumber(0);
1436 }
1437 void CPDF_StreamContentParser::Handle_SetHorzScale() {
1438   if (m_ParamCount != 1) {
1439     return;
1440   }
1441   m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
1442   OnChangeTextMatrix();
1443 }
1444 void CPDF_StreamContentParser::Handle_MoveToNextLine() {
1445   m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
1446   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1447   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1448 }
1449 void CPDF_StreamContentParser::Handle_CurveTo_23() {
1450   if (m_Options.m_bTextOnly) {
1451     return;
1452   }
1453   AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
1454   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
1455   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1456 }
1457 void CPDF_StreamContentParser::Handle_SetLineWidth() {
1458   FX_FLOAT width = GetNumber(0);
1459   m_pCurStates->m_GraphState.GetModify()->m_LineWidth = width;
1460 }
1461 void CPDF_StreamContentParser::Handle_Clip() {
1462   m_PathClipType = FXFILL_WINDING;
1463 }
1464 void CPDF_StreamContentParser::Handle_EOClip() {
1465   m_PathClipType = FXFILL_ALTERNATE;
1466 }
1467 void CPDF_StreamContentParser::Handle_CurveTo_13() {
1468   if (m_Options.m_bTextOnly) {
1469     return;
1470   }
1471   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
1472   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1473   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
1474 }
1475 void CPDF_StreamContentParser::Handle_NextLineShowText() {
1476   Handle_MoveToNextLine();
1477   Handle_ShowText();
1478 }
1479 void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
1480   m_pCurStates->m_TextState.GetModify()->m_WordSpace = GetNumber(2);
1481   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(1);
1482   Handle_NextLineShowText();
1483 }
1484 void CPDF_StreamContentParser::Handle_Invalid() {}
1485 void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
1486   m_PathCurrentX = x;
1487   m_PathCurrentY = y;
1488   if (flag == FXPT_MOVETO) {
1489     m_PathStartX = x;
1490     m_PathStartY = y;
1491     if (m_PathPointCount &&
1492         m_pPathPoints[m_PathPointCount - 1].m_Flag == FXPT_MOVETO) {
1493       m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
1494       m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
1495       return;
1496     }
1497   } else if (m_PathPointCount == 0) {
1498     return;
1499   }
1500   m_PathPointCount++;
1501   if (m_PathPointCount > m_PathAllocSize) {
1502     int newsize = m_PathPointCount + 256;
1503     FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
1504     if (m_PathAllocSize) {
1505       FXSYS_memcpy(pNewPoints, m_pPathPoints,
1506                    m_PathAllocSize * sizeof(FX_PATHPOINT));
1507       FX_Free(m_pPathPoints);
1508     }
1509     m_pPathPoints = pNewPoints;
1510     m_PathAllocSize = newsize;
1511   }
1512   m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
1513   m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
1514   m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
1515 }
1516 void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke) {
1517   int PathPointCount = m_PathPointCount, PathClipType = m_PathClipType;
1518   m_PathPointCount = 0;
1519   m_PathClipType = 0;
1520   if (PathPointCount <= 1) {
1521     if (PathPointCount && PathClipType) {
1522       CPDF_Path path;
1523       path.New()->AppendRect(0, 0, 0, 0);
1524       m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
1525     }
1526     return;
1527   }
1528   if (PathPointCount &&
1529       m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
1530     PathPointCount--;
1531   }
1532   CPDF_Path Path;
1533   CFX_PathData* pPathData = Path.New();
1534   pPathData->SetPointCount(PathPointCount);
1535   FXSYS_memcpy(pPathData->GetPoints(), m_pPathPoints,
1536                sizeof(FX_PATHPOINT) * PathPointCount);
1537   CFX_AffineMatrix matrix = m_pCurStates->m_CTM;
1538   matrix.Concat(m_mtContentToUser);
1539   if (bStroke || FillType) {
1540     CPDF_PathObject* pPathObj = new CPDF_PathObject;
1541     pPathObj->m_bStroke = bStroke;
1542     pPathObj->m_FillType = FillType;
1543     pPathObj->m_Path = Path;
1544     pPathObj->m_Matrix = matrix;
1545     SetGraphicStates(pPathObj, TRUE, FALSE, TRUE);
1546     pPathObj->CalcBoundingBox();
1547     m_pObjectList->m_ObjectList.AddTail(pPathObj);
1548   }
1549   if (PathClipType) {
1550     if (!matrix.IsIdentity()) {
1551       Path.Transform(&matrix);
1552       matrix.SetIdentity();
1553     }
1554     m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
1555   }
1556 }
1557 CFX_ByteString _FPDF_ByteStringFromHex(CFX_BinaryBuf& src_buf) {
1558   CFX_ByteTextBuf buf;
1559   FX_BOOL bFirst = TRUE;
1560   int code = 0;
1561   const uint8_t* str = src_buf.GetBuffer();
1562   FX_DWORD size = src_buf.GetSize();
1563   for (FX_DWORD i = 0; i < size; i++) {
1564     uint8_t ch = str[i];
1565     if (ch >= '0' && ch <= '9') {
1566       if (bFirst) {
1567         code = (ch - '0') * 16;
1568       } else {
1569         code += ch - '0';
1570         buf.AppendChar((char)code);
1571       }
1572       bFirst = !bFirst;
1573     } else if (ch >= 'A' && ch <= 'F') {
1574       if (bFirst) {
1575         code = (ch - 'A' + 10) * 16;
1576       } else {
1577         code += ch - 'A' + 10;
1578         buf.AppendChar((char)code);
1579       }
1580       bFirst = !bFirst;
1581     } else if (ch >= 'a' && ch <= 'f') {
1582       if (bFirst) {
1583         code = (ch - 'a' + 10) * 16;
1584       } else {
1585         code += ch - 'a' + 10;
1586         buf.AppendChar((char)code);
1587       }
1588       bFirst = !bFirst;
1589     }
1590   }
1591   if (!bFirst) {
1592     buf.AppendChar((char)code);
1593   }
1594   return buf.GetByteString();
1595 }