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