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