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