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