Revert "Add type cast definitions for CPDF_Reference."
[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 = param.m_Number.m_bInteger
167                                ? CPDF_Number::Create(param.m_Number.m_Integer)
168                                : CPDF_Number::Create(param.m_Number.m_Float);
169
170     param.m_Type = 0;
171     param.m_pObject = pNumber;
172     return pNumber;
173   }
174   if (param.m_Type == PDFOBJ_NAME) {
175     CPDF_Name* pName = CPDF_Name::Create(
176         CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len));
177     param.m_Type = 0;
178     param.m_pObject = pName;
179     return pName;
180   }
181   if (param.m_Type == 0) {
182     return param.m_pObject;
183   }
184   ASSERT(FALSE);
185   return NULL;
186 }
187 CFX_ByteString CPDF_StreamContentParser::GetString(FX_DWORD index) {
188   if (index >= m_ParamCount) {
189     return CFX_ByteString();
190   }
191   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
192   if (real_index >= PARAM_BUF_SIZE) {
193     real_index -= PARAM_BUF_SIZE;
194   }
195   _ContentParam& param = m_ParamBuf1[real_index];
196   if (param.m_Type == PDFOBJ_NAME) {
197     return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
198   }
199   if (param.m_Type == 0 && param.m_pObject) {
200     return param.m_pObject->GetString();
201   }
202   return CFX_ByteString();
203 }
204 FX_FLOAT CPDF_StreamContentParser::GetNumber(FX_DWORD index) {
205   if (index >= m_ParamCount) {
206     return 0;
207   }
208   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
209   if (real_index >= PARAM_BUF_SIZE) {
210     real_index -= PARAM_BUF_SIZE;
211   }
212   _ContentParam& param = m_ParamBuf1[real_index];
213   if (param.m_Type == PDFOBJ_NUMBER) {
214     return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
215                                      : param.m_Number.m_Float;
216   }
217   if (param.m_Type == 0 && param.m_pObject) {
218     return param.m_pObject->GetNumber();
219   }
220   return 0;
221 }
222 FX_FLOAT CPDF_StreamContentParser::GetNumber16(FX_DWORD index) {
223   return GetNumber(index);
224 }
225 void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
226                                                 FX_BOOL bColor,
227                                                 FX_BOOL bText,
228                                                 FX_BOOL bGraph) {
229   pObj->m_GeneralState = m_pCurStates->m_GeneralState;
230   pObj->m_ClipPath = m_pCurStates->m_ClipPath;
231   pObj->m_ContentMark = m_CurContentMark;
232   if (bColor) {
233     pObj->m_ColorState = m_pCurStates->m_ColorState;
234   }
235   if (bGraph) {
236     pObj->m_GraphState = m_pCurStates->m_GraphState;
237   }
238   if (bText) {
239     pObj->m_TextState = m_pCurStates->m_TextState;
240   }
241 }
242
243 const CPDF_StreamContentParser::OpCode CPDF_StreamContentParser::g_OpCodes[] = {
244     {FXBSTR_ID('"', 0, 0, 0),
245      &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
246     {FXBSTR_ID('\'', 0, 0, 0),
247      &CPDF_StreamContentParser::Handle_NextLineShowText},
248     {FXBSTR_ID('B', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillStrokePath},
249     {FXBSTR_ID('B', '*', 0, 0),
250      &CPDF_StreamContentParser::Handle_EOFillStrokePath},
251     {FXBSTR_ID('B', 'D', 'C', 0),
252      &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
253     {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
254     {FXBSTR_ID('B', 'M', 'C', 0),
255      &CPDF_StreamContentParser::Handle_BeginMarkedContent},
256     {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
257     {FXBSTR_ID('B', 'X', 0, 0),
258      &CPDF_StreamContentParser::Handle_BeginSectionUndefined},
259     {FXBSTR_ID('C', 'S', 0, 0),
260      &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
261     {FXBSTR_ID('D', 'P', 0, 0),
262      &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
263     {FXBSTR_ID('D', 'o', 0, 0),
264      &CPDF_StreamContentParser::Handle_ExecuteXObject},
265     {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
266     {FXBSTR_ID('E', 'M', 'C', 0),
267      &CPDF_StreamContentParser::Handle_EndMarkedContent},
268     {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
269     {FXBSTR_ID('E', 'X', 0, 0),
270      &CPDF_StreamContentParser::Handle_EndSectionUndefined},
271     {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
272     {FXBSTR_ID('G', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Stroke},
273     {FXBSTR_ID('I', 'D', 0, 0),
274      &CPDF_StreamContentParser::Handle_BeginImageData},
275     {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
276     {FXBSTR_ID('K', 0, 0, 0),
277      &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
278     {FXBSTR_ID('M', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetMiterLimit},
279     {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
280     {FXBSTR_ID('Q', 0, 0, 0),
281      &CPDF_StreamContentParser::Handle_RestoreGraphState},
282     {FXBSTR_ID('R', 'G', 0, 0),
283      &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
284     {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
285     {FXBSTR_ID('S', 'C', 0, 0),
286      &CPDF_StreamContentParser::Handle_SetColor_Stroke},
287     {FXBSTR_ID('S', 'C', 'N', 0),
288      &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
289     {FXBSTR_ID('T', '*', 0, 0),
290      &CPDF_StreamContentParser::Handle_MoveToNextLine},
291     {FXBSTR_ID('T', 'D', 0, 0),
292      &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
293     {FXBSTR_ID('T', 'J', 0, 0),
294      &CPDF_StreamContentParser::Handle_ShowText_Positioning},
295     {FXBSTR_ID('T', 'L', 0, 0),
296      &CPDF_StreamContentParser::Handle_SetTextLeading},
297     {FXBSTR_ID('T', 'c', 0, 0), &CPDF_StreamContentParser::Handle_SetCharSpace},
298     {FXBSTR_ID('T', 'd', 0, 0),
299      &CPDF_StreamContentParser::Handle_MoveTextPoint},
300     {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
301     {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
302     {FXBSTR_ID('T', 'm', 0, 0),
303      &CPDF_StreamContentParser::Handle_SetTextMatrix},
304     {FXBSTR_ID('T', 'r', 0, 0),
305      &CPDF_StreamContentParser::Handle_SetTextRenderMode},
306     {FXBSTR_ID('T', 's', 0, 0), &CPDF_StreamContentParser::Handle_SetTextRise},
307     {FXBSTR_ID('T', 'w', 0, 0), &CPDF_StreamContentParser::Handle_SetWordSpace},
308     {FXBSTR_ID('T', 'z', 0, 0), &CPDF_StreamContentParser::Handle_SetHorzScale},
309     {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
310     {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
311     {FXBSTR_ID('b', 0, 0, 0),
312      &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
313     {FXBSTR_ID('b', '*', 0, 0),
314      &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
315     {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
316     {FXBSTR_ID('c', 'm', 0, 0), &CPDF_StreamContentParser::Handle_ConcatMatrix},
317     {FXBSTR_ID('c', 's', 0, 0),
318      &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
319     {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
320     {FXBSTR_ID('d', '0', 0, 0), &CPDF_StreamContentParser::Handle_SetCharWidth},
321     {FXBSTR_ID('d', '1', 0, 0),
322      &CPDF_StreamContentParser::Handle_SetCachedDevice},
323     {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
324     {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
325     {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
326     {FXBSTR_ID('g', 's', 0, 0),
327      &CPDF_StreamContentParser::Handle_SetExtendGraphState},
328     {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
329     {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
330     {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
331     {FXBSTR_ID('k', 0, 0, 0),
332      &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
333     {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
334     {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
335     {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
336     {FXBSTR_ID('q', 0, 0, 0), &CPDF_StreamContentParser::Handle_SaveGraphState},
337     {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
338     {FXBSTR_ID('r', 'g', 0, 0),
339      &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
340     {FXBSTR_ID('r', 'i', 0, 0),
341      &CPDF_StreamContentParser::Handle_SetRenderIntent},
342     {FXBSTR_ID('s', 0, 0, 0),
343      &CPDF_StreamContentParser::Handle_CloseStrokePath},
344     {FXBSTR_ID('s', 'c', 0, 0),
345      &CPDF_StreamContentParser::Handle_SetColor_Fill},
346     {FXBSTR_ID('s', 'c', 'n', 0),
347      &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
348     {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
349     {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
350     {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
351     {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
352 };
353 FX_BOOL CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
354   int i = 0;
355   FX_DWORD opid = 0;
356   while (i < 4 && op[i]) {
357     opid = (opid << 8) + op[i];
358     i++;
359   }
360   while (i < 4) {
361     opid <<= 8;
362     i++;
363   };
364   int low = 0, high = sizeof g_OpCodes / sizeof(OpCode) - 1;
365   while (low <= high) {
366     int middle = (low + high) / 2;
367     int compare = opid - g_OpCodes[middle].m_OpId;
368     if (compare == 0) {
369       (this->*g_OpCodes[middle].m_OpHandler)();
370       return TRUE;
371     }
372     if (compare < 0) {
373       high = middle - 1;
374     } else {
375       low = middle + 1;
376     }
377   }
378   return m_CompatCount != 0;
379 }
380 void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
381   if (m_Options.m_bTextOnly) {
382     return;
383   }
384   Handle_ClosePath();
385   AddPathObject(FXFILL_WINDING, TRUE);
386 }
387 void CPDF_StreamContentParser::Handle_FillStrokePath() {
388   if (m_Options.m_bTextOnly) {
389     return;
390   }
391   AddPathObject(FXFILL_WINDING, TRUE);
392 }
393 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
394   if (m_Options.m_bTextOnly) {
395     return;
396   }
397   AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
398   AddPathObject(FXFILL_ALTERNATE, TRUE);
399 }
400 void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
401   if (m_Options.m_bTextOnly) {
402     return;
403   }
404   AddPathObject(FXFILL_ALTERNATE, TRUE);
405 }
406 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
407   if (!m_Options.m_bMarkedContent) {
408     return;
409   }
410   CFX_ByteString tag = GetString(1);
411   CPDF_Object* pProperty = GetObject(0);
412   if (pProperty == NULL) {
413     return;
414   }
415   FX_BOOL bDirect = TRUE;
416   if (pProperty->IsName()) {
417     pProperty = FindResourceObj(FX_BSTRC("Properties"), pProperty->GetString());
418     if (!pProperty)
419       return;
420     bDirect = FALSE;
421   }
422   if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
423     m_CurContentMark.GetModify()->AddMark(tag, pDict, bDirect);
424   }
425 }
426 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
427   if (!m_Options.m_bMarkedContent) {
428     return;
429   }
430   CFX_ByteString tag = GetString(0);
431   m_CurContentMark.GetModify()->AddMark(tag, NULL, FALSE);
432 }
433 struct _FX_BSTR {
434   const FX_CHAR* m_Ptr;
435   int m_Size;
436 };
437 #define _FX_BSTRC(str) \
438   { str, sizeof(str) - 1 }
439 const _FX_BSTR _PDF_InlineKeyAbbr[] = {
440     _FX_BSTRC("BitsPerComponent"),
441     _FX_BSTRC("BPC"),
442     _FX_BSTRC("ColorSpace"),
443     _FX_BSTRC("CS"),
444     _FX_BSTRC("Decode"),
445     _FX_BSTRC("D"),
446     _FX_BSTRC("DecodeParms"),
447     _FX_BSTRC("DP"),
448     _FX_BSTRC("Filter"),
449     _FX_BSTRC("F"),
450     _FX_BSTRC("Height"),
451     _FX_BSTRC("H"),
452     _FX_BSTRC("ImageMask"),
453     _FX_BSTRC("IM"),
454     _FX_BSTRC("Interpolate"),
455     _FX_BSTRC("I"),
456     _FX_BSTRC("Width"),
457     _FX_BSTRC("W"),
458 };
459 const _FX_BSTR _PDF_InlineValueAbbr[] = {
460     _FX_BSTRC("DeviceGray"),      _FX_BSTRC("G"),
461     _FX_BSTRC("DeviceRGB"),       _FX_BSTRC("RGB"),
462     _FX_BSTRC("DeviceCMYK"),      _FX_BSTRC("CMYK"),
463     _FX_BSTRC("Indexed"),         _FX_BSTRC("I"),
464     _FX_BSTRC("ASCIIHexDecode"),  _FX_BSTRC("AHx"),
465     _FX_BSTRC("ASCII85Decode"),   _FX_BSTRC("A85"),
466     _FX_BSTRC("LZWDecode"),       _FX_BSTRC("LZW"),
467     _FX_BSTRC("FlateDecode"),     _FX_BSTRC("Fl"),
468     _FX_BSTRC("RunLengthDecode"), _FX_BSTRC("RL"),
469     _FX_BSTRC("CCITTFaxDecode"),  _FX_BSTRC("CCF"),
470     _FX_BSTRC("DCTDecode"),       _FX_BSTRC("DCT"),
471 };
472 static CFX_ByteStringC _PDF_FindFullName(const _FX_BSTR* table,
473                                          int count,
474                                          const CFX_ByteStringC& abbr) {
475   int i = 0;
476   while (i < count) {
477     if (abbr.GetLength() == table[i + 1].m_Size &&
478         FXSYS_memcmp(abbr.GetPtr(), table[i + 1].m_Ptr, abbr.GetLength()) ==
479             0) {
480       return CFX_ByteStringC(table[i].m_Ptr, table[i].m_Size);
481     }
482     i += 2;
483   }
484   return CFX_ByteStringC();
485 }
486 void _PDF_ReplaceAbbr(CPDF_Object* pObj) {
487   switch (pObj->GetType()) {
488     case PDFOBJ_DICTIONARY: {
489       CPDF_Dictionary* pDict = pObj->AsDictionary();
490       FX_POSITION pos = pDict->GetStartPos();
491       while (pos) {
492         CFX_ByteString key;
493         CPDF_Object* value = pDict->GetNextElement(pos, key);
494         CFX_ByteStringC fullname = _PDF_FindFullName(
495             _PDF_InlineKeyAbbr, sizeof _PDF_InlineKeyAbbr / sizeof(_FX_BSTR),
496             key);
497         if (!fullname.IsEmpty()) {
498           pDict->ReplaceKey(key, fullname);
499           key = fullname;
500         }
501
502         if (value->IsName()) {
503           CFX_ByteString name = value->GetString();
504           fullname = _PDF_FindFullName(
505               _PDF_InlineValueAbbr,
506               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
507           if (!fullname.IsEmpty()) {
508             pDict->SetAtName(key, fullname);
509           }
510         } else {
511           _PDF_ReplaceAbbr(value);
512         }
513       }
514       break;
515     }
516     case PDFOBJ_ARRAY: {
517       CPDF_Array* pArray = pObj->AsArray();
518       for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
519         CPDF_Object* pElement = pArray->GetElement(i);
520         if (pElement->IsName()) {
521           CFX_ByteString name = pElement->GetString();
522           CFX_ByteStringC fullname = _PDF_FindFullName(
523               _PDF_InlineValueAbbr,
524               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
525           if (!fullname.IsEmpty()) {
526             pArray->SetAt(i, CPDF_Name::Create(fullname));
527           }
528         } else {
529           _PDF_ReplaceAbbr(pElement);
530         }
531       }
532       break;
533     }
534   }
535 }
536 static CFX_ByteStringC _PDF_FindAbbrName(const _FX_BSTR* table,
537                                          int count,
538                                          const CFX_ByteStringC& fullName) {
539   int i = 0;
540   while (i < count) {
541     if (fullName.GetLength() == table[i].m_Size &&
542         FXSYS_memcmp(fullName.GetPtr(), table[i].m_Ptr, fullName.GetLength()) ==
543             0) {
544       return CFX_ByteStringC(table[i + 1].m_Ptr, table[i + 1].m_Size);
545     }
546     i += 2;
547   }
548   return CFX_ByteStringC();
549 }
550 void _PDF_ReplaceFull(CPDF_Object* pObj) {
551   switch (pObj->GetType()) {
552     case PDFOBJ_DICTIONARY: {
553       CPDF_Dictionary* pDict = pObj->AsDictionary();
554       FX_POSITION pos = pDict->GetStartPos();
555       while (pos) {
556         CFX_ByteString key;
557         CPDF_Object* value = pDict->GetNextElement(pos, key);
558         CFX_ByteStringC abbrName = _PDF_FindAbbrName(
559             _PDF_InlineKeyAbbr, sizeof(_PDF_InlineKeyAbbr) / sizeof(_FX_BSTR),
560             key);
561         if (!abbrName.IsEmpty()) {
562           pDict->ReplaceKey(key, abbrName);
563           key = abbrName;
564         }
565         if (value->IsName()) {
566           CFX_ByteString name = value->GetString();
567           abbrName = _PDF_FindAbbrName(
568               _PDF_InlineValueAbbr,
569               sizeof(_PDF_InlineValueAbbr) / sizeof(_FX_BSTR), name);
570           if (!abbrName.IsEmpty()) {
571             pDict->SetAtName(key, abbrName);
572           }
573         } else {
574           _PDF_ReplaceFull(value);
575         }
576       }
577       break;
578     }
579     case PDFOBJ_ARRAY: {
580       CPDF_Array* pArray = pObj->AsArray();
581       for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
582         CPDF_Object* pElement = pArray->GetElement(i);
583         if (pElement->IsName()) {
584           CFX_ByteString name = pElement->GetString();
585           CFX_ByteStringC abbrName = _PDF_FindAbbrName(
586               _PDF_InlineValueAbbr,
587               sizeof _PDF_InlineValueAbbr / sizeof(_FX_BSTR), name);
588           if (!abbrName.IsEmpty()) {
589             pArray->SetAt(i, CPDF_Name::Create(abbrName));
590           }
591         } else {
592           _PDF_ReplaceFull(pElement);
593         }
594       }
595       break;
596     }
597   }
598 }
599 void CPDF_StreamContentParser::Handle_BeginText() {
600   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
601   OnChangeTextMatrix();
602   m_pCurStates->m_TextX = 0;
603   m_pCurStates->m_TextY = 0;
604   m_pCurStates->m_TextLineX = 0;
605   m_pCurStates->m_TextLineY = 0;
606 }
607 void CPDF_StreamContentParser::Handle_BeginSectionUndefined() {
608   m_CompatCount++;
609 }
610 void CPDF_StreamContentParser::Handle_CurveTo_123() {
611   if (m_Options.m_bTextOnly) {
612     return;
613   }
614   AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
615   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
616   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
617 }
618 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
619   FX_FLOAT a2 = GetNumber16(5), b2 = GetNumber16(4), c2 = GetNumber16(3),
620            d2 = GetNumber16(2);
621   FX_FLOAT e2 = GetNumber(1), f2 = GetNumber(0);
622   CFX_AffineMatrix new_matrix(a2, b2, c2, d2, e2, f2);
623   new_matrix.Concat(m_pCurStates->m_CTM);
624   m_pCurStates->m_CTM = new_matrix;
625   OnChangeTextMatrix();
626 }
627 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
628   if (m_Options.m_bTextOnly) {
629     return;
630   }
631   CFX_ByteString csname = GetString(0);
632   CPDF_ColorSpace* pCS = FindColorSpace(csname);
633   if (pCS == NULL) {
634     return;
635   }
636   m_pCurStates->m_ColorState.GetModify()->m_FillColor.SetColorSpace(pCS);
637 }
638 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
639   if (m_Options.m_bTextOnly) {
640     return;
641   }
642   CFX_ByteString csname = GetString(0);
643   CPDF_ColorSpace* pCS = FindColorSpace(csname);
644   if (pCS == NULL) {
645     return;
646   }
647   m_pCurStates->m_ColorState.GetModify()->m_StrokeColor.SetColorSpace(pCS);
648 }
649 void CPDF_StreamContentParser::Handle_SetDash() {
650   if (m_Options.m_bTextOnly) {
651     return;
652   }
653   CPDF_Array* pArray = GetObject(1) ? GetObject(1)->GetArray() : NULL;
654   if (pArray == NULL) {
655     return;
656   }
657   m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
658 }
659 void CPDF_StreamContentParser::Handle_SetCharWidth() {
660   m_Type3Data[0] = GetNumber(1);
661   m_Type3Data[1] = GetNumber(0);
662   m_bColored = TRUE;
663 }
664 void CPDF_StreamContentParser::Handle_SetCachedDevice() {
665   for (int i = 0; i < 6; i++) {
666     m_Type3Data[i] = GetNumber(5 - i);
667   }
668   m_bColored = FALSE;
669 }
670 void CPDF_StreamContentParser::Handle_ExecuteXObject() {
671   CFX_ByteString name = GetString(0);
672   if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
673       m_pLastImage->GetStream()->GetObjNum()) {
674     AddImage(NULL, m_pLastImage, FALSE);
675     return;
676   }
677   if (m_Options.m_bTextOnly) {
678     CPDF_Object* pRes = NULL;
679     if (m_pResources == NULL) {
680       return;
681     }
682     if (m_pResources == m_pPageResources) {
683       CPDF_Dictionary* pList = m_pResources->GetDict(FX_BSTRC("XObject"));
684       if (pList == NULL) {
685         return;
686       }
687       pRes = pList->GetElement(name);
688       if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
689         return;
690       }
691     } else {
692       CPDF_Dictionary* pList = m_pResources->GetDict(FX_BSTRC("XObject"));
693       if (pList == NULL) {
694         if (m_pPageResources == NULL) {
695           return;
696         }
697         CPDF_Dictionary* pList = m_pPageResources->GetDict(FX_BSTRC("XObject"));
698         if (pList == NULL) {
699           return;
700         }
701         pRes = pList->GetElement(name);
702         if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
703           return;
704         }
705       } else {
706         pRes = pList->GetElement(name);
707         if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
708           return;
709         }
710       }
711     }
712     FX_BOOL bForm;
713     if (m_pDocument->IsFormStream(((CPDF_Reference*)pRes)->GetRefObjNum(),
714                                   bForm) &&
715         !bForm) {
716       return;
717     }
718   }
719   CPDF_Stream* pXObject = ToStream(FindResourceObj(FX_BSTRC("XObject"), name));
720   if (!pXObject) {
721     m_bResourceMissing = TRUE;
722     return;
723   }
724
725   CFX_ByteStringC type =
726       pXObject->GetDict()
727           ? pXObject->GetDict()->GetConstString(FX_BSTRC("Subtype"))
728           : CFX_ByteStringC();
729   if (type == FX_BSTRC("Image")) {
730     if (m_Options.m_bTextOnly) {
731       return;
732     }
733     CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
734     m_LastImageName = name;
735     m_pLastImage = pObj->m_pImage;
736   } else if (type == FX_BSTRC("Form")) {
737     AddForm(pXObject);
738   } else {
739     return;
740   }
741 }
742 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
743   if (!m_Options.m_bSeparateForm) {
744     CPDF_Dictionary* pResources =
745         pStream->GetDict()->GetDict(FX_BSTRC("Resources"));
746     CFX_AffineMatrix form_matrix =
747         pStream->GetDict()->GetMatrix(FX_BSTRC("Matrix"));
748     form_matrix.Concat(m_pCurStates->m_CTM);
749     CPDF_Array* pBBox = pStream->GetDict()->GetArray(FX_BSTRC("BBox"));
750     CFX_FloatRect form_bbox;
751     CPDF_Path ClipPath;
752     if (pBBox) {
753       form_bbox = pStream->GetDict()->GetRect(FX_BSTRC("BBox"));
754       ClipPath.New();
755       ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
756                           form_bbox.top);
757       ClipPath.Transform(&form_matrix);
758       form_bbox.Transform(&form_matrix);
759     }
760     CPDF_StreamContentParser parser(m_pDocument, m_pPageResources, m_pResources,
761                                     &m_mtContentToUser, m_pObjectList,
762                                     pResources, &form_bbox, &m_Options,
763                                     m_pCurStates.get(), m_Level + 1);
764     parser.m_pCurStates->m_CTM = form_matrix;
765     if (ClipPath.NotNull()) {
766       parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
767                                                  TRUE);
768     }
769     CPDF_StreamAcc stream;
770     stream.LoadAllData(pStream, FALSE);
771     if (stream.GetSize() == 0) {
772       return;
773     }
774     parser.Parse(stream.GetData(), stream.GetSize(), 0);
775     return;
776   }
777   CPDF_FormObject* pFormObj = new CPDF_FormObject;
778   pFormObj->m_pForm =
779       new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources);
780   pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
781   pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
782   CPDF_AllStates status;
783   status.m_GeneralState = m_pCurStates->m_GeneralState;
784   status.m_GraphState = m_pCurStates->m_GraphState;
785   status.m_ColorState = m_pCurStates->m_ColorState;
786   status.m_TextState = m_pCurStates->m_TextState;
787   pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
788   if (!m_pObjectList->m_bBackgroundAlphaNeeded &&
789       pFormObj->m_pForm->m_bBackgroundAlphaNeeded) {
790     m_pObjectList->m_bBackgroundAlphaNeeded = TRUE;
791   }
792   pFormObj->CalcBoundingBox();
793   SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
794   m_pObjectList->m_ObjectList.AddTail(pFormObj);
795 }
796 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream,
797                                                      CPDF_Image* pImage,
798                                                      FX_BOOL bInline) {
799   if (pStream == NULL && pImage == NULL) {
800     return NULL;
801   }
802   CFX_AffineMatrix ImageMatrix;
803   ImageMatrix.Copy(m_pCurStates->m_CTM);
804   ImageMatrix.Concat(m_mtContentToUser);
805   CPDF_ImageObject* pImageObj = new CPDF_ImageObject;
806   if (pImage) {
807     pImageObj->m_pImage =
808         m_pDocument->GetPageData()->GetImage(pImage->GetStream());
809   } else if (pStream->GetObjNum()) {
810     pImageObj->m_pImage = m_pDocument->LoadImageF(pStream);
811   } else {
812     pImageObj->m_pImage = new CPDF_Image(m_pDocument);
813     pImageObj->m_pImage->LoadImageF(pStream, bInline);
814   }
815   SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), FALSE, FALSE);
816   pImageObj->m_Matrix = ImageMatrix;
817   pImageObj->CalcBoundingBox();
818   m_pObjectList->m_ObjectList.AddTail(pImageObj);
819   return pImageObj;
820 }
821 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
822 void CPDF_StreamContentParser::Handle_EndImage() {}
823 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
824   if (!m_Options.m_bMarkedContent) {
825     return;
826   }
827   if (m_CurContentMark.IsNull()) {
828     return;
829   }
830   int count = m_CurContentMark.GetObject()->CountItems();
831   if (count == 1) {
832     m_CurContentMark.SetNull();
833     return;
834   }
835   m_CurContentMark.GetModify()->DeleteLastMark();
836 }
837 void CPDF_StreamContentParser::Handle_EndText() {
838   int count = m_ClipTextList.GetSize();
839   if (count == 0) {
840     return;
841   }
842   if (m_pCurStates->m_TextState.GetObject()->m_TextMode < 4) {
843     for (int i = 0; i < count; i++) {
844       CPDF_TextObject* pText = (CPDF_TextObject*)m_ClipTextList.GetAt(i);
845       delete pText;
846     }
847   } else {
848     m_pCurStates->m_ClipPath.AppendTexts(
849         (CPDF_TextObject**)m_ClipTextList.GetData(), count);
850   }
851   m_ClipTextList.RemoveAll();
852 }
853 void CPDF_StreamContentParser::Handle_EndSectionUndefined() {
854   if (m_CompatCount) {
855     m_CompatCount--;
856   }
857 }
858 void CPDF_StreamContentParser::Handle_FillPath() {
859   if (m_Options.m_bTextOnly) {
860     return;
861   }
862   AddPathObject(FXFILL_WINDING, FALSE);
863 }
864 void CPDF_StreamContentParser::Handle_FillPathOld() {
865   if (m_Options.m_bTextOnly) {
866     return;
867   }
868   AddPathObject(FXFILL_WINDING, FALSE);
869 }
870 void CPDF_StreamContentParser::Handle_EOFillPath() {
871   if (m_Options.m_bTextOnly) {
872     return;
873   }
874   AddPathObject(FXFILL_ALTERNATE, FALSE);
875 }
876 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
877   FX_FLOAT value = GetNumber(0);
878   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
879   m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
880 }
881 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
882   FX_FLOAT value = GetNumber(0);
883   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
884   m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
885 }
886 void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
887   CFX_ByteString name = GetString(0);
888   CPDF_Dictionary* pGS =
889       ToDictionary(FindResourceObj(FX_BSTRC("ExtGState"), name));
890   if (!pGS) {
891     m_bResourceMissing = TRUE;
892     return;
893   }
894   m_pCurStates->ProcessExtGS(pGS, this);
895 }
896 void CPDF_StreamContentParser::Handle_ClosePath() {
897   if (m_Options.m_bTextOnly) {
898     return;
899   }
900   if (m_PathPointCount == 0) {
901     return;
902   }
903   if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
904     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
905   } else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
906     m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
907   }
908 }
909 void CPDF_StreamContentParser::Handle_SetFlat() {
910   m_pCurStates->m_GeneralState.GetModify()->m_Flatness = GetNumber(0);
911 }
912 void CPDF_StreamContentParser::Handle_BeginImageData() {}
913 void CPDF_StreamContentParser::Handle_SetLineJoin() {
914   m_pCurStates->m_GraphState.GetModify()->m_LineJoin =
915       (CFX_GraphStateData::LineJoin)GetInteger(0);
916 }
917 void CPDF_StreamContentParser::Handle_SetLineCap() {
918   m_pCurStates->m_GraphState.GetModify()->m_LineCap =
919       (CFX_GraphStateData::LineCap)GetInteger(0);
920 }
921 void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
922   REQUIRE_PARAMS(4);
923   FX_FLOAT values[4];
924   for (int i = 0; i < 4; i++) {
925     values[i] = GetNumber(3 - i);
926   }
927   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
928   m_pCurStates->m_ColorState.SetFillColor(pCS, values, 4);
929 }
930 void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
931   REQUIRE_PARAMS(4);
932   FX_FLOAT values[4];
933   for (int i = 0; i < 4; i++) {
934     values[i] = GetNumber(3 - i);
935   }
936   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
937   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
938 }
939 void CPDF_StreamContentParser::Handle_LineTo() {
940   REQUIRE_PARAMS(2);
941   if (m_Options.m_bTextOnly) {
942     return;
943   }
944   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
945 }
946 void CPDF_StreamContentParser::Handle_MoveTo() {
947   REQUIRE_PARAMS(2);
948   if (m_Options.m_bTextOnly) {
949     m_pSyntax->SkipPathObject();
950     return;
951   }
952   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
953   ParsePathObject();
954 }
955 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
956   m_pCurStates->m_GraphState.GetModify()->m_MiterLimit = GetNumber(0);
957 }
958 void CPDF_StreamContentParser::Handle_MarkPlace() {}
959 void CPDF_StreamContentParser::Handle_EndPath() {
960   if (m_Options.m_bTextOnly) {
961     return;
962   }
963   AddPathObject(0, FALSE);
964 }
965 void CPDF_StreamContentParser::Handle_SaveGraphState() {
966   CPDF_AllStates* pStates = new CPDF_AllStates;
967   pStates->Copy(*m_pCurStates);
968   m_StateStack.Add(pStates);
969 }
970 void CPDF_StreamContentParser::Handle_RestoreGraphState() {
971   int size = m_StateStack.GetSize();
972   if (size == 0) {
973     return;
974   }
975   CPDF_AllStates* pStates = (CPDF_AllStates*)m_StateStack.GetAt(size - 1);
976   m_pCurStates->Copy(*pStates);
977   delete pStates;
978   m_StateStack.RemoveAt(size - 1);
979 }
980 void CPDF_StreamContentParser::Handle_Rectangle() {
981   if (m_Options.m_bTextOnly) {
982     return;
983   }
984   FX_FLOAT x = GetNumber(3), y = GetNumber(2);
985   FX_FLOAT w = GetNumber(1), h = GetNumber(0);
986   AddPathRect(x, y, w, h);
987 }
988 void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
989                                            FX_FLOAT y,
990                                            FX_FLOAT w,
991                                            FX_FLOAT h) {
992   AddPathPoint(x, y, FXPT_MOVETO);
993   AddPathPoint(x + w, y, FXPT_LINETO);
994   AddPathPoint(x + w, y + h, FXPT_LINETO);
995   AddPathPoint(x, y + h, FXPT_LINETO);
996   AddPathPoint(x, y, FXPT_LINETO | FXPT_CLOSEFIGURE);
997 }
998 void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
999   REQUIRE_PARAMS(3);
1000   FX_FLOAT values[3];
1001   for (int i = 0; i < 3; i++) {
1002     values[i] = GetNumber(2 - i);
1003   }
1004   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1005   m_pCurStates->m_ColorState.SetFillColor(pCS, values, 3);
1006 }
1007 void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
1008   REQUIRE_PARAMS(3);
1009   FX_FLOAT values[3];
1010   for (int i = 0; i < 3; i++) {
1011     values[i] = GetNumber(2 - i);
1012   }
1013   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1014   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
1015 }
1016 void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
1017 void CPDF_StreamContentParser::Handle_CloseStrokePath() {
1018   if (m_Options.m_bTextOnly) {
1019     return;
1020   }
1021   Handle_ClosePath();
1022   AddPathObject(0, TRUE);
1023 }
1024 void CPDF_StreamContentParser::Handle_StrokePath() {
1025   if (m_Options.m_bTextOnly) {
1026     return;
1027   }
1028   AddPathObject(0, TRUE);
1029 }
1030 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
1031   if (m_Options.m_bTextOnly) {
1032     return;
1033   }
1034   FX_FLOAT values[4];
1035   int nargs = m_ParamCount;
1036   if (nargs > 4) {
1037     nargs = 4;
1038   }
1039   for (int i = 0; i < nargs; i++) {
1040     values[i] = GetNumber(nargs - i - 1);
1041   }
1042   m_pCurStates->m_ColorState.SetFillColor(NULL, values, nargs);
1043 }
1044 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
1045   if (m_Options.m_bTextOnly) {
1046     return;
1047   }
1048   FX_FLOAT values[4];
1049   int nargs = m_ParamCount;
1050   if (nargs > 4) {
1051     nargs = 4;
1052   }
1053   for (int i = 0; i < nargs; i++) {
1054     values[i] = GetNumber(nargs - i - 1);
1055   }
1056   m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nargs);
1057 }
1058 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
1059   if (m_Options.m_bTextOnly) {
1060     return;
1061   }
1062   CPDF_Object* pLastParam = GetObject(0);
1063   if (pLastParam == NULL) {
1064     return;
1065   }
1066   int nargs = m_ParamCount;
1067   int nvalues = nargs;
1068   if (pLastParam->IsName()) {
1069     nvalues--;
1070   }
1071   FX_FLOAT* values = NULL;
1072   if (nvalues) {
1073     values = FX_Alloc(FX_FLOAT, nvalues);
1074     for (int i = 0; i < nvalues; i++) {
1075       values[i] = GetNumber(nargs - i - 1);
1076     }
1077   }
1078   if (nvalues != nargs) {
1079     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
1080     if (pPattern) {
1081       m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
1082     }
1083   } else {
1084     m_pCurStates->m_ColorState.SetFillColor(NULL, values, nvalues);
1085   }
1086   FX_Free(values);
1087 }
1088 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
1089   if (m_Options.m_bTextOnly) {
1090     return;
1091   }
1092   CPDF_Object* pLastParam = GetObject(0);
1093   if (pLastParam == NULL) {
1094     return;
1095   }
1096   int nargs = m_ParamCount;
1097   int nvalues = nargs;
1098   if (pLastParam->IsName())
1099     nvalues--;
1100
1101   FX_FLOAT* values = NULL;
1102   if (nvalues) {
1103     values = FX_Alloc(FX_FLOAT, nvalues);
1104     for (int i = 0; i < nvalues; i++) {
1105       values[i] = GetNumber(nargs - i - 1);
1106     }
1107   }
1108   if (nvalues != nargs) {
1109     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
1110     if (pPattern) {
1111       m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
1112     }
1113   } else {
1114     m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nvalues);
1115   }
1116   FX_Free(values);
1117 }
1118 CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream,
1119                               int type,
1120                               const CFX_AffineMatrix* pMatrix,
1121                               CPDF_Function** pFuncs,
1122                               int nFuncs,
1123                               CPDF_ColorSpace* pCS);
1124 void CPDF_StreamContentParser::Handle_ShadeFill() {
1125   if (m_Options.m_bTextOnly) {
1126     return;
1127   }
1128   CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
1129   if (pPattern == NULL) {
1130     return;
1131   }
1132   if (pPattern->m_PatternType != PATTERN_SHADING) {
1133     return;
1134   }
1135   CPDF_ShadingPattern* pShading = (CPDF_ShadingPattern*)pPattern;
1136   if (!pShading->m_bShadingObj) {
1137     return;
1138   }
1139   if (!pShading->Load()) {
1140     return;
1141   }
1142   CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
1143   pObj->m_pShading = pShading;
1144   SetGraphicStates(pObj, FALSE, FALSE, FALSE);
1145   pObj->m_Matrix = m_pCurStates->m_CTM;
1146   pObj->m_Matrix.Concat(m_mtContentToUser);
1147   CFX_FloatRect bbox;
1148   if (!pObj->m_ClipPath.IsNull()) {
1149     bbox = pObj->m_ClipPath.GetClipBox();
1150   } else {
1151     bbox = m_BBox;
1152   }
1153   if (pShading->m_ShadingType >= 4) {
1154     bbox.Intersect(_GetShadingBBox(ToStream(pShading->m_pShadingObj),
1155                                    pShading->m_ShadingType, &pObj->m_Matrix,
1156                                    pShading->m_pFunctions, pShading->m_nFuncs,
1157                                    pShading->m_pCS));
1158   }
1159   pObj->m_Left = bbox.left;
1160   pObj->m_Right = bbox.right;
1161   pObj->m_Top = bbox.top;
1162   pObj->m_Bottom = bbox.bottom;
1163   m_pObjectList->m_ObjectList.AddTail(pObj);
1164 }
1165 void CPDF_StreamContentParser::Handle_SetCharSpace() {
1166   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(0);
1167 }
1168 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
1169   m_pCurStates->m_TextLineX += GetNumber(1);
1170   m_pCurStates->m_TextLineY += GetNumber(0);
1171   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
1172   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
1173 }
1174 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
1175   Handle_MoveTextPoint();
1176   m_pCurStates->m_TextLeading = -GetNumber(0);
1177 }
1178 void CPDF_StreamContentParser::Handle_SetFont() {
1179   FX_FLOAT fs = GetNumber(0);
1180   if (fs == 0) {
1181     fs = m_DefFontSize;
1182   }
1183   m_pCurStates->m_TextState.GetModify()->m_FontSize = fs;
1184   CPDF_Font* pFont = FindFont(GetString(1));
1185   if (pFont) {
1186     m_pCurStates->m_TextState.SetFont(pFont);
1187   }
1188 }
1189 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
1190     const CFX_ByteStringC& type,
1191     const CFX_ByteString& name) {
1192   if (m_pResources == NULL) {
1193     return NULL;
1194   }
1195   if (m_pResources == m_pPageResources) {
1196     CPDF_Dictionary* pList = m_pResources->GetDict(type);
1197     if (pList == NULL) {
1198       return NULL;
1199     }
1200     CPDF_Object* pRes = pList->GetElementValue(name);
1201     return pRes;
1202   }
1203   CPDF_Dictionary* pList = m_pResources->GetDict(type);
1204   if (pList == NULL) {
1205     if (m_pPageResources == NULL) {
1206       return NULL;
1207     }
1208     CPDF_Dictionary* pList = m_pPageResources->GetDict(type);
1209     if (pList == NULL) {
1210       return NULL;
1211     }
1212     CPDF_Object* pRes = pList->GetElementValue(name);
1213     return pRes;
1214   }
1215   CPDF_Object* pRes = pList->GetElementValue(name);
1216   return pRes;
1217 }
1218 CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
1219   CPDF_Dictionary* pFontDict =
1220       ToDictionary(FindResourceObj(FX_BSTRC("Font"), name));
1221   if (!pFontDict) {
1222     m_bResourceMissing = TRUE;
1223     return CPDF_Font::GetStockFont(m_pDocument, FX_BSTRC("Helvetica"));
1224   }
1225
1226   CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
1227   if (pFont && pFont->GetType3Font()) {
1228     pFont->GetType3Font()->SetPageResources(m_pResources);
1229     pFont->GetType3Font()->CheckType3FontMetrics();
1230   }
1231   return pFont;
1232 }
1233 CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
1234     const CFX_ByteString& name) {
1235   if (name == FX_BSTRC("Pattern")) {
1236     return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
1237   }
1238   if (name == FX_BSTRC("DeviceGray") || name == FX_BSTRC("DeviceCMYK") ||
1239       name == FX_BSTRC("DeviceRGB")) {
1240     CFX_ByteString defname = "Default";
1241     defname += name.Mid(7);
1242     CPDF_Object* pDefObj = FindResourceObj(FX_BSTRC("ColorSpace"), defname);
1243     if (pDefObj == NULL) {
1244       if (name == FX_BSTRC("DeviceGray")) {
1245         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
1246       }
1247       if (name == FX_BSTRC("DeviceRGB")) {
1248         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1249       }
1250       return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
1251     }
1252     return m_pDocument->LoadColorSpace(pDefObj);
1253   }
1254   CPDF_Object* pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
1255   if (pCSObj == NULL) {
1256     m_bResourceMissing = TRUE;
1257     return NULL;
1258   }
1259   return m_pDocument->LoadColorSpace(pCSObj);
1260 }
1261 CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
1262                                                     FX_BOOL bShading) {
1263   CPDF_Object* pPattern = FindResourceObj(
1264       bShading ? FX_BSTRC("Shading") : FX_BSTRC("Pattern"), name);
1265   if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
1266     m_bResourceMissing = TRUE;
1267     return NULL;
1268   }
1269   return m_pDocument->LoadPattern(pPattern, bShading,
1270                                   &m_pCurStates->m_ParentMatrix);
1271 }
1272 void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
1273   m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
1274   ConvertUserSpace(x, y);
1275 }
1276 void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
1277   m_pCurStates->m_CTM.Transform(x, y, x, y);
1278   m_mtContentToUser.Transform(x, y, x, y);
1279 }
1280 void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
1281                                              FX_FLOAT fInitKerning,
1282                                              FX_FLOAT* pKerning,
1283                                              int nsegs) {
1284   CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
1285   if (pFont == NULL) {
1286     return;
1287   }
1288   if (fInitKerning != 0) {
1289     if (!pFont->IsVertWriting()) {
1290       m_pCurStates->m_TextX -=
1291           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1292           1000;
1293     } else {
1294       m_pCurStates->m_TextY -=
1295           FXSYS_Mul(fInitKerning, m_pCurStates->m_TextState.GetFontSize()) /
1296           1000;
1297     }
1298   }
1299   if (nsegs == 0) {
1300     return;
1301   }
1302   int textmode;
1303   if (pFont->GetFontType() == PDFFONT_TYPE3) {
1304     textmode = 0;
1305   } else {
1306     textmode = m_pCurStates->m_TextState.GetObject()->m_TextMode;
1307   }
1308   CPDF_TextObject* pText = new CPDF_TextObject;
1309   m_pLastTextObject = pText;
1310   SetGraphicStates(pText, TRUE, TRUE, TRUE);
1311   if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
1312     FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
1313     pCTM[0] = m_pCurStates->m_CTM.a;
1314     pCTM[1] = m_pCurStates->m_CTM.c;
1315     pCTM[2] = m_pCurStates->m_CTM.b;
1316     pCTM[3] = m_pCurStates->m_CTM.d;
1317   }
1318   pText->SetSegments(pStrs, pKerning, nsegs);
1319   pText->m_PosX = m_pCurStates->m_TextX;
1320   pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
1321   ConvertTextSpace(pText->m_PosX, pText->m_PosY);
1322   FX_FLOAT x_advance, y_advance;
1323   pText->CalcPositionData(&x_advance, &y_advance, m_pCurStates->m_TextHorzScale,
1324                           m_Level);
1325   m_pCurStates->m_TextX += x_advance;
1326   m_pCurStates->m_TextY += y_advance;
1327   if (textmode > 3) {
1328     CPDF_TextObject* pCopy = new CPDF_TextObject;
1329     pCopy->Copy(pText);
1330     m_ClipTextList.Add(pCopy);
1331   }
1332   m_pObjectList->m_ObjectList.AddTail(pText);
1333   if (pKerning && pKerning[nsegs - 1] != 0) {
1334     if (!pFont->IsVertWriting()) {
1335       m_pCurStates->m_TextX -=
1336           FXSYS_Mul(pKerning[nsegs - 1],
1337                     m_pCurStates->m_TextState.GetFontSize()) /
1338           1000;
1339     } else {
1340       m_pCurStates->m_TextY -=
1341           FXSYS_Mul(pKerning[nsegs - 1],
1342                     m_pCurStates->m_TextState.GetFontSize()) /
1343           1000;
1344     }
1345   }
1346 }
1347 void CPDF_StreamContentParser::Handle_ShowText() {
1348   CFX_ByteString str = GetString(0);
1349   if (str.IsEmpty()) {
1350     return;
1351   }
1352   AddTextObject(&str, 0, NULL, 1);
1353 }
1354 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
1355   CPDF_Array* pArray = GetObject(0) ? GetObject(0)->GetArray() : NULL;
1356   if (pArray == NULL) {
1357     return;
1358   }
1359   int n = pArray->GetCount();
1360   int nsegs = 0;
1361   for (int i = 0; i < n; i++) {
1362     if (pArray->GetElementValue(i)->IsString())
1363       nsegs++;
1364   }
1365   if (nsegs == 0) {
1366     for (int 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 (int i = 0; i < n; i++) {
1379     CPDF_Object* pObj = pArray->GetElementValue(i);
1380     if (pObj->IsString()) {
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 }