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