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