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