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