core/include/fpdfapi/fpdf_resource.h

   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 #ifndef CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
   8 #define CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
   9
  10 #include "../fxge/fx_font.h"
  11 #include "fpdf_parser.h"
  12
  13 class CFX_CTTGSUBTable;
  14 class CFX_DIBitmap;
  15 class CFX_Font;
  16 class CFX_SubstFont;
  17 class CPDF_CID2UnicodeMap;
  18 class CPDF_CIDFont;
  19 class CPDF_CMap;
  20 class CPDF_Color;
  21 class CPDF_ColorSpace;
  22 class CPDF_Face;
  23 class CPDF_Font;
  24 class CPDF_FontEncoding;
  25 class CPDF_Form;
  26 class CPDF_Function;
  27 class CPDF_Image;
  28 class CPDF_ImageObject;
  29 class CPDF_Page;
  30 class CPDF_Pattern;
  31 class CPDF_RenderContext;
  32 class CPDF_ShadingPattern;
  33 class CPDF_TilingPattern;
  34 class CPDF_ToUnicodeMap;
  35 class CPDF_TrueTypeFont;
  36 class CPDF_Type1Font;
  37 class CPDF_Type3Font;
  38 typedef struct FT_FaceRec_* FXFT_Face;
  39
  40 template <class ObjClass> class CPDF_CountedObject
  41 {
  42 public:
  43     ObjClass    m_Obj;
  44     FX_DWORD    m_nCount;
  45 };
  46 typedef CPDF_CountedObject<CPDF_StreamAcc*>     CPDF_CountedStreamAcc;
  47 using CPDF_CountedColorSpace = CPDF_CountedObject<CPDF_ColorSpace*>;
  48 using CPDF_CountedPattern = CPDF_CountedObject<CPDF_Pattern*>;
  49
  50 typedef CFX_MapPtrTemplate<CPDF_Stream*, CPDF_CountedStreamAcc*>    CPDF_FontFileMap;
  51
  52 #define PDFFONT_TYPE1                   1
  53 #define PDFFONT_TRUETYPE                2
  54 #define PDFFONT_TYPE3                   3
  55 #define PDFFONT_CIDFONT                 4
  56 #define PDFFONT_FIXEDPITCH              1
  57 #define PDFFONT_SERIF                   2
  58 #define PDFFONT_SYMBOLIC                4
  59 #define PDFFONT_SCRIPT                  8
  60 #define PDFFONT_NONSYMBOLIC             32
  61 #define PDFFONT_ITALIC                  64
  62 #define PDFFONT_ALLCAP                  0x10000
  63 #define PDFFONT_SMALLCAP                0x20000
  64 #define PDFFONT_FORCEBOLD               0x40000
  65 #define PDFFONT_USEEXTERNATTR   0x80000
  66 FX_WCHAR PDF_UnicodeFromAdobeName(const FX_CHAR* name);
  67 CFX_ByteString PDF_AdobeNameFromUnicode(FX_WCHAR unicode);
  68 class CPDF_Font
  69 {
  70 public:
  71     static CPDF_Font*           CreateFontF(CPDF_Document* pDoc, CPDF_Dictionary* pFontDict);
  72     static CPDF_Font*           GetStockFont(CPDF_Document* pDoc, const CFX_ByteStringC& fontname);
  73
  74     virtual ~CPDF_Font();
  75
  76     bool IsFontType(int fonttype) const { return fonttype == m_FontType; }
  77     int GetFontType() const { return m_FontType;  }
  78
  79     CFX_ByteString                      GetFontTypeName() const;
  80
  81     const CFX_ByteString&       GetBaseFont() const
  82     {
  83         return m_BaseFont;
  84     }
  85
  86     const CFX_SubstFont*        GetSubstFont() const
  87     {
  88         return m_Font.GetSubstFont();
  89     }
  90
  91     FX_DWORD                            GetFlags() const
  92     {
  93         return m_Flags;
  94     }
  95
  96     virtual FX_BOOL                     IsVertWriting()const;
  97
  98
  99
 100
 101     CPDF_Type1Font*                     GetType1Font() const
 102     {
 103         return m_FontType == PDFFONT_TYPE1 ? (CPDF_Type1Font*)(void*)this : NULL;
 104     }
 105
 106     CPDF_TrueTypeFont*          GetTrueTypeFont() const
 107     {
 108         return m_FontType == PDFFONT_TRUETYPE ? (CPDF_TrueTypeFont*)(void*)this : NULL;
 109     }
 110
 111     CPDF_CIDFont*                       GetCIDFont() const
 112     {
 113         return (m_FontType == PDFFONT_CIDFONT) ? (CPDF_CIDFont*)(void*)this : NULL;
 114     }
 115
 116     CPDF_Type3Font*                     GetType3Font() const
 117     {
 118         return (m_FontType == PDFFONT_TYPE3) ? (CPDF_Type3Font*)(void*)this : NULL;
 119     }
 120
 121
 122     FX_BOOL                                     IsEmbedded() const
 123     {
 124         return m_FontType == PDFFONT_TYPE3 || m_pFontFile != NULL;
 125     }
 126
 127     virtual FX_BOOL                     IsUnicodeCompatible() const
 128     {
 129         return FALSE;
 130     }
 131
 132     CPDF_StreamAcc*                     GetFontFile() const
 133     {
 134         return m_pFontFile;
 135     }
 136
 137     CPDF_Dictionary*            GetFontDict() const
 138     {
 139         return m_pFontDict;
 140     }
 141
 142     FX_BOOL                                     IsStandardFont() const;
 143
 144     FXFT_Face                           GetFace() const
 145     {
 146         return m_Font.GetFace();
 147     }
 148
 149     virtual FX_DWORD            GetNextChar(const FX_CHAR* pString, int nStrLen, int& offset) const
 150     {
 151         if (offset < 0 || nStrLen < 1) {
 152             return 0;
 153         }
 154         uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen-1];
 155         return static_cast<FX_DWORD>(ch);
 156     }
 157
 158     virtual int                         CountChar(const FX_CHAR* pString, int size) const
 159     {
 160         return size;
 161     }
 162
 163     void                                        AppendChar(CFX_ByteString& str, FX_DWORD charcode) const;
 164
 165     virtual int                         AppendChar(FX_CHAR* buf, FX_DWORD charcode) const
 166     {
 167         *buf = (FX_CHAR)charcode;
 168         return 1;
 169     }
 170
 171     virtual int                         GetCharSize(FX_DWORD charcode) const
 172     {
 173         return 1;
 174     }
 175
 176
 177
 178
 179     virtual int                         GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph = NULL) = 0;
 180     virtual int                         GlyphFromCharCodeExt(FX_DWORD charcode)
 181     {
 182         return GlyphFromCharCode(charcode);
 183     }
 184
 185     CFX_WideString                      UnicodeFromCharCode(FX_DWORD charcode) const;
 186
 187     FX_DWORD                            CharCodeFromUnicode(FX_WCHAR Unicode) const;
 188
 189     CFX_CharMap*                        GetCharMap()
 190     {
 191         return m_pCharMap;
 192     }
 193
 194     CFX_ByteString                      EncodeString(const CFX_WideString& str) const;
 195
 196     CFX_WideString                      DecodeString(const CFX_ByteString& str) const;
 197
 198
 199
 200
 201     void                                        GetFontBBox(FX_RECT& rect) const
 202     {
 203         rect = m_FontBBox;
 204     }
 205
 206     int                                         GetTypeAscent() const
 207     {
 208         return m_Ascent;
 209     }
 210
 211     int                                         GetTypeDescent() const
 212     {
 213         return m_Descent;
 214     }
 215
 216     int                                         GetItalicAngle() const
 217     {
 218         return m_ItalicAngle;
 219     }
 220
 221     int                                         GetStemV() const
 222     {
 223         return m_StemV;
 224     }
 225
 226     int                                         GetStringWidth(const FX_CHAR* pString, int size);
 227
 228     virtual int                         GetCharWidthF(FX_DWORD charcode, int level = 0) = 0;
 229
 230     virtual int                         GetCharTypeWidth(FX_DWORD charcode);
 231
 232     virtual void                        GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) = 0;
 233
 234
 235
 236     CPDF_Document*                      m_pDocument;
 237
 238     class CFX_PathData*         LoadGlyphPath(FX_DWORD charcode, int dest_width = 0);
 239
 240     CFX_Font                            m_Font;
 241
 242 protected:
 243     explicit CPDF_Font(int fonttype);
 244
 245     FX_BOOL                                     Initialize();
 246
 247     FX_BOOL                                     Load();
 248
 249     virtual FX_BOOL                     _Load() = 0;
 250
 251     virtual FX_WCHAR            _UnicodeFromCharCode(FX_DWORD charcode) const = 0;
 252
 253     virtual FX_DWORD            _CharCodeFromUnicode(FX_WCHAR Unicode) const = 0;
 254
 255     void                                        LoadUnicodeMap();
 256
 257     void                                        LoadPDFEncoding(CPDF_Object* pEncoding, int& iBaseEncoding,
 258                                             CFX_ByteString*& pCharNames, FX_BOOL bEmbedded, FX_BOOL bTrueType);
 259
 260     void                                        LoadFontDescriptor(CPDF_Dictionary*);
 261
 262     void                                        LoadCharWidths(FX_WORD* pWidths);
 263
 264     void                                        CheckFontMetrics();
 265
 266     CFX_CharMap*                        m_pCharMap;
 267
 268
 269
 270     CFX_ByteString                      m_BaseFont;
 271
 272     CPDF_StreamAcc*                     m_pFontFile;
 273
 274     CPDF_Dictionary*            m_pFontDict;
 275
 276     CPDF_ToUnicodeMap*          m_pToUnicodeMap;
 277
 278     FX_BOOL                                     m_bToUnicodeLoaded;
 279
 280
 281
 282
 283     int                                         m_Flags;
 284
 285     FX_RECT                                     m_FontBBox;
 286
 287     int                                         m_StemV;
 288
 289     int                                         m_Ascent;
 290
 291     int                                         m_Descent;
 292
 293     int                                         m_ItalicAngle;
 294
 295 private:
 296     const int                           m_FontType;
 297 };
 298 #define PDFFONT_ENCODING_BUILTIN                0
 299 #define PDFFONT_ENCODING_WINANSI                1
 300 #define PDFFONT_ENCODING_MACROMAN               2
 301 #define PDFFONT_ENCODING_MACEXPERT              3
 302 #define PDFFONT_ENCODING_STANDARD               4
 303 #define PDFFONT_ENCODING_ADOBE_SYMBOL   5
 304 #define PDFFONT_ENCODING_ZAPFDINGBATS   6
 305 #define PDFFONT_ENCODING_PDFDOC                 7
 306 #define PDFFONT_ENCODING_MS_SYMBOL              8
 307 #define PDFFONT_ENCODING_UNICODE                9
 308 class CPDF_FontEncoding
 309 {
 310 public:
 311
 312     CPDF_FontEncoding();
 313
 314     CPDF_FontEncoding(int PredefinedEncoding);
 315
 316     void                                        LoadEncoding(CPDF_Object* pEncoding);
 317
 318     FX_BOOL                                     IsIdentical(CPDF_FontEncoding* pAnother) const;
 319
 320     FX_WCHAR                            UnicodeFromCharCode(uint8_t charcode) const
 321     {
 322         return m_Unicodes[charcode];
 323     }
 324
 325     int                                         CharCodeFromUnicode(FX_WCHAR unicode) const;
 326
 327     void                                        SetUnicode(uint8_t charcode, FX_WCHAR unicode)
 328     {
 329         m_Unicodes[charcode] = unicode;
 330     }
 331
 332     CPDF_Object*                        Realize();
 333 public:
 334
 335     FX_WCHAR                            m_Unicodes[256];
 336 };
 337 class CPDF_SimpleFont : public CPDF_Font
 338 {
 339 public:
 340     explicit CPDF_SimpleFont(int fonttype);
 341     ~CPDF_SimpleFont() override;
 342
 343     CPDF_FontEncoding*          GetEncoding()
 344     {
 345         return &m_Encoding;
 346     }
 347     virtual int                         GetCharWidthF(FX_DWORD charcode, int level = 0);
 348     virtual void                        GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0);
 349     virtual int                         GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph = NULL);
 350     virtual FX_BOOL                     IsUnicodeCompatible() const;
 351 protected:
 352
 353     FX_BOOL                                     LoadCommon();
 354
 355     void                                        LoadSubstFont();
 356
 357     void                                        LoadFaceMetrics();
 358
 359     virtual void                        LoadGlyphMap() = 0;
 360     virtual FX_WCHAR            _UnicodeFromCharCode(FX_DWORD charcode) const
 361     {
 362         return m_Encoding.UnicodeFromCharCode((uint8_t)charcode);
 363     }
 364     virtual FX_DWORD            _CharCodeFromUnicode(FX_WCHAR Unicode) const
 365     {
 366         return m_Encoding.CharCodeFromUnicode(Unicode);
 367     }
 368
 369
 370
 371     CPDF_FontEncoding           m_Encoding;
 372
 373     FX_WORD                                     m_GlyphIndex[256];
 374     FX_WORD                                     m_ExtGID[256];
 375
 376
 377
 378
 379     CFX_ByteString*                     m_pCharNames;
 380
 381     int                                         m_BaseEncoding;
 382
 383
 384
 385
 386     FX_WORD                                     m_CharWidth[256];
 387
 388     FX_SMALL_RECT                       m_CharBBox[256];
 389
 390     FX_BOOL                                     m_bUseFontWidth;
 391
 392     void                                        LoadCharMetrics(int charcode);
 393
 394 };
 395 class CPDF_Type1Font : public CPDF_SimpleFont
 396 {
 397 public:
 398
 399     CPDF_Type1Font();
 400
 401     int                                         GetBase14Font()
 402     {
 403         return m_Base14Font;
 404     }
 405     virtual int                         GlyphFromCharCodeExt(FX_DWORD charcode);
 406 protected:
 407     virtual FX_BOOL                     _Load();
 408
 409     int                                         m_Base14Font;
 410     virtual void                        LoadGlyphMap();
 411 };
 412 class CPDF_TrueTypeFont : public CPDF_SimpleFont
 413 {
 414 public:
 415
 416     CPDF_TrueTypeFont();
 417 protected:
 418     virtual FX_BOOL                     _Load();
 419     virtual void                        LoadGlyphMap();
 420 };
 421 class CPDF_Type3Char
 422 {
 423 public:
 424
 425     CPDF_Type3Char();
 426
 427     ~CPDF_Type3Char();
 428
 429     FX_BOOL LoadBitmap(CPDF_RenderContext* pContext);
 430
 431     FX_BOOL                                     m_bColored;
 432
 433     FX_BOOL                                     m_bPageRequired;
 434
 435
 436
 437     CPDF_Form*                          m_pForm;
 438
 439     CFX_AffineMatrix            m_ImageMatrix;
 440
 441     CFX_DIBitmap*                       m_pBitmap;
 442
 443
 444     int                                         m_Width;
 445
 446     FX_RECT                                     m_BBox;
 447 };
 448 class CPDF_Type3Font : public CPDF_SimpleFont
 449 {
 450 public:
 451     CPDF_Type3Font();
 452     ~CPDF_Type3Font() override;
 453     void                                        SetPageResources(CPDF_Dictionary* pResources)
 454     {
 455         m_pPageResources = pResources;
 456     }
 457     CPDF_Type3Char*                     LoadChar(FX_DWORD charcode, int level = 0);
 458     virtual int                         GetCharWidthF(FX_DWORD charcode, int level = 0);
 459     virtual int                         GetCharTypeWidth(FX_DWORD charcode)
 460     {
 461         return GetCharWidthF(charcode);
 462     }
 463     virtual void                        GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0);
 464     CFX_AffineMatrix&           GetFontMatrix()
 465     {
 466         return m_FontMatrix;
 467     }
 468     void                                        CheckType3FontMetrics();
 469 private:
 470     virtual FX_BOOL                     _Load();
 471     virtual void                        LoadGlyphMap() {}
 472     int                                         m_CharWidthL[256];
 473     CPDF_Dictionary*            m_pCharProcs;
 474     CPDF_Dictionary*            m_pPageResources;
 475     CPDF_Dictionary*            m_pFontResources;
 476     CFX_MapPtrToPtr                     m_CacheMap;
 477     CFX_MapPtrToPtr                     m_DeletedMap;
 478 protected:
 479     CFX_AffineMatrix            m_FontMatrix;
 480 };
 481 #define CIDSET_UNKNOWN          0
 482 #define CIDSET_GB1                      1
 483 #define CIDSET_CNS1                     2
 484 #define CIDSET_JAPAN1           3
 485 #define CIDSET_KOREA1           4
 486 #define CIDSET_UNICODE          5
 487 #define NUMBER_OF_CIDSETS   6
 488
 489 class CPDF_CIDFont : public CPDF_Font
 490 {
 491 public:
 492
 493     CPDF_CIDFont();
 494
 495     virtual ~CPDF_CIDFont();
 496
 497     FX_BOOL                 LoadGB2312();
 498     virtual int             GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph = NULL);
 499     virtual int             GetCharWidthF(FX_DWORD charcode, int level = 0);
 500     virtual void            GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0);
 501     FX_WORD                 CIDFromCharCode(FX_DWORD charcode) const;
 502
 503     FX_BOOL                 IsTrueType()
 504     {
 505         return !m_bType1;
 506     }
 507
 508     virtual FX_DWORD        GetNextChar(const FX_CHAR* pString, int nStrLen, int& offset) const override;
 509     virtual int             CountChar(const FX_CHAR* pString, int size) const;
 510     virtual int             AppendChar(FX_CHAR* str, FX_DWORD charcode) const;
 511     virtual int             GetCharSize(FX_DWORD charcode) const;
 512
 513     int                     GetCharset() const
 514     {
 515         return m_Charset;
 516     }
 517
 518     const uint8_t*              GetCIDTransform(FX_WORD CID) const;
 519     virtual FX_BOOL         IsVertWriting() const;
 520     short                   GetVertWidth(FX_WORD CID) const;
 521     void                    GetVertOrigin(FX_WORD CID, short& vx, short& vy) const;
 522     virtual FX_BOOL         IsUnicodeCompatible() const;
 523     virtual FX_BOOL         IsFontStyleFromCharCode(FX_DWORD charcode) const;
 524
 525 protected:
 526     friend class            CPDF_Font;
 527     virtual FX_BOOL         _Load();
 528     virtual FX_WCHAR        _UnicodeFromCharCode(FX_DWORD charcode) const;
 529     virtual FX_DWORD        _CharCodeFromUnicode(FX_WCHAR Unicode) const;
 530     int                     GetGlyphIndex(FX_DWORD unicodeb, FX_BOOL *pVertGlyph);
 531
 532     CPDF_CMap*              m_pCMap;
 533     CPDF_CMap*              m_pAllocatedCMap;
 534     CPDF_CID2UnicodeMap*    m_pCID2UnicodeMap;
 535     int                     m_Charset;
 536     FX_BOOL                 m_bType1;
 537     CPDF_StreamAcc*         m_pCIDToGIDMap;
 538     FX_BOOL                 m_bCIDIsGID;
 539     FX_WORD                 m_DefaultWidth;
 540     FX_WORD*                m_pAnsiWidths;
 541     FX_SMALL_RECT           m_CharBBox[256];
 542     CFX_DWordArray          m_WidthList;
 543     short                   m_DefaultVY;
 544     short                   m_DefaultW1;
 545     CFX_DWordArray          m_VertMetrics;
 546
 547     void                    LoadMetricsArray(CPDF_Array* pArray, CFX_DWordArray& result, int nElements);
 548     void                    LoadSubstFont();
 549
 550     FX_BOOL                                     m_bAdobeCourierStd;
 551     CFX_CTTGSUBTable*       m_pTTGSUBTable;
 552 };
 553
 554 #define PDFCS_DEVICEGRAY        1
 555 #define PDFCS_DEVICERGB         2
 556 #define PDFCS_DEVICECMYK        3
 557 #define PDFCS_CALGRAY           4
 558 #define PDFCS_CALRGB            5
 559 #define PDFCS_LAB               6
 560 #define PDFCS_ICCBASED          7
 561 #define PDFCS_SEPARATION        8
 562 #define PDFCS_DEVICEN           9
 563 #define PDFCS_INDEXED           10
 564 #define PDFCS_PATTERN           11
 565
 566 class CPDF_ColorSpace
 567 {
 568 public:
 569
 570     static CPDF_ColorSpace* GetStockCS(int Family);
 571
 572     static CPDF_ColorSpace*     Load(CPDF_Document* pDoc, CPDF_Object* pCSObj);
 573
 574     void                                        ReleaseCS();
 575
 576     int                                         GetBufSize() const;
 577
 578     FX_FLOAT*                   CreateBuf();
 579
 580     void                                        GetDefaultColor(FX_FLOAT* buf) const;
 581
 582     int                                         CountComponents() const
 583     {
 584         return m_nComponents;
 585     }
 586
 587     int                                         GetFamily() const
 588     {
 589         return m_Family;
 590     }
 591
 592     virtual void                        GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
 593     {
 594         value = 0;
 595         min = 0;
 596         max = 1.0f;
 597     }
 598
 599     FX_BOOL                                     sRGB() const;
 600
 601
 602
 603     virtual FX_BOOL                     GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const = 0;
 604
 605     virtual FX_BOOL                     SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 606     {
 607         return FALSE;
 608     }
 609
 610
 611
 612
 613     FX_BOOL                                     GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const;
 614
 615     FX_BOOL                                     SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const;
 616
 617
 618     virtual void                        TranslateImageLine(uint8_t* dest_buf, const uint8_t* src_buf, int pixels,
 619             int image_width, int image_height, FX_BOOL bTransMask = FALSE) const;
 620
 621     CPDF_Array*&                        GetArray()
 622     {
 623         return m_pArray;
 624     }
 625
 626     int                                         GetMaxIndex() const;
 627
 628     virtual CPDF_ColorSpace*    GetBaseCS() const
 629     {
 630         return NULL;
 631     }
 632
 633     virtual void                        EnableStdConversion(FX_BOOL bEnabled);
 634     CPDF_Document*                      m_pDocument;
 635 protected:
 636
 637     CPDF_ColorSpace();
 638
 639     virtual ~CPDF_ColorSpace() {}
 640     virtual FX_BOOL                     v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 641     {
 642         return TRUE;
 643     }
 644     virtual FX_BOOL                     v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 645     {
 646         return FALSE;
 647     }
 648     virtual FX_BOOL                     v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
 649     {
 650         return FALSE;
 651     }
 652
 653     int                                         m_Family;
 654
 655     int                                         m_nComponents;
 656
 657     CPDF_Array*                         m_pArray;
 658
 659     FX_DWORD                            m_dwStdConversion;
 660 };
 661 class CPDF_Color
 662 {
 663 public:
 664
 665     CPDF_Color() :m_pCS(NULL), m_pBuffer(NULL)
 666     {
 667     }
 668
 669     CPDF_Color(int family);
 670
 671     ~CPDF_Color();
 672
 673     FX_BOOL                                     IsNull() const
 674     {
 675         return m_pBuffer == NULL;
 676     }
 677
 678     FX_BOOL                                     IsEqual(const CPDF_Color& other) const;
 679
 680     FX_BOOL                                     IsPattern() const
 681     {
 682         return m_pCS && m_pCS->GetFamily() == PDFCS_PATTERN;
 683     }
 684
 685     void                                        Copy(const CPDF_Color* pSrc);
 686
 687     void                                        SetColorSpace(CPDF_ColorSpace* pCS);
 688
 689     void                                        SetValue(FX_FLOAT* comp);
 690
 691     void                                        SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comp, int ncomps);
 692
 693     FX_BOOL                                     GetRGB(int& R, int& G, int& B) const;
 694
 695     CPDF_Pattern*                       GetPattern() const;
 696
 697     CPDF_ColorSpace*            GetPatternCS() const;
 698
 699     FX_FLOAT*                   GetPatternColor() const;
 700
 701     CPDF_ColorSpace*            m_pCS;
 702
 703 protected:
 704     void        ReleaseBuffer();
 705     void        ReleaseColorSpace();
 706     FX_FLOAT*                       m_pBuffer;
 707 };
 708 #define PATTERN_TILING          1
 709 #define PATTERN_SHADING         2
 710 class CPDF_Pattern
 711 {
 712 public:
 713
 714     virtual ~CPDF_Pattern();
 715     void    SetForceClear(FX_BOOL bForceClear) { m_bForceClear = bForceClear; }
 716
 717     CPDF_Object*                m_pPatternObj;
 718
 719     int                         m_PatternType;
 720
 721     CFX_AffineMatrix            m_Pattern2Form;
 722     CFX_AffineMatrix            m_ParentMatrix;
 723
 724     CPDF_Document*              m_pDocument;
 725
 726 protected:
 727     CPDF_Pattern(const CFX_AffineMatrix* pParentMatrix);
 728     FX_BOOL     m_bForceClear;
 729 };
 730
 731 class CPDF_TilingPattern : public CPDF_Pattern
 732 {
 733 public:
 734
 735     CPDF_TilingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, const CFX_AffineMatrix* parentMatrix);
 736
 737     virtual ~CPDF_TilingPattern();
 738
 739     FX_BOOL                             Load();
 740
 741
 742
 743     FX_BOOL                             m_bColored;
 744
 745     CFX_FloatRect               m_BBox;
 746
 747     FX_FLOAT                    m_XStep;
 748
 749     FX_FLOAT                    m_YStep;
 750
 751
 752
 753     CPDF_Form*                  m_pForm;
 754 };
 755 class CPDF_ShadingPattern : public CPDF_Pattern
 756 {
 757 public:
 758
 759     CPDF_ShadingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* parentMatrix);
 760
 761     virtual ~CPDF_ShadingPattern();
 762
 763     CPDF_Object*                m_pShadingObj;
 764
 765     FX_BOOL                             m_bShadingObj;
 766
 767     FX_BOOL                             Load();
 768
 769     FX_BOOL                             Reload();
 770
 771     int                                 m_ShadingType;
 772
 773     CPDF_ColorSpace*    m_pCS; // Still keep m_pCS as some CPDF_ColorSpace (name object) are not managed as counted objects. Refer to CPDF_DocPageData::GetColorSpace.
 774
 775     CPDF_CountedColorSpace*     m_pCountedCS;
 776
 777     CPDF_Function*              m_pFunctions[4];
 778
 779     int                                 m_nFuncs;
 780 protected:
 781     void        Clear();
 782 };
 783 struct CPDF_MeshVertex {
 784     FX_FLOAT x, y;
 785     FX_FLOAT r, g, b;
 786 };
 787 class CPDF_MeshStream
 788 {
 789 public:
 790
 791     FX_BOOL                             Load(CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS);
 792
 793     FX_DWORD                    GetFlag();
 794
 795     void                                GetCoords(FX_FLOAT& x, FX_FLOAT& y);
 796
 797     void                                GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b);
 798
 799     FX_DWORD                    GetVertex(CPDF_MeshVertex& vertex, CFX_AffineMatrix* pObject2Bitmap);
 800
 801     FX_BOOL                             GetVertexRow(CPDF_MeshVertex* vertex, int count, CFX_AffineMatrix* pObject2Bitmap);
 802     CPDF_Function**     m_pFuncs;
 803     CPDF_ColorSpace*    m_pCS;
 804     FX_DWORD                    m_nFuncs, m_nCoordBits, m_nCompBits, m_nFlagBits, m_nComps;
 805     FX_DWORD                    m_CoordMax, m_CompMax;
 806     FX_FLOAT                    m_xmin, m_xmax, m_ymin, m_ymax;
 807     FX_FLOAT                    m_ColorMin[8], m_ColorMax[8];
 808     CPDF_StreamAcc              m_Stream;
 809     CFX_BitStream               m_BitStream;
 810 };
 811 #define PDF_IMAGE_NO_COMPRESS                           0x0000
 812 #define PDF_IMAGE_LOSSY_COMPRESS                        0x0001
 813 #define PDF_IMAGE_LOSSLESS_COMPRESS                     0x0002
 814 #define PDF_IMAGE_MASK_LOSSY_COMPRESS           0x0004
 815 #define PDF_IMAGE_MASK_LOSSLESS_COMPRESS        0x0008
 816 class CPDF_ImageSetParam
 817 {
 818 public:
 819     CPDF_ImageSetParam()
 820         : pMatteColor(NULL)
 821         , nQuality(80)
 822     {
 823     }
 824     FX_ARGB* pMatteColor;
 825     int32_t nQuality;
 826 };
 827 class CPDF_Image
 828 {
 829 public:
 830
 831     CPDF_Image(CPDF_Document* pDoc);
 832
 833     ~CPDF_Image();
 834
 835     FX_BOOL                                     LoadImageF(CPDF_Stream* pImageStream, FX_BOOL bInline);
 836
 837     void                                        Release();
 838
 839     CPDF_Image*                         Clone();
 840
 841     FX_BOOL                                     IsInline()
 842     {
 843         return m_bInline;
 844     }
 845
 846     void                                        SetInlineDict(CPDF_Dictionary* pDict)
 847     {
 848         m_pInlineDict = pDict;
 849     }
 850
 851     CPDF_Dictionary*            GetInlineDict() const
 852     {
 853         return m_pInlineDict;
 854     }
 855
 856     CPDF_Stream*                        GetStream() const
 857     {
 858         return m_pStream;
 859     }
 860
 861     CPDF_Dictionary*            GetDict() const
 862     {
 863         return m_pStream? m_pStream->GetDict(): NULL;
 864     }
 865
 866     CPDF_Dictionary*            GetOC() const
 867     {
 868         return m_pOC;
 869     }
 870
 871     CPDF_Document*                      GetDocument() const
 872     {
 873         return m_pDocument;
 874     }
 875
 876
 877
 878     int32_t                             GetPixelHeight() const
 879     {
 880         return m_Height;
 881     }
 882
 883     int32_t                             GetPixelWidth() const
 884     {
 885         return m_Width;
 886     }
 887
 888
 889     FX_BOOL                                     IsMask() const
 890     {
 891         return m_bIsMask;
 892     }
 893
 894     FX_BOOL                                     IsInterpol() const
 895     {
 896         return m_bInterpolate;
 897     }
 898
 899     CFX_DIBSource*                      LoadDIBSource(CFX_DIBSource** ppMask = NULL, FX_DWORD* pMatteColor = NULL, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE) const;
 900
 901
 902
 903     void                                        SetImage(const CFX_DIBitmap* pDIBitmap, int32_t iCompress, IFX_FileWrite *pFileWrite = NULL, IFX_FileRead *pFileRead = NULL, const CFX_DIBitmap* pMask = NULL, const CPDF_ImageSetParam* pParam = NULL);
 904
 905     void                                        SetJpegImage(uint8_t* pImageData, FX_DWORD size);
 906
 907     void                                        SetJpegImage(IFX_FileRead *pFile);
 908
 909     void                                        ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pDIBitmap);
 910
 911 public:
 912     FX_BOOL                                     StartLoadDIBSource(CPDF_Dictionary* pFormResource, CPDF_Dictionary* pPageResource, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE);
 913     FX_BOOL                                     Continue(IFX_Pause* pPause);
 914     CFX_DIBSource*                      DetachBitmap();
 915     CFX_DIBSource*                      DetachMask();
 916     CFX_DIBSource*                      m_pDIBSource;
 917     CFX_DIBSource*                      m_pMask;
 918     FX_DWORD                            m_MatteColor;
 919 private:
 920
 921     CPDF_Stream*                        m_pStream;
 922     FX_BOOL                                     m_bInline;
 923     CPDF_Dictionary*            m_pInlineDict;
 924
 925     int32_t                             m_Height;
 926
 927     int32_t                             m_Width;
 928
 929     FX_BOOL                                     m_bIsMask;
 930
 931     FX_BOOL                                     m_bInterpolate;
 932
 933     CPDF_Document*                      m_pDocument;
 934
 935     CPDF_Dictionary*            m_pOC;
 936     CPDF_Dictionary*    InitJPEG(uint8_t* pData, FX_DWORD size);
 937 };
 938
 939 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_