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