Make ContentStreamParser members private, fix constructor
[pdfium.git] / core / src / fpdfapi / fpdf_page / fpdf_page.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 "pageint.h"
10 CPDF_PageObject* CPDF_PageObject::Create(int type)
11 {
12     switch (type) {
13         case PDFPAGE_TEXT:
14             return new CPDF_TextObject;
15         case PDFPAGE_IMAGE:
16             return new CPDF_ImageObject;
17         case PDFPAGE_PATH:
18             return new CPDF_PathObject;
19         case PDFPAGE_SHADING:
20             return new CPDF_ShadingObject;
21         case PDFPAGE_FORM:
22             return new CPDF_FormObject;
23     }
24     return NULL;
25 }
26 CPDF_PageObject::~CPDF_PageObject()
27 {
28 }
29 CPDF_PageObject* CPDF_PageObject::Clone() const
30 {
31     CPDF_PageObject* pObj = Create(m_Type);
32     pObj->Copy(this);
33     return pObj;
34 }
35 void CPDF_PageObject::Copy(const CPDF_PageObject* pSrc)
36 {
37     if (m_Type != pSrc->m_Type) {
38         return;
39     }
40     CopyData(pSrc);
41     CopyStates(*pSrc);
42     m_Left = pSrc->m_Left;
43     m_Right = pSrc->m_Right;
44     m_Top = pSrc->m_Top;
45     m_Bottom = pSrc->m_Bottom;
46 }
47 void CPDF_PageObject::AppendClipPath(CPDF_Path path, int type, FX_BOOL bAutoMerge)
48 {
49     m_ClipPath.AppendPath(path, type, bAutoMerge);
50 }
51 void CPDF_PageObject::CopyClipPath(CPDF_PageObject* pObj)
52 {
53     m_ClipPath = pObj->m_ClipPath;
54 }
55 void CPDF_PageObject::RemoveClipPath()
56 {
57     m_ClipPath.SetNull();
58 }
59 void CPDF_PageObject::RecalcBBox()
60 {
61     switch (m_Type) {
62         case PDFPAGE_TEXT:
63             ((CPDF_TextObject*)this)->RecalcPositionData();
64             break;
65         case PDFPAGE_PATH:
66             ((CPDF_PathObject*)this)->CalcBoundingBox();
67             break;
68         case PDFPAGE_SHADING:
69             ((CPDF_ShadingObject*)this)->CalcBoundingBox();
70             break;
71     }
72 }
73 void CPDF_PageObject::TransformClipPath(CFX_AffineMatrix& matrix)
74 {
75     if (m_ClipPath.IsNull()) {
76         return;
77     }
78     m_ClipPath.GetModify();
79     m_ClipPath.Transform(matrix);
80 }
81 void CPDF_PageObject::TransformGeneralState(CFX_AffineMatrix& matrix)
82 {
83     if(m_GeneralState.IsNull()) {
84         return;
85     }
86     CPDF_GeneralStateData* pGS = m_GeneralState.GetModify();
87     pGS->m_Matrix.Concat(matrix);
88 }
89 FX_RECT CPDF_PageObject::GetBBox(const CFX_AffineMatrix* pMatrix) const
90 {
91     CFX_FloatRect rect(m_Left, m_Bottom, m_Right, m_Top);
92     if (pMatrix) {
93         pMatrix->TransformRect(rect);
94     }
95     return rect.GetOutterRect();
96 }
97
98 CPDF_TextObject::CPDF_TextObject()
99     : m_PosX(0),
100       m_PosY(0),
101       m_nChars(0),
102       m_pCharCodes(nullptr),
103       m_pCharPos(nullptr)
104 {
105     m_Type = PDFPAGE_TEXT;
106 }
107
108 CPDF_TextObject::~CPDF_TextObject()
109 {
110     if (m_nChars > 1 && m_pCharCodes) {
111         FX_Free(m_pCharCodes);
112     }
113     if (m_pCharPos) {
114         FX_Free(m_pCharPos);
115     }
116 }
117
118 void CPDF_TextObject::GetItemInfo(int index, CPDF_TextObjectItem* pInfo) const
119 {
120     pInfo->m_CharCode =
121         m_nChars == 1 ? (FX_DWORD)(uintptr_t)m_pCharCodes : m_pCharCodes[index];
122     pInfo->m_OriginX = index ? m_pCharPos[index - 1] : 0;
123     pInfo->m_OriginY = 0;
124     if (pInfo->m_CharCode == -1) {
125         return;
126     }
127     CPDF_Font* pFont = m_TextState.GetFont();
128     if (pFont->GetFontType() != PDFFONT_CIDFONT) {
129         return;
130     }
131     if (!((CPDF_CIDFont*)pFont)->IsVertWriting()) {
132         return;
133     }
134     FX_WORD CID = ((CPDF_CIDFont*)pFont)->CIDFromCharCode(pInfo->m_CharCode);
135     pInfo->m_OriginY = pInfo->m_OriginX;
136     pInfo->m_OriginX = 0;
137     short vx, vy;
138     ((CPDF_CIDFont*)pFont)->GetVertOrigin(CID, vx, vy);
139     FX_FLOAT fontsize = m_TextState.GetFontSize();
140     pInfo->m_OriginX -= fontsize * vx / 1000;
141     pInfo->m_OriginY -= fontsize * vy / 1000;
142 }
143
144 int CPDF_TextObject::CountChars() const
145 {
146     if (m_nChars == 1) {
147         return 1;
148     }
149     int count = 0;
150     for (int i = 0; i < m_nChars; ++i)
151         if (m_pCharCodes[i] != (FX_DWORD) - 1) {
152             ++count;
153         }
154     return count;
155 }
156
157 void CPDF_TextObject::GetCharInfo(int index,
158                                   FX_DWORD& charcode,
159                                   FX_FLOAT& kerning) const
160 {
161     if (m_nChars == 1) {
162         charcode = (FX_DWORD)(uintptr_t)m_pCharCodes;
163         kerning = 0;
164         return;
165     }
166     int count = 0;
167     for (int i = 0; i < m_nChars; ++i) {
168         if (m_pCharCodes[i] != (FX_DWORD) - 1) {
169             if (count == index) {
170                 charcode = m_pCharCodes[i];
171                 if (i == m_nChars - 1 ||
172                     m_pCharCodes[i + 1] != (FX_DWORD) - 1) {
173                     kerning = 0;
174                 } else {
175                     kerning = m_pCharPos[i];
176                 }
177                 return;
178             }
179             ++count;
180         }
181     }
182 }
183
184 void CPDF_TextObject::GetCharInfo(int index, CPDF_TextObjectItem* pInfo) const
185 {
186     if (m_nChars == 1) {
187         GetItemInfo(0, pInfo);
188         return;
189     }
190     int count = 0;
191     for (int i = 0; i < m_nChars; ++i) {
192         FX_DWORD charcode = m_pCharCodes[i];
193         if (charcode == (FX_DWORD) - 1) {
194             continue;
195         }
196         if (count == index) {
197             GetItemInfo(i, pInfo);
198             break;
199         }
200         ++count;
201     }
202 }
203
204 void CPDF_TextObject::CopyData(const CPDF_PageObject* pSrc)
205 {
206     const CPDF_TextObject* pSrcObj = (const CPDF_TextObject*)pSrc;
207     if (m_nChars > 1 && m_pCharCodes) {
208         FX_Free(m_pCharCodes);
209         m_pCharCodes = nullptr;
210     }
211     if (m_pCharPos) {
212         FX_Free(m_pCharPos);
213         m_pCharPos = nullptr;
214     }
215     m_nChars = pSrcObj->m_nChars;
216     if (m_nChars > 1) {
217         m_pCharCodes = FX_Alloc(FX_DWORD, m_nChars);
218         m_pCharPos = FX_Alloc(FX_FLOAT, m_nChars - 1);
219         for (int i = 0; i < m_nChars; ++i) {
220             m_pCharCodes[i] = pSrcObj->m_pCharCodes[i];
221         }
222         for (int i = 0; i < m_nChars - 1; ++i) {
223             m_pCharPos[i] = pSrcObj->m_pCharPos[i];
224         }
225     } else {
226         m_pCharCodes = pSrcObj->m_pCharCodes;
227     }
228     m_PosX = pSrcObj->m_PosX;
229     m_PosY = pSrcObj->m_PosY;
230 }
231
232 void CPDF_TextObject::GetTextMatrix(CFX_AffineMatrix* pMatrix) const
233 {
234     FX_FLOAT* pTextMatrix = m_TextState.GetMatrix();
235     pMatrix->Set(pTextMatrix[0],
236                  pTextMatrix[2],
237                  pTextMatrix[1],
238                  pTextMatrix[3],
239                  m_PosX,
240                  m_PosY);
241 }
242
243 void CPDF_TextObject::SetSegments(const CFX_ByteString* pStrs,
244                                   FX_FLOAT* pKerning,
245                                   int nsegs)
246 {
247     if (m_nChars > 1 && m_pCharCodes) {
248         FX_Free(m_pCharCodes);
249         m_pCharCodes = nullptr;
250     }
251     if (m_pCharPos) {
252         FX_Free(m_pCharPos);
253         m_pCharPos = nullptr;
254     }
255     CPDF_Font* pFont = m_TextState.GetFont();
256     m_nChars = 0;
257     for (int i = 0; i < nsegs; ++i) {
258         m_nChars += pFont->CountChar(pStrs[i], pStrs[i].GetLength());
259     }
260     m_nChars += nsegs - 1;
261     if (m_nChars > 1) {
262         m_pCharCodes = FX_Alloc(FX_DWORD, m_nChars);
263         m_pCharPos = FX_Alloc(FX_FLOAT, m_nChars - 1);
264         int index = 0;
265         for (int i = 0; i < nsegs; ++i) {
266             const FX_CHAR* segment = pStrs[i];
267             int offset = 0, len = pStrs[i].GetLength();
268             while (offset < len) {
269                 m_pCharCodes[index++] =
270                     pFont->GetNextChar(segment, len, offset);
271             }
272             if (i != nsegs - 1) {
273                 m_pCharPos[index - 1] = pKerning[i];
274                 m_pCharCodes[index++] = (FX_DWORD) - 1;
275             }
276         }
277     } else {
278         int offset = 0;
279         m_pCharCodes =
280             (FX_DWORD*)(uintptr_t)pFont->GetNextChar(pStrs[0],
281                                                      pStrs[0].GetLength(),
282                                                      offset);
283     }
284 }
285
286 void CPDF_TextObject::SetText(const CFX_ByteString& str)
287 {
288     SetSegments(&str, nullptr, 1);
289     RecalcPositionData();
290 }
291
292 void CPDF_TextObject::SetEmpty()
293 {
294     if (m_nChars > 1 && m_pCharCodes) {
295         FX_Free(m_pCharCodes);
296     }
297     if (m_nChars > 1 && m_pCharPos) {
298         FX_Free(m_pCharPos);
299     }
300     m_nChars = 0;
301     m_pCharCodes = nullptr;
302     m_pCharPos = nullptr;
303     m_Left = m_Right = m_PosX;
304     m_Top = m_Bottom = m_PosY;
305 }
306
307 void CPDF_TextObject::SetText(CFX_ByteString* pStrs,
308                               FX_FLOAT* pKerning,
309                               int nSegs)
310 {
311     SetSegments(pStrs, pKerning, nSegs);
312     RecalcPositionData();
313 }
314
315 void CPDF_TextObject::SetText(int nChars,
316                               FX_DWORD* pCharCodes,
317                               FX_FLOAT* pKernings)
318 {
319     if (m_nChars > 1 && m_pCharCodes) {
320         FX_Free(m_pCharCodes);
321         m_pCharCodes = nullptr;
322     }
323     if (m_pCharPos) {
324         FX_Free(m_pCharPos);
325         m_pCharPos = nullptr;
326     }
327     int nKernings = 0;
328     int i;
329     for (i = 0; i < nChars - 1; ++i) {
330         if (pKernings[i] != 0) {
331             ++nKernings;
332         }
333     }
334     m_nChars = nChars + nKernings;
335     if (m_nChars > 1) {
336         m_pCharCodes = FX_Alloc(FX_DWORD, m_nChars);
337         m_pCharPos = FX_Alloc(FX_FLOAT, m_nChars - 1);
338         for (int i = 0, index = 0; i < nChars; ++i) {
339             m_pCharCodes[index++] = pCharCodes[i];
340             if (pKernings[i] != 0 && i != nChars - 1) {
341                 m_pCharCodes[index] = (FX_DWORD) - 1;
342                 m_pCharPos[index - 1] = pKernings[i];
343                 ++index;
344             }
345         }
346     } else {
347         m_pCharCodes = (FX_DWORD*)(uintptr_t)pCharCodes[0];
348     }
349     RecalcPositionData();
350 }
351
352 FX_FLOAT CPDF_TextObject::GetCharWidth(FX_DWORD charcode) const
353 {
354     FX_FLOAT fontsize = m_TextState.GetFontSize() / 1000;
355     CPDF_Font* pFont = m_TextState.GetFont();
356     FX_BOOL bVertWriting = FALSE;
357     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
358     if (pCIDFont) {
359         bVertWriting = pCIDFont->IsVertWriting();
360     }
361     if (!bVertWriting)
362         return pFont->GetCharWidthF(charcode, 0) * fontsize;
363
364     FX_WORD CID = pCIDFont->CIDFromCharCode(charcode);
365     return pCIDFont->GetVertWidth(CID) * fontsize;
366 }
367
368 FX_FLOAT CPDF_TextObject::GetSpaceCharWidth() const
369 {
370     CPDF_Font* pFont = m_TextState.GetFont();
371     FX_DWORD charCode = m_TextState.GetFont()->CharCodeFromUnicode(32);
372     if (charCode != (FX_DWORD) - 1) {
373         return GetCharWidth(charCode);
374     }
375     FX_FLOAT fontSize = m_TextState.GetFontSize() / 4000.0f;
376     FX_BOOL bVertWriting = FALSE;
377     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
378     if (pCIDFont) {
379         bVertWriting = pCIDFont->IsVertWriting();
380     }
381     FX_RECT fontRect;
382     pFont->GetFontBBox(fontRect);
383     fontSize *= bVertWriting ?
384         (FX_FLOAT)fontRect.Height() : (FX_FLOAT)fontRect.Width();
385     return fontSize;
386 }
387
388 void CPDF_TextObject::GetCharRect(int index, CFX_FloatRect& rect) const
389 {
390     CPDF_Font* pFont = m_TextState.GetFont();
391     FX_BOOL bVertWriting = FALSE;
392     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
393     if (pCIDFont) {
394         bVertWriting = pCIDFont->IsVertWriting();
395     }
396     FX_FLOAT fontsize = m_TextState.GetFontSize() / 1000;
397     int count = 0;
398     for (int i = 0; i < m_nChars; ++i) {
399         FX_DWORD charcode = m_nChars == 1 ?
400             (FX_DWORD)(uintptr_t)m_pCharCodes : m_pCharCodes[i];
401         if (charcode == (FX_DWORD) - 1) {
402             continue;
403         }
404         if (count != index) {
405             ++count;
406             continue;
407         }
408         FX_FLOAT curpos = i > 0 ? m_pCharPos[i - 1] : 0;
409         FX_RECT char_rect;
410         pFont->GetCharBBox(charcode, char_rect, 0);
411         if (!bVertWriting) {
412             rect.left = curpos + char_rect.left * fontsize;
413             rect.right = curpos + char_rect.right * fontsize;
414             rect.top = char_rect.top * fontsize;
415             rect.bottom = char_rect.bottom * fontsize;
416         } else {
417             FX_WORD CID = pCIDFont->CIDFromCharCode(charcode);
418             short vx, vy;
419             pCIDFont->GetVertOrigin(CID, vx, vy);
420             char_rect.left -= vx;
421             char_rect.right -= vx;
422             char_rect.top -= vy;
423             char_rect.bottom -= vy;
424             rect.left = char_rect.left * fontsize;
425             rect.right = char_rect.right * fontsize;
426             rect.top = curpos + char_rect.top * fontsize;
427             rect.bottom = curpos + char_rect.bottom * fontsize;
428         }
429         return;
430     }
431 }
432
433 void CPDF_TextObject::CalcPositionData(FX_FLOAT* pTextAdvanceX,
434                                        FX_FLOAT* pTextAdvanceY,
435                                        FX_FLOAT horz_scale,
436                                        int level)
437 {
438     FX_FLOAT curpos = 0;
439     FX_FLOAT min_x = 10000 * 1.0f;
440     FX_FLOAT max_x = -10000 * 1.0f;
441     FX_FLOAT min_y = 10000 * 1.0f;
442     FX_FLOAT max_y = -10000 * 1.0f;
443     CPDF_Font* pFont = m_TextState.GetFont();
444     FX_BOOL bVertWriting = FALSE;
445     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
446     if (pCIDFont) {
447         bVertWriting = pCIDFont->IsVertWriting();
448     }
449     FX_FLOAT fontsize = m_TextState.GetFontSize();
450     for (int i = 0; i < m_nChars; ++i) {
451         FX_DWORD charcode = m_nChars == 1 ?
452             (FX_DWORD)(uintptr_t)m_pCharCodes : m_pCharCodes[i];
453         if (charcode == (FX_DWORD) - 1) {
454             curpos -= FXSYS_Mul(m_pCharPos[i - 1], fontsize) / 1000;
455             continue;
456         }
457         if (i) {
458             m_pCharPos[i - 1] = curpos;
459         }
460         FX_RECT char_rect;
461         pFont->GetCharBBox(charcode, char_rect, level);
462         FX_FLOAT charwidth;
463         if (!bVertWriting) {
464             if (min_y > char_rect.top) {
465                 min_y = (FX_FLOAT)char_rect.top;
466             }
467             if (max_y < char_rect.top) {
468                 max_y = (FX_FLOAT)char_rect.top;
469             }
470             if (min_y > char_rect.bottom) {
471                 min_y = (FX_FLOAT)char_rect.bottom;
472             }
473             if (max_y < char_rect.bottom) {
474                 max_y = (FX_FLOAT)char_rect.bottom;
475             }
476             FX_FLOAT char_left = curpos + char_rect.left * fontsize / 1000;
477             FX_FLOAT char_right = curpos + char_rect.right * fontsize / 1000;
478             if (min_x > char_left) {
479                 min_x = char_left;
480             }
481             if (max_x < char_left) {
482                 max_x = char_left;
483             }
484             if (min_x > char_right) {
485                 min_x = char_right;
486             }
487             if (max_x < char_right) {
488                 max_x = char_right;
489             }
490             charwidth = pFont->GetCharWidthF(charcode, level) * fontsize / 1000;
491         } else {
492             FX_WORD CID = pCIDFont->CIDFromCharCode(charcode);
493             short vx;
494             short vy;
495             pCIDFont->GetVertOrigin(CID, vx, vy);
496             char_rect.left -= vx;
497             char_rect.right -= vx;
498             char_rect.top -= vy;
499             char_rect.bottom -= vy;
500             if (min_x > char_rect.left) {
501                 min_x = (FX_FLOAT)char_rect.left;
502             }
503             if (max_x < char_rect.left) {
504                 max_x = (FX_FLOAT)char_rect.left;
505             }
506             if (min_x > char_rect.right) {
507                 min_x = (FX_FLOAT)char_rect.right;
508             }
509             if (max_x < char_rect.right) {
510                 max_x = (FX_FLOAT)char_rect.right;
511             }
512             FX_FLOAT char_top = curpos + char_rect.top * fontsize / 1000;
513             FX_FLOAT char_bottom = curpos + char_rect.bottom * fontsize / 1000;
514             if (min_y > char_top) {
515                 min_y = char_top;
516             }
517             if (max_y < char_top) {
518                 max_y = char_top;
519             }
520             if (min_y > char_bottom) {
521                 min_y = char_bottom;
522             }
523             if (max_y < char_bottom) {
524                 max_y = char_bottom;
525             }
526             charwidth = pCIDFont->GetVertWidth(CID) * fontsize / 1000;
527         }
528         curpos += charwidth;
529         if (charcode == ' ' && (!pCIDFont || pCIDFont->GetCharSize(32) == 1)) {
530             curpos += m_TextState.GetObject()->m_WordSpace;
531         }
532         curpos += m_TextState.GetObject()->m_CharSpace;
533     }
534     if (bVertWriting) {
535         if (pTextAdvanceX) {
536             *pTextAdvanceX = 0;
537         }
538         if (pTextAdvanceY) {
539             *pTextAdvanceY = curpos;
540         }
541         min_x = min_x * fontsize / 1000;
542         max_x = max_x * fontsize / 1000;
543     } else {
544         if (pTextAdvanceX) {
545             *pTextAdvanceX = FXSYS_Mul(curpos, horz_scale);
546         }
547         if (pTextAdvanceY) {
548             *pTextAdvanceY = 0;
549         }
550         min_y = min_y * fontsize / 1000;
551         max_y = max_y * fontsize / 1000;
552     }
553     CFX_AffineMatrix matrix;
554     GetTextMatrix(&matrix);
555     m_Left = min_x;
556     m_Right = max_x;
557     m_Bottom = min_y;
558     m_Top = max_y;
559     matrix.TransformRect(m_Left, m_Right, m_Top, m_Bottom);
560     int textmode = m_TextState.GetObject()->m_TextMode;
561     if (textmode == 1 || textmode == 2 || textmode == 5 || textmode == 6) {
562         FX_FLOAT half_width = m_GraphState.GetObject()->m_LineWidth / 2;
563         m_Left -= half_width;
564         m_Right += half_width;
565         m_Top += half_width;
566         m_Bottom -= half_width;
567     }
568 }
569
570 void CPDF_TextObject::CalcCharPos(FX_FLOAT* pPosArray) const
571 {
572     CPDF_Font* pFont = m_TextState.GetFont();
573     FX_BOOL bVertWriting = FALSE;
574     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
575     if (pCIDFont) {
576         bVertWriting = pCIDFont->IsVertWriting();
577     }
578     FX_FLOAT fontsize = m_TextState.GetFontSize();
579     for (int i = 0, index = 0; i < m_nChars; ++i) {
580         FX_DWORD charcode = m_nChars == 1 ?
581             (FX_DWORD)(uintptr_t)m_pCharCodes : m_pCharCodes[i];
582         if (charcode == (FX_DWORD) - 1) {
583             continue;
584         }
585         pPosArray[index++] = i ? m_pCharPos[i - 1] : 0;
586         FX_FLOAT charwidth;
587         if (bVertWriting) {
588             FX_WORD CID = pCIDFont->CIDFromCharCode(charcode);
589             charwidth = pCIDFont->GetVertWidth(CID) * fontsize / 1000;
590         } else {
591             charwidth = pFont->GetCharWidthF(charcode) * fontsize / 1000;
592         }
593         pPosArray[index] = pPosArray[index - 1] + charwidth;
594         index++;
595     }
596 }
597
598 void CPDF_TextObject::Transform(const CFX_AffineMatrix& matrix)
599 {
600     m_TextState.GetModify();
601     CFX_AffineMatrix text_matrix;
602     GetTextMatrix(&text_matrix);
603     text_matrix.Concat(matrix);
604     FX_FLOAT* pTextMatrix = m_TextState.GetMatrix();
605     pTextMatrix[0] = text_matrix.GetA();
606     pTextMatrix[1] = text_matrix.GetC();
607     pTextMatrix[2] = text_matrix.GetB();
608     pTextMatrix[3] = text_matrix.GetD();
609     m_PosX = text_matrix.GetE();
610     m_PosY = text_matrix.GetF();
611     CalcPositionData(nullptr, nullptr, 0);
612 }
613
614 void CPDF_TextObject::SetPosition(FX_FLOAT x, FX_FLOAT y)
615 {
616     FX_FLOAT dx = x - m_PosX;
617     FX_FLOAT dy = y - m_PosY;
618     m_PosX = x;
619     m_PosY = y;
620     m_Left += dx;
621     m_Right += dx;
622     m_Top += dy;
623     m_Bottom += dy;
624 }
625
626 void CPDF_TextObject::SetData(int nChars,
627                               FX_DWORD* pCharCodes,
628                               FX_FLOAT* pCharPos,
629                               FX_FLOAT x,
630                               FX_FLOAT y)
631 {
632     ASSERT(m_nChars == 0);
633     m_nChars = nChars;
634     m_PosX = x;
635     m_PosY = y;
636     if (nChars == 0) {
637         return;
638     }
639     if (nChars == 1) {
640         m_pCharCodes = (FX_DWORD*)(uintptr_t) * pCharCodes;
641     } else {
642         m_pCharCodes = FX_Alloc(FX_DWORD, nChars);
643         FXSYS_memcpy(m_pCharCodes, pCharCodes, sizeof(FX_DWORD)*nChars);
644         m_pCharPos = FX_Alloc(FX_FLOAT, nChars - 1);
645         FXSYS_memcpy(m_pCharPos, pCharPos, sizeof(FX_FLOAT) * (nChars - 1));
646     }
647     RecalcPositionData();
648 }
649
650 void CPDF_TextObject::SetTextState(CPDF_TextState TextState)
651 {
652     m_TextState = TextState;
653     CalcPositionData(nullptr, nullptr, 0);
654 }
655
656 CPDF_ShadingObject::CPDF_ShadingObject()
657 {
658     m_pShading = NULL;
659     m_Type = PDFPAGE_SHADING;
660 }
661 CPDF_ShadingObject::~CPDF_ShadingObject()
662 {
663 }
664 void CPDF_ShadingObject::CopyData(const CPDF_PageObject* pSrc)
665 {
666     CPDF_ShadingObject* pSrcObj = (CPDF_ShadingObject*)pSrc;
667     m_pShading = pSrcObj->m_pShading;
668     if (m_pShading && m_pShading->m_pDocument) {
669         CPDF_DocPageData* pDocPageData = m_pShading->m_pDocument->GetPageData();
670         m_pShading = (CPDF_ShadingPattern*)pDocPageData->GetPattern(m_pShading->m_pShadingObj, m_pShading->m_bShadingObj, &m_pShading->m_ParentMatrix);
671     }
672     m_Matrix = pSrcObj->m_Matrix;
673 }
674 void CPDF_ShadingObject::Transform(const CFX_AffineMatrix& matrix)
675 {
676     if (!m_ClipPath.IsNull()) {
677         m_ClipPath.GetModify();
678         m_ClipPath.Transform(matrix);
679     }
680     m_Matrix.Concat(matrix);
681     if (!m_ClipPath.IsNull()) {
682         CalcBoundingBox();
683     } else {
684         matrix.TransformRect(m_Left, m_Right, m_Top, m_Bottom);
685     }
686 }
687 void CPDF_ShadingObject::CalcBoundingBox()
688 {
689     if (m_ClipPath.IsNull()) {
690         return;
691     }
692     CFX_FloatRect rect = m_ClipPath.GetClipBox();
693     m_Left = rect.left;
694     m_Bottom = rect.bottom;
695     m_Right = rect.right;
696     m_Top = rect.top;
697 }
698 CPDF_FormObject::~CPDF_FormObject()
699 {
700     delete m_pForm;
701 }
702 void CPDF_FormObject::Transform(const CFX_AffineMatrix& matrix)
703 {
704     m_FormMatrix.Concat(matrix);
705     CalcBoundingBox();
706 }
707 void CPDF_FormObject::CopyData(const CPDF_PageObject* pSrc)
708 {
709     const CPDF_FormObject* pSrcObj = (const CPDF_FormObject*)pSrc;
710     delete m_pForm;
711     m_pForm = pSrcObj->m_pForm->Clone();
712     m_FormMatrix = pSrcObj->m_FormMatrix;
713 }
714 void CPDF_FormObject::CalcBoundingBox()
715 {
716     CFX_FloatRect form_rect = m_pForm->CalcBoundingBox();
717     form_rect.Transform(&m_FormMatrix);
718     m_Left = form_rect.left;
719     m_Bottom = form_rect.bottom;
720     m_Right = form_rect.right;
721     m_Top = form_rect.top;
722 }
723 CPDF_PageObjects::CPDF_PageObjects(FX_BOOL bReleaseMembers) : m_ObjectList(128)
724 {
725     m_bBackgroundAlphaNeeded = FALSE;
726     m_bReleaseMembers = bReleaseMembers;
727     m_ParseState = PDF_CONTENT_NOT_PARSED;
728     m_pParser = NULL;
729     m_pFormStream = NULL;
730     m_pResources = NULL;
731 }
732 CPDF_PageObjects::~CPDF_PageObjects()
733 {
734     delete m_pParser;
735     if (!m_bReleaseMembers) {
736         return;
737     }
738     FX_POSITION pos = m_ObjectList.GetHeadPosition();
739     while (pos) {
740         delete (CPDF_PageObject*)m_ObjectList.GetNext(pos);
741     }
742 }
743 void CPDF_PageObjects::ContinueParse(IFX_Pause* pPause)
744 {
745     if (m_pParser == NULL) {
746         return;
747     }
748     m_pParser->Continue(pPause);
749     if (m_pParser->GetStatus() == CPDF_ContentParser::Done) {
750         m_ParseState = PDF_CONTENT_PARSED;
751         delete m_pParser;
752         m_pParser = NULL;
753     }
754 }
755 int CPDF_PageObjects::EstimateParseProgress() const
756 {
757     if (m_pParser == NULL) {
758         return m_ParseState == PDF_CONTENT_PARSED ? 100 : 0;
759     }
760     return m_pParser->EstimateProgress();
761 }
762 FX_POSITION CPDF_PageObjects::InsertObject(FX_POSITION posInsertAfter, CPDF_PageObject* pNewObject)
763 {
764     if (posInsertAfter == NULL) {
765         return m_ObjectList.AddHead(pNewObject);
766     } else {
767         return m_ObjectList.InsertAfter(posInsertAfter, pNewObject);
768     }
769 }
770 int CPDF_PageObjects::GetObjectIndex(CPDF_PageObject* pObj) const
771 {
772     int index = 0;
773     FX_POSITION pos = m_ObjectList.GetHeadPosition();
774     while (pos) {
775         CPDF_PageObject* pThisObj = (CPDF_PageObject*)m_ObjectList.GetNext(pos);
776         if (pThisObj == pObj) {
777             return index;
778         }
779         index ++;
780     }
781     return -1;
782 }
783 CPDF_PageObject* CPDF_PageObjects::GetObjectByIndex(int index) const
784 {
785     FX_POSITION pos = m_ObjectList.FindIndex(index);
786     if (pos == NULL) {
787         return NULL;
788     }
789     return (CPDF_PageObject*)m_ObjectList.GetAt(pos);
790 }
791 void CPDF_PageObjects::Transform(const CFX_AffineMatrix& matrix)
792 {
793     FX_POSITION pos = m_ObjectList.GetHeadPosition();
794     while (pos) {
795         CPDF_PageObject* pObj = (CPDF_PageObject*)m_ObjectList.GetNext(pos);
796         pObj->Transform(matrix);
797     }
798 }
799 CFX_FloatRect CPDF_PageObjects::CalcBoundingBox() const
800 {
801     if (m_ObjectList.GetCount() == 0) {
802         return CFX_FloatRect(0, 0, 0, 0);
803     }
804     FX_FLOAT left, right, top, bottom;
805     left = bottom = 1000000 * 1.0f;
806     right = top = -1000000 * 1.0f;
807     FX_POSITION pos = m_ObjectList.GetHeadPosition();
808     while (pos) {
809         CPDF_PageObject* pObj = (CPDF_PageObject*)m_ObjectList.GetNext(pos);
810         if (left > pObj->m_Left) {
811             left = pObj->m_Left;
812         }
813         if (right < pObj->m_Right) {
814             right = pObj->m_Right;
815         }
816         if (top < pObj->m_Top) {
817             top = pObj->m_Top;
818         }
819         if (bottom > pObj->m_Bottom) {
820             bottom = pObj->m_Bottom;
821         }
822     }
823     return CFX_FloatRect(left, bottom, right, top);
824 }
825 void CPDF_PageObjects::LoadTransInfo()
826 {
827     if (m_pFormDict == NULL) {
828         return;
829     }
830     CPDF_Dictionary* pGroup = m_pFormDict->GetDict(FX_BSTRC("Group"));
831     if (pGroup == NULL) {
832         return;
833     }
834     if (pGroup->GetString(FX_BSTRC("S")) != FX_BSTRC("Transparency")) {
835         return;
836     }
837     m_Transparency |= PDFTRANS_GROUP;
838     if (pGroup->GetInteger(FX_BSTRC("I"))) {
839         m_Transparency |= PDFTRANS_ISOLATED;
840     }
841     if (pGroup->GetInteger(FX_BSTRC("K"))) {
842         m_Transparency |= PDFTRANS_KNOCKOUT;
843     }
844 }
845 void CPDF_PageObjects::ClearCacheObjects()
846 {
847     m_ParseState = PDF_CONTENT_NOT_PARSED;
848     delete m_pParser;
849     m_pParser = NULL;
850     if (m_bReleaseMembers) {
851         FX_POSITION pos = m_ObjectList.GetHeadPosition();
852         while (pos) {
853             delete (CPDF_PageObject*)m_ObjectList.GetNext(pos);
854         }
855     }
856     m_ObjectList.RemoveAll();
857 }
858 CPDF_Page::CPDF_Page()
859 {
860     m_pPageRender = NULL;
861 }
862 void CPDF_Page::Load(CPDF_Document* pDocument, CPDF_Dictionary* pPageDict, FX_BOOL bPageCache)
863 {
864     m_pDocument = (CPDF_Document*)pDocument;
865     m_pFormDict = pPageDict;
866     if (bPageCache) {
867         m_pPageRender = CPDF_ModuleMgr::Get()->GetRenderModule()->CreatePageCache(this);
868     }
869     if (pPageDict == NULL) {
870         m_PageWidth = m_PageHeight = 100 * 1.0f;
871         m_pPageResources = m_pResources = NULL;
872         return;
873     }
874     CPDF_Object* pageAttr = GetPageAttr(FX_BSTRC("Resources"));
875     m_pResources = pageAttr ? pageAttr->GetDict() : NULL;
876     m_pPageResources = m_pResources;
877     CPDF_Object* pRotate = GetPageAttr(FX_BSTRC("Rotate"));
878     int rotate = 0;
879     if (pRotate) {
880         rotate = pRotate->GetInteger() / 90 % 4;
881     }
882     if (rotate < 0) {
883         rotate += 4;
884     }
885     CPDF_Array* pMediaBox, *pCropBox;
886     pMediaBox = (CPDF_Array*)GetPageAttr(FX_BSTRC("MediaBox"));
887     CFX_FloatRect mediabox;
888     if (pMediaBox) {
889         mediabox = pMediaBox->GetRect();
890         mediabox.Normalize();
891     }
892     if (mediabox.IsEmpty()) {
893         mediabox = CFX_FloatRect(0, 0, 612, 792);
894     }
895     pCropBox = (CPDF_Array*)GetPageAttr(FX_BSTRC("CropBox"));
896     if (pCropBox) {
897         m_BBox = pCropBox->GetRect();
898         m_BBox.Normalize();
899     }
900     if (m_BBox.IsEmpty()) {
901         m_BBox = mediabox;
902     } else {
903         m_BBox.Intersect(mediabox);
904     }
905     if (rotate % 2) {
906         m_PageHeight = m_BBox.right - m_BBox.left;
907         m_PageWidth = m_BBox.top - m_BBox.bottom;
908     } else {
909         m_PageWidth = m_BBox.right - m_BBox.left;
910         m_PageHeight = m_BBox.top - m_BBox.bottom;
911     }
912     switch (rotate) {
913         case 0:
914             m_PageMatrix.Set(1.0f, 0, 0, 1.0f, -m_BBox.left, -m_BBox.bottom);
915             break;
916         case 1:
917             m_PageMatrix.Set(0, -1.0f, 1.0f, 0, -m_BBox.bottom, m_BBox.right);
918             break;
919         case 2:
920             m_PageMatrix.Set(-1.0f, 0, 0, -1.0f, m_BBox.right, m_BBox.top);
921             break;
922         case 3:
923             m_PageMatrix.Set(0, 1.0f, -1.0f, 0, m_BBox.top, -m_BBox.left);
924             break;
925     }
926     m_Transparency = PDFTRANS_ISOLATED;
927     LoadTransInfo();
928 }
929 void CPDF_Page::StartParse(CPDF_ParseOptions* pOptions, FX_BOOL bReParse)
930 {
931     if (bReParse) {
932         ClearCacheObjects();
933     }
934     if (m_ParseState == PDF_CONTENT_PARSED || m_ParseState == PDF_CONTENT_PARSING) {
935         return;
936     }
937     m_pParser = new CPDF_ContentParser;
938     m_pParser->Start(this, pOptions);
939     m_ParseState = PDF_CONTENT_PARSING;
940 }
941 void CPDF_Page::ParseContent(CPDF_ParseOptions* pOptions, FX_BOOL bReParse)
942 {
943     StartParse(pOptions, bReParse);
944     ContinueParse(NULL);
945 }
946 CPDF_Page::~CPDF_Page()
947 {
948     if (m_pPageRender) {
949         IPDF_RenderModule* pModule = CPDF_ModuleMgr::Get()->GetRenderModule();
950         pModule->DestroyPageCache(m_pPageRender);
951     }
952 }
953 CPDF_Object* FPDFAPI_GetPageAttr(CPDF_Dictionary* pPageDict, const CFX_ByteStringC& name)
954 {
955     int level = 0;
956     while (1) {
957         CPDF_Object* pObj = pPageDict->GetElementValue(name);
958         if (pObj) {
959             return pObj;
960         }
961         CPDF_Dictionary* pParent = pPageDict->GetDict(FX_BSTRC("Parent"));
962         if (!pParent || pParent == pPageDict) {
963             return NULL;
964         }
965         pPageDict = pParent;
966         level ++;
967         if (level == 1000) {
968             return NULL;
969         }
970     }
971 }
972 CPDF_Object* CPDF_Page::GetPageAttr(const CFX_ByteStringC& name) const
973 {
974     return FPDFAPI_GetPageAttr(m_pFormDict, name);
975 }
976 CPDF_Form::CPDF_Form(CPDF_Document* pDoc, CPDF_Dictionary* pPageResources, CPDF_Stream* pFormStream, CPDF_Dictionary* pParentResources)
977 {
978     m_pDocument = pDoc;
979     m_pFormStream = pFormStream;
980     m_pFormDict = pFormStream ? pFormStream->GetDict() : NULL;
981     m_pResources = m_pFormDict->GetDict(FX_BSTRC("Resources"));
982     m_pPageResources = pPageResources;
983     if (m_pResources == NULL) {
984         m_pResources = pParentResources;
985     }
986     if (m_pResources == NULL) {
987         m_pResources = pPageResources;
988     }
989     m_Transparency = 0;
990     LoadTransInfo();
991 }
992 CPDF_Form::~CPDF_Form()
993 {
994 }
995 void CPDF_Form::StartParse(CPDF_AllStates* pGraphicStates, CFX_AffineMatrix* pParentMatrix,
996                            CPDF_Type3Char* pType3Char, CPDF_ParseOptions* pOptions, int level)
997 {
998     if (m_ParseState == PDF_CONTENT_PARSED || m_ParseState == PDF_CONTENT_PARSING) {
999         return;
1000     }
1001     m_pParser = new CPDF_ContentParser;
1002     m_pParser->Start(this, pGraphicStates, pParentMatrix, pType3Char, pOptions, level);
1003     m_ParseState = PDF_CONTENT_PARSING;
1004 }
1005 void CPDF_Form::ParseContent(CPDF_AllStates* pGraphicStates, CFX_AffineMatrix* pParentMatrix,
1006                              CPDF_Type3Char* pType3Char, CPDF_ParseOptions* pOptions, int level)
1007 {
1008     StartParse(pGraphicStates, pParentMatrix, pType3Char, pOptions, level);
1009     ContinueParse(NULL);
1010 }
1011 CPDF_Form* CPDF_Form::Clone() const
1012 {
1013     CPDF_Form* pClone = new CPDF_Form(m_pDocument, m_pPageResources, m_pFormStream, m_pResources);
1014     FX_POSITION pos = m_ObjectList.GetHeadPosition();
1015     while (pos) {
1016         CPDF_PageObject* pObj = (CPDF_PageObject*)m_ObjectList.GetNext(pos);
1017         pClone->m_ObjectList.AddTail(pObj->Clone());
1018     }
1019     return pClone;
1020 }
1021 void CPDF_Page::GetDisplayMatrix(CFX_AffineMatrix& matrix, int xPos, int yPos,
1022                                  int xSize, int ySize, int iRotate) const
1023 {
1024     if (m_PageWidth == 0 || m_PageHeight == 0) {
1025         return;
1026     }
1027     CFX_AffineMatrix display_matrix;
1028     int x0, y0, x1, y1, x2, y2;
1029     iRotate %= 4;
1030     switch (iRotate) {
1031         case 0:
1032             x0 = xPos;
1033             y0 = yPos + ySize;
1034             x1 = xPos;
1035             y1 = yPos;
1036             x2 = xPos + xSize;
1037             y2 = yPos + ySize;
1038             break;
1039         case 1:
1040             x0 = xPos;
1041             y0 = yPos;
1042             x1 = xPos + xSize;
1043             y1 = yPos;
1044             x2 = xPos;
1045             y2 = yPos + ySize;
1046             break;
1047         case 2:
1048             x0 = xPos + xSize;
1049             y0 = yPos;
1050             x1 = xPos + xSize;
1051             y1 = yPos + ySize;
1052             x2 = xPos;
1053             y2 = yPos;
1054             break;
1055         case 3:
1056             x0 = xPos + xSize;
1057             y0 = yPos + ySize;
1058             x1 = xPos;
1059             y1 = yPos + ySize;
1060             x2 = xPos + xSize;
1061             y2 = yPos;
1062             break;
1063     }
1064     display_matrix.Set(FXSYS_Div((FX_FLOAT)(x2 - x0), m_PageWidth),
1065                        FXSYS_Div((FX_FLOAT)(y2 - y0), m_PageWidth),
1066                        FXSYS_Div((FX_FLOAT)(x1 - x0), m_PageHeight),
1067                        FXSYS_Div((FX_FLOAT)(y1 - y0), m_PageHeight),
1068                        (FX_FLOAT)x0, (FX_FLOAT)y0);
1069     matrix = m_PageMatrix;
1070     matrix.Concat(display_matrix);
1071 }
1072 CPDF_ParseOptions::CPDF_ParseOptions()
1073 {
1074     m_bTextOnly = FALSE;
1075     m_bMarkedContent = TRUE;
1076     m_bSeparateForm = TRUE;
1077     m_bDecodeInlineImage = FALSE;
1078 }