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 }