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 class CPDF_CIDFont : public CPDF_Font
 506 {
 507 public:
 508
 509     CPDF_CIDFont();
 510
 511     virtual ~CPDF_CIDFont();
 512
 513     FX_BOOL                                     LoadGB2312();
 514     virtual int                         GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph = NULL);
 515     virtual int                         GetCharWidthF(FX_DWORD charcode, int level = 0);
 516     virtual void                        GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0);
 517
 518     FX_WORD                                     CIDFromCharCode(FX_DWORD charcode) const;
 519
 520     FX_BOOL                                     IsTrueType()
 521     {
 522         return !m_bType1;
 523     }
 524
 525
 526     virtual FX_DWORD            GetNextChar(const FX_CHAR* pString, int& offset) const;
 527     virtual int                         CountChar(const FX_CHAR* pString, int size) const;
 528     virtual int                         AppendChar(FX_LPSTR str, FX_DWORD charcode) const;
 529     virtual int                         GetCharSize(FX_DWORD charcode) const;
 530
 531
 532     int                                         GetCharset() const
 533     {
 534         return m_Charset;
 535     }
 536
 537     FX_LPCBYTE                          GetCIDTransform(FX_WORD CID) const;
 538
 539
 540
 541     virtual FX_BOOL                     IsVertWriting() const;
 542
 543     short                                       GetVertWidth(FX_WORD CID) const;
 544
 545     void                                        GetVertOrigin(FX_WORD CID, short& vx, short& vy) const;
 546
 547     virtual FX_BOOL                     IsUnicodeCompatible() const;
 548     virtual FX_BOOL                     IsFontStyleFromCharCode(FX_DWORD charcode) const;
 549 protected:
 550     friend class                        CPDF_Font;
 551     virtual FX_BOOL                     _Load();
 552     virtual FX_WCHAR            _UnicodeFromCharCode(FX_DWORD charcode) const;
 553     virtual FX_DWORD            _CharCodeFromUnicode(FX_WCHAR Unicode) const;
 554     int                         GetGlyphIndex(FX_DWORD unicodeb, FX_BOOL *pVertGlyph);
 555
 556     CPDF_CMap*                          m_pCMap;
 557
 558     CPDF_CMap*                          m_pAllocatedCMap;
 559
 560     CPDF_CID2UnicodeMap*        m_pCID2UnicodeMap;
 561
 562     int                                         m_Charset;
 563
 564     FX_BOOL                                     m_bType1;
 565
 566     CPDF_StreamAcc*                     m_pCIDToGIDMap;
 567     FX_BOOL                                     m_bCIDIsGID;
 568
 569
 570
 571     FX_WORD                                     m_DefaultWidth;
 572
 573     FX_WORD*                            m_pAnsiWidths;
 574
 575     FX_SMALL_RECT                       m_CharBBox[256];
 576
 577     CFX_DWordArray                      m_WidthList;
 578
 579     short                                       m_DefaultVY;
 580
 581     short                                       m_DefaultW1;
 582
 583     CFX_DWordArray                      m_VertMetrics;
 584
 585
 586     void                                        LoadMetricsArray(CPDF_Array* pArray, CFX_DWordArray& result, int nElements);
 587
 588     void                                        LoadSubstFont();
 589
 590     FX_BOOL                                     m_bAdobeCourierStd;
 591
 592     CFX_CTTGSUBTable*                   m_pTTGSUBTable;
 593 };
 594 #define PDFCS_DEVICEGRAY                1
 595
 596 #define PDFCS_DEVICERGB                 2
 597 #define PDFCS_DEVICECMYK                3
 598 #define PDFCS_CALGRAY                   4
 599 #define PDFCS_CALRGB                    5
 600 #define PDFCS_LAB                               6
 601 #define PDFCS_ICCBASED                  7
 602 #define PDFCS_SEPARATION                8
 603 #define PDFCS_DEVICEN                   9
 604 #define PDFCS_INDEXED                   10
 605 #define PDFCS_PATTERN                   11
 606 class CPDF_ColorSpace : public CFX_Object
 607 {
 608 public:
 609
 610     static CPDF_ColorSpace* GetStockCS(int Family);
 611
 612     static CPDF_ColorSpace*     Load(CPDF_Document* pDoc, CPDF_Object* pCSObj);
 613
 614     void                                        ReleaseCS();
 615
 616     int                                         GetBufSize() const;
 617
 618     FX_FLOAT*                   CreateBuf();
 619
 620     void                                        GetDefaultColor(FX_FLOAT* buf) const;
 621
 622     int                                         CountComponents() const
 623     {
 624         return m_nComponents;
 625     }
 626
 627     int                                         GetFamily() const
 628     {
 629         return m_Family;
 630     }
 631
 632     virtual void                        GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
 633     {
 634         value = 0;
 635         min = 0;
 636         max = 1.0f;
 637     }
 638
 639     FX_BOOL                                     sRGB() const;
 640
 641
 642
 643     virtual FX_BOOL                     GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const = 0;
 644
 645     virtual FX_BOOL                     SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 646     {
 647         return FALSE;
 648     }
 649
 650
 651
 652
 653     FX_BOOL                                     GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const;
 654
 655     FX_BOOL                                     SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const;
 656
 657
 658     virtual void                        TranslateImageLine(FX_LPBYTE dest_buf, FX_LPCBYTE src_buf, int pixels,
 659             int image_width, int image_height, FX_BOOL bTransMask = FALSE) const;
 660
 661     CPDF_Array*&                        GetArray()
 662     {
 663         return m_pArray;
 664     }
 665
 666     int                                         GetMaxIndex() const;
 667
 668     virtual CPDF_ColorSpace*    GetBaseCS() const
 669     {
 670         return NULL;
 671     }
 672
 673     virtual void                        EnableStdConversion(FX_BOOL bEnabled);
 674     CPDF_Document*                      m_pDocument;
 675 protected:
 676
 677     CPDF_ColorSpace();
 678
 679     virtual ~CPDF_ColorSpace() {}
 680     virtual FX_BOOL                     v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 681     {
 682         return TRUE;
 683     }
 684     virtual FX_BOOL                     v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 685     {
 686         return FALSE;
 687     }
 688     virtual FX_BOOL                     v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
 689     {
 690         return FALSE;
 691     }
 692
 693     int                                         m_Family;
 694
 695     int                                         m_nComponents;
 696
 697     CPDF_Array*                         m_pArray;
 698
 699     FX_DWORD                            m_dwStdConversion;
 700 };
 701 class CPDF_Color : public CFX_Object
 702 {
 703 public:
 704
 705     CPDF_Color() :m_pCS(NULL), m_pBuffer(NULL)
 706     {
 707     }
 708
 709     CPDF_Color(int family);
 710
 711     ~CPDF_Color();
 712
 713     FX_BOOL                                     IsNull() const
 714     {
 715         return m_pBuffer == NULL;
 716     }
 717
 718     FX_BOOL                                     IsEqual(const CPDF_Color& other) const;
 719
 720     FX_BOOL                                     IsPattern() const
 721     {
 722         return m_pCS && m_pCS->GetFamily() == PDFCS_PATTERN;
 723     }
 724
 725     void                                        Copy(const CPDF_Color* pSrc);
 726
 727     void                                        SetColorSpace(CPDF_ColorSpace* pCS);
 728
 729     void                                        SetValue(FX_FLOAT* comp);
 730
 731     void                                        SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comp, int ncomps);
 732
 733     FX_BOOL                                     GetRGB(int& R, int& G, int& B) const;
 734
 735     CPDF_Pattern*                       GetPattern() const;
 736
 737     CPDF_ColorSpace*            GetPatternCS() const;
 738
 739     FX_FLOAT*                   GetPatternColor() const;
 740
 741     CPDF_ColorSpace*            m_pCS;
 742
 743 protected:
 744     void        ReleaseBuffer();
 745     void        ReleaseColorSpace();
 746     FX_FLOAT*                       m_pBuffer;
 747 };
 748 #define PATTERN_TILING          1
 749 #define PATTERN_SHADING         2
 750 class CPDF_Pattern : public CFX_Object
 751 {
 752 public:
 753
 754     virtual ~CPDF_Pattern();
 755     void    SetForceClear(FX_BOOL bForceClear) { m_bForceClear = bForceClear; }
 756
 757     CPDF_Object*                m_pPatternObj;
 758
 759     int                         m_PatternType;
 760
 761     CFX_AffineMatrix            m_Pattern2Form;
 762     CFX_AffineMatrix            m_ParentMatrix;
 763
 764     CPDF_Document*              m_pDocument;
 765
 766 protected:
 767     CPDF_Pattern(const CFX_AffineMatrix* pParentMatrix);
 768     FX_BOOL     m_bForceClear;
 769 };
 770
 771 class CPDF_TilingPattern : public CPDF_Pattern
 772 {
 773 public:
 774
 775     CPDF_TilingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, const CFX_AffineMatrix* parentMatrix);
 776
 777     virtual ~CPDF_TilingPattern();
 778
 779     FX_BOOL                             Load();
 780
 781
 782
 783     FX_BOOL                             m_bColored;
 784
 785     CFX_FloatRect               m_BBox;
 786
 787     FX_FLOAT                    m_XStep;
 788
 789     FX_FLOAT                    m_YStep;
 790
 791
 792
 793     CPDF_Form*                  m_pForm;
 794 };
 795 class CPDF_ShadingPattern : public CPDF_Pattern
 796 {
 797 public:
 798
 799     CPDF_ShadingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* parentMatrix);
 800
 801     virtual ~CPDF_ShadingPattern();
 802
 803     CPDF_Object*                m_pShadingObj;
 804
 805     FX_BOOL                             m_bShadingObj;
 806
 807     FX_BOOL                             Load();
 808
 809     FX_BOOL                             Reload();
 810
 811     int                                 m_ShadingType;
 812
 813     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.
 814
 815     CPDF_CountedColorSpace*     m_pCountedCS;
 816
 817     CPDF_Function*              m_pFunctions[4];
 818
 819     int                                 m_nFuncs;
 820 protected:
 821     void        Clear();
 822 };
 823 struct CPDF_MeshVertex {
 824     FX_FLOAT x, y;
 825     FX_FLOAT r, g, b;
 826 };
 827 class CPDF_MeshStream : public CFX_Object
 828 {
 829 public:
 830
 831     FX_BOOL                             Load(CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS);
 832
 833     FX_DWORD                    GetFlag();
 834
 835     void                                GetCoords(FX_FLOAT& x, FX_FLOAT& y);
 836
 837     void                                GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b);
 838
 839     FX_DWORD                    GetVertex(CPDF_MeshVertex& vertex, CFX_AffineMatrix* pObject2Bitmap);
 840
 841     FX_BOOL                             GetVertexRow(CPDF_MeshVertex* vertex, int count, CFX_AffineMatrix* pObject2Bitmap);
 842     CPDF_Function**     m_pFuncs;
 843     CPDF_ColorSpace*    m_pCS;
 844     FX_DWORD                    m_nFuncs, m_nCoordBits, m_nCompBits, m_nFlagBits, m_nComps;
 845     FX_DWORD                    m_CoordMax, m_CompMax;
 846     FX_FLOAT                    m_xmin, m_xmax, m_ymin, m_ymax;
 847     FX_FLOAT                    m_ColorMin[8], m_ColorMax[8];
 848     CPDF_StreamAcc              m_Stream;
 849     CFX_BitStream               m_BitStream;
 850 };
 851 #define PDF_IMAGE_NO_COMPRESS                           0x0000
 852 #define PDF_IMAGE_LOSSY_COMPRESS                        0x0001
 853 #define PDF_IMAGE_LOSSLESS_COMPRESS                     0x0002
 854 #define PDF_IMAGE_MASK_LOSSY_COMPRESS           0x0004
 855 #define PDF_IMAGE_MASK_LOSSLESS_COMPRESS        0x0008
 856 class CPDF_ImageSetParam
 857 {
 858 public:
 859     CPDF_ImageSetParam()
 860         : pMatteColor(NULL)
 861         , nQuality(80)
 862     {
 863     }
 864     FX_ARGB* pMatteColor;
 865     FX_INT32 nQuality;
 866 };
 867 class CPDF_Image : public CFX_Object
 868 {
 869 public:
 870
 871     CPDF_Image(CPDF_Document* pDoc);
 872
 873     ~CPDF_Image();
 874
 875     FX_BOOL                                     LoadImageF(CPDF_Stream* pImageStream, FX_BOOL bInline);
 876
 877     void                                        Release();
 878
 879     CPDF_Image*                         Clone();
 880
 881     FX_BOOL                                     IsInline()
 882     {
 883         return m_bInline;
 884     }
 885
 886     void                                        SetInlineDict(CPDF_Dictionary* pDict)
 887     {
 888         m_pInlineDict = pDict;
 889     }
 890
 891     CPDF_Dictionary*            GetInlineDict() const
 892     {
 893         return m_pInlineDict;
 894     }
 895
 896     CPDF_Stream*                        GetStream() const
 897     {
 898         return m_pStream;
 899     }
 900
 901     CPDF_Dictionary*            GetDict() const
 902     {
 903         return m_pStream? m_pStream->GetDict(): NULL;
 904     }
 905
 906     CPDF_Dictionary*            GetOC() const
 907     {
 908         return m_pOC;
 909     }
 910
 911     CPDF_Document*                      GetDocument() const
 912     {
 913         return m_pDocument;
 914     }
 915
 916
 917
 918     FX_INT32                            GetPixelHeight() const
 919     {
 920         return m_Height;
 921     }
 922
 923     FX_INT32                            GetPixelWidth() const
 924     {
 925         return m_Width;
 926     }
 927
 928
 929     FX_BOOL                                     IsMask() const
 930     {
 931         return m_bIsMask;
 932     }
 933
 934     FX_BOOL                                     IsInterpol() const
 935     {
 936         return m_bInterpolate;
 937     }
 938
 939     CFX_DIBSource*                      LoadDIBSource(CFX_DIBSource** ppMask = NULL, FX_DWORD* pMatteColor = NULL, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE) const;
 940
 941
 942
 943     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);
 944
 945     void                                        SetJpegImage(FX_BYTE* pImageData, FX_DWORD size);
 946
 947     void                                        SetJpegImage(IFX_FileRead *pFile);
 948
 949     void                                        ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pDIBitmap);
 950
 951 public:
 952     FX_BOOL                                     StartLoadDIBSource(CPDF_Dictionary* pFormResource, CPDF_Dictionary* pPageResource, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE);
 953     FX_BOOL                                     Continue(IFX_Pause* pPause);
 954     CFX_DIBSource*                      DetachBitmap();
 955     CFX_DIBSource*                      DetachMask();
 956     CFX_DIBSource*                      m_pDIBSource;
 957     CFX_DIBSource*                      m_pMask;
 958     FX_DWORD                            m_MatteColor;
 959 private:
 960
 961     CPDF_Stream*                        m_pStream;
 962     FX_BOOL                                     m_bInline;
 963     CPDF_Dictionary*            m_pInlineDict;
 964
 965     FX_INT32                            m_Height;
 966
 967     FX_INT32                            m_Width;
 968
 969     FX_BOOL                                     m_bIsMask;
 970
 971     FX_BOOL                                     m_bInterpolate;
 972
 973     CPDF_Document*                      m_pDocument;
 974
 975     CPDF_Dictionary*            m_pOC;
 976     CPDF_Dictionary*    InitJPEG(FX_LPBYTE pData, FX_DWORD size);
 977 };
 978 #endif