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