core/src/fpdfapi/fpdf_page/pageint.h - Issue 1265503005: clang-format all pdfium code.

Side by Side Diff: core/src/fpdfapi/fpdf_page/pageint.h

Issue 1265503005: clang-format all pdfium code. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: sigh Created 5 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
1 // Copyright 2014 PDFium Authors. All rights reserved.	1 // Copyright 2014 PDFium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be	2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.	3 // found in the LICENSE file.

4	4

5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com	5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

6	6

7 #ifndef CORE_SRC_FPDFAPI_FPDF_PAGE_PAGEINT_H_	7 #ifndef CORE_SRC_FPDFAPI_FPDF_PAGE_PAGEINT_H_

8 #define CORE_SRC_FPDFAPI_FPDF_PAGE_PAGEINT_H_	8 #define CORE_SRC_FPDFAPI_FPDF_PAGE_PAGEINT_H_

9	9

10 #include <map>	10 #include <map>

11	11

12 #include "../../../../third_party/base/nonstd_unique_ptr.h"	12 #include "../../../../third_party/base/nonstd_unique_ptr.h"

13 #include "../../../include/fpdfapi/fpdf_pageobj.h"	13 #include "../../../include/fpdfapi/fpdf_pageobj.h"

14	14

15 #define PARSE_STEP_LIMIT» » 100	15 #define PARSE_STEP_LIMIT 100

16	16

17 class CPDF_StreamParser	17 class CPDF_StreamParser {

18 {	18 public:

19 public:	19 CPDF_StreamParser(const uint8_t* pData, FX_DWORD dwSize);

20	20 ~CPDF_StreamParser();

21 CPDF_StreamParser(const uint8_t* pData, FX_DWORD dwSize);	21

22 ~CPDF_StreamParser();	22 CPDF_Stream* ReadInlineStream(CPDF_Document* pDoc,

23	23 CPDF_Dictionary* pDict,

24 CPDF_Stream» » ReadInlineStream(CPDF_Document pDoc, CPDF_Dicti onary* pDict, CPDF_Object* pCSObj, FX_BOOL bDecode);	24 CPDF_Object* pCSObj,

25 typedef enum { EndOfData, Number, Keyword, Name, Others } SyntaxType;	25 FX_BOOL bDecode);

26	26 typedef enum { EndOfData, Number, Keyword, Name, Others } SyntaxType;

27 SyntaxType» » » ParseNextElement();	27

28 uint8_t*» » » GetWordBuf()	28 SyntaxType ParseNextElement();

29 {	29 uint8_t* GetWordBuf() { return m_WordBuffer; }

30 return m_WordBuffer;	30 FX_DWORD GetWordSize() { return m_WordSize; }

31 }	31 CPDF_Object* GetObject() {

32 FX_DWORD» » » GetWordSize()	32 CPDF_Object* pObj = m_pLastObj;

33 {	33 m_pLastObj = NULL;

34 return m_WordSize;	34 return pObj;

35 }	35 }

36 CPDF_Object*» » GetObject()	36 FX_DWORD GetPos() { return m_Pos; }

37 {	37 void SetPos(FX_DWORD pos) { m_Pos = pos; }

38 CPDF_Object* pObj = m_pLastObj;	38

39 m_pLastObj = NULL;	39 CPDF_Object* ReadNextObject(FX_BOOL bAllowNestedArray = FALSE,

40 return pObj;	40 FX_BOOL bInArray = FALSE);

41 }	41 void SkipPathObject();

42 FX_DWORD» » » GetPos()	42

43 {	43 protected:

44 return m_Pos;	44 void GetNextWord(FX_BOOL& bIsNumber);

45 }	45 CFX_ByteString ReadString();

46 void» » » » SetPos(FX_DWORD pos)	46 CFX_ByteString ReadHexString();

47 {	47 const uint8_t* m_pBuf;

48 m_Pos = pos;	48 FX_DWORD m_Size;

49 }	49 FX_DWORD m_Pos;

50	50 uint8_t m_WordBuffer[256];

51 CPDF_Object*» » ReadNextObject(FX_BOOL bAllowNestedArray = FALSE , FX_BOOL bInArray = FALSE);	51 FX_DWORD m_WordSize;

52 void» » » » SkipPathObject();	52 CPDF_Object* m_pLastObj;

53 protected:

54 void» » » » GetNextWord(FX_BOOL& bIsNumber);

55 CFX_ByteString» » ReadString();

56 CFX_ByteString» » ReadHexString();

57 const uint8_t*» » m_pBuf;

58 FX_DWORD» » » m_Size;

59 FX_DWORD» » » m_Pos;

60 uint8_t» » » » m_WordBuffer[256];

61 FX_DWORD» » » m_WordSize;

62 CPDF_Object*» » m_pLastObj;

63 };	53 };

64 typedef enum {	54 typedef enum {

65 PDFOP_CloseFillStrokePath = 0, PDFOP_FillStrokePath,	55 PDFOP_CloseFillStrokePath = 0,

66 PDFOP_CloseEOFillStrokePath, PDFOP_EOFillStrokePath,	56 PDFOP_FillStrokePath,

67 PDFOP_BeginMarkedContent_Dictionary, PDFOP_BeginImage,	57 PDFOP_CloseEOFillStrokePath,

68 PDFOP_BeginMarkedContent, PDFOP_BeginText,	58 PDFOP_EOFillStrokePath,

69 PDFOP_BeginSectionUndefined, PDFOP_CurveTo_123,	59 PDFOP_BeginMarkedContent_Dictionary,

70 PDFOP_ConcatMatrix, PDFOP_SetColorSpace_Fill,	60 PDFOP_BeginImage,

71 PDFOP_SetColorSpace_Stroke, PDFOP_SetDash,	61 PDFOP_BeginMarkedContent,

72 PDFOP_SetCharWidth, PDFOP_SetCachedDevice,	62 PDFOP_BeginText,

73 PDFOP_ExecuteXObject, PDFOP_MarkPlace_Dictionary,	63 PDFOP_BeginSectionUndefined,

74 PDFOP_EndImage, PDFOP_EndMarkedContent,	64 PDFOP_CurveTo_123,

75 PDFOP_EndText, PDFOP_EndSectionUndefined,	65 PDFOP_ConcatMatrix,

76 PDFOP_FillPath, PDFOP_FillPathOld,	66 PDFOP_SetColorSpace_Fill,

77 PDFOP_EOFillPath, PDFOP_SetGray_Fill,	67 PDFOP_SetColorSpace_Stroke,

78 PDFOP_SetGray_Stroke, PDFOP_SetExtendGraphState,	68 PDFOP_SetDash,

79 PDFOP_ClosePath, PDFOP_SetFlat,	69 PDFOP_SetCharWidth,

80 PDFOP_BeginImageData, PDFOP_SetLineJoin,	70 PDFOP_SetCachedDevice,

81 PDFOP_SetLineCap, PDFOP_SetCMYKColor_Fill,	71 PDFOP_ExecuteXObject,

82 PDFOP_SetCMYKColor_Stroke, PDFOP_LineTo,	72 PDFOP_MarkPlace_Dictionary,

83 PDFOP_MoveTo, PDFOP_SetMiterLimit,	73 PDFOP_EndImage,

84 PDFOP_MarkPlace, PDFOP_EndPath,	74 PDFOP_EndMarkedContent,

85 PDFOP_SaveGraphState, PDFOP_RestoreGraphState,	75 PDFOP_EndText,

86 PDFOP_Rectangle, PDFOP_SetRGBColor_Fill,	76 PDFOP_EndSectionUndefined,

87 PDFOP_SetRGBColor_Stroke, PDFOP_SetRenderIntent,	77 PDFOP_FillPath,

88 PDFOP_CloseStrokePath, PDFOP_StrokePath,	78 PDFOP_FillPathOld,

89 PDFOP_SetColor_Fill, PDFOP_SetColor_Stroke,	79 PDFOP_EOFillPath,

90 PDFOP_SetColorPS_Fill, PDFOP_SetColorPS_Stroke,	80 PDFOP_SetGray_Fill,

91 PDFOP_ShadeFill, PDFOP_SetCharSpace,	81 PDFOP_SetGray_Stroke,

92 PDFOP_MoveTextPoint, PDFOP_MoveTextPoint_SetLeading,	82 PDFOP_SetExtendGraphState,

93 PDFOP_SetFont, PDFOP_ShowText,	83 PDFOP_ClosePath,

94 PDFOP_ShowText_Positioning, PDFOP_SetTextLeading,	84 PDFOP_SetFlat,

95 PDFOP_SetTextMatrix, PDFOP_SetTextRenderMode,	85 PDFOP_BeginImageData,

96 PDFOP_SetTextRise, PDFOP_SetWordSpace,	86 PDFOP_SetLineJoin,

97 PDFOP_SetHorzScale, PDFOP_MoveToNextLine,	87 PDFOP_SetLineCap,

98 PDFOP_CurveTo_23, PDFOP_SetLineWidth,	88 PDFOP_SetCMYKColor_Fill,

99 PDFOP_Clip, PDFOP_EOClip,	89 PDFOP_SetCMYKColor_Stroke,

100 PDFOP_CurveTo_13, PDFOP_NextLineShowText,	90 PDFOP_LineTo,

101 PDFOP_NextLineShowText_Space, PDFOP_Invalid	91 PDFOP_MoveTo,

	92 PDFOP_SetMiterLimit,

	93 PDFOP_MarkPlace,

	94 PDFOP_EndPath,

	95 PDFOP_SaveGraphState,

	96 PDFOP_RestoreGraphState,

	97 PDFOP_Rectangle,

	98 PDFOP_SetRGBColor_Fill,

	99 PDFOP_SetRGBColor_Stroke,

	100 PDFOP_SetRenderIntent,

	101 PDFOP_CloseStrokePath,

	102 PDFOP_StrokePath,

	103 PDFOP_SetColor_Fill,

	104 PDFOP_SetColor_Stroke,

	105 PDFOP_SetColorPS_Fill,

	106 PDFOP_SetColorPS_Stroke,

	107 PDFOP_ShadeFill,

	108 PDFOP_SetCharSpace,

	109 PDFOP_MoveTextPoint,

	110 PDFOP_MoveTextPoint_SetLeading,

	111 PDFOP_SetFont,

	112 PDFOP_ShowText,

	113 PDFOP_ShowText_Positioning,

	114 PDFOP_SetTextLeading,

	115 PDFOP_SetTextMatrix,

	116 PDFOP_SetTextRenderMode,

	117 PDFOP_SetTextRise,

	118 PDFOP_SetWordSpace,

	119 PDFOP_SetHorzScale,

	120 PDFOP_MoveToNextLine,

	121 PDFOP_CurveTo_23,

	122 PDFOP_SetLineWidth,

	123 PDFOP_Clip,

	124 PDFOP_EOClip,

	125 PDFOP_CurveTo_13,

	126 PDFOP_NextLineShowText,

	127 PDFOP_NextLineShowText_Space,

	128 PDFOP_Invalid

102 } PDFOP;	129 } PDFOP;

103 #define PARAM_BUF_SIZE» 16	130 #define PARAM_BUF_SIZE 16

104 typedef struct {	131 typedef struct {

105 int»» » m_Type;	132 int m_Type;

106 union {	133 union {

107 struct {	134 struct {

108 FX_BOOL» » m_bInteger;	135 FX_BOOL m_bInteger;

109 union {	136 union {

110 int» » m_Integer;	137 int m_Integer;

111 FX_FLOAT m_Float;	138 FX_FLOAT m_Float;

112 };	139 };

113 } m_Number;	140 } m_Number;

114 CPDF_Object*» m_pObject;	141 CPDF_Object* m_pObject;

115 struct {	142 struct {

116 int»» » m_Len;	143 int m_Len;

117 char» » m_Buffer[32];	144 char m_Buffer[32];

118 } m_Name;	145 } m_Name;

119 };	146 };

120 } _ContentParam;	147 } _ContentParam;

121 #define _FPDF_MAX_FORM_LEVEL_» » 30	148 #define _FPDF_MAX_FORM_LEVEL_ 30

122 #define _FPDF_MAX_TYPE3_FORM_LEVEL_» 4	149 #define _FPDF_MAX_TYPE3_FORM_LEVEL_ 4

123 #define _FPDF_MAX_OBJECT_STACK_SIZE_ 512	150 #define _FPDF_MAX_OBJECT_STACK_SIZE_ 512

124 class CPDF_StreamContentParser	151 class CPDF_StreamContentParser {

125 {	152 public:

126 public:	153 CPDF_StreamContentParser(CPDF_Document* pDoc,

127 CPDF_StreamContentParser(	154 CPDF_Dictionary* pPageResources,

128 CPDF_Document* pDoc,	155 CPDF_Dictionary* pParentResources,

129 CPDF_Dictionary* pPageResources,	156 CFX_AffineMatrix* pmtContentToUser,

130 CPDF_Dictionary* pParentResources,	157 CPDF_PageObjects* pObjList,

131 CFX_AffineMatrix* pmtContentToUser,	158 CPDF_Dictionary* pResources,

132 CPDF_PageObjects* pObjList,	159 CFX_FloatRect* pBBox,

133 CPDF_Dictionary* pResources,	160 CPDF_ParseOptions* pOptions,

134 CFX_FloatRect* pBBox,	161 CPDF_AllStates* pAllStates,

135 CPDF_ParseOptions* pOptions,	162 int level);

136 CPDF_AllStates* pAllStates,	163 ~CPDF_StreamContentParser();

137 int level);	164

138 ~CPDF_StreamContentParser();	165 FX_BOOL ShouldAbort() const { return m_bAbort; }

139	166 CPDF_PageObjects* GetObjectList() const { return m_pObjectList; }

140 FX_BOOL ShouldAbort() const { return m_bAbort; }	167 CPDF_AllStates* GetCurStates() const { return m_pCurStates.get(); }

141 CPDF_PageObjects* GetObjectList() const { return m_pObjectList; }	168 FX_BOOL IsColored() const { return m_bColored; }

142 CPDF_AllStates* GetCurStates() const { return m_pCurStates.get(); }	169 const FX_FLOAT* GetType3Data() const { return m_Type3Data; }

143 FX_BOOL IsColored() const { return m_bColored; }	170

144 const FX_FLOAT* GetType3Data() const { return m_Type3Data; }	171 void AddNumberParam(const FX_CHAR* str, int len);

145	172 void AddObjectParam(CPDF_Object* pObj);

146 void AddNumberParam(const FX_CHAR* str, int l en);	173 void AddNameParam(const FX_CHAR* name, int size);

147 void AddObjectParam(CPDF_Object* pObj);	174 int GetNextParamPos();

148 void AddNameParam(const FX_CHAR* name, int si ze);	175 void ClearAllParams();

149 int GetNextParamPos();	176 CPDF_Object* GetObject(FX_DWORD index);

150 void ClearAllParams();	177 CFX_ByteString GetString(FX_DWORD index);

151 CPDF_Object* GetObject(FX_DWORD index);	178 FX_FLOAT GetNumber(FX_DWORD index);

152 CFX_ByteString GetString(FX_DWORD index);	179 FX_FLOAT GetNumber16(FX_DWORD index);

153 FX_FLOAT GetNumber(FX_DWORD index);	180 int GetInteger(FX_DWORD index) { return (int32_t)(GetNumber(index)); }

154 FX_FLOAT GetNumber16(FX_DWORD index);	181 FX_BOOL OnOperator(const FX_CHAR* op);

155 int GetInteger(FX_DWORD index)	182 void BigCaseCaller(int index);

156 {	183 FX_DWORD GetParsePos() { return m_pSyntax->GetPos(); }

157 return (int32_t)(GetNumber(index));	184 void AddTextObject(CFX_ByteString* pText,

158 }	185 FX_FLOAT fInitKerning,

159 FX_BOOL OnOperator(const FX_CHAR* op);	186 FX_FLOAT* pKerning,

160 void BigCaseCaller(int index);	187 int count);

161 FX_DWORD GetParsePos()	188

162 {	189 void ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y);

163 return m_pSyntax->GetPos();	190 void ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y);

164 }	191 void OnChangeTextMatrix();

165 void AddTextObject(CFX_ByteString* pText, FX_ FLOAT fInitKerning, FX_FLOAT* pKerning, int count);	192 FX_DWORD Parse(const uint8_t* pData, FX_DWORD dwSize, FX_DWORD max_cost);

166	193 void ParsePathObject();

167 void ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y);	194 void AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag);

168 void ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y);	195 void AddPathRect(FX_FLOAT x, FX_FLOAT y, FX_FLOAT w, FX_FLOAT h);

169 void OnChangeTextMatrix();	196 void AddPathObject(int FillType, FX_BOOL bStroke);

170 FX_DWORD Parse(const uint8_t* pData, FX_DWORD dwSize, FX_ DWORD max_cost);	197 CPDF_ImageObject* AddImage(CPDF_Stream* pStream,

171 void ParsePathObject();	198 CPDF_Image* pImage,

172 void AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag);	199 FX_BOOL bInline);

173 void AddPathRect(FX_FLOAT x, FX_FLOAT y, FX_F LOAT w, FX_FLOAT h);	200 void AddDuplicateImage();

174 void AddPathObject(int FillType, FX_BOOL bStr oke);	201 void AddForm(CPDF_Stream*);

175 CPDF_ImageObject* AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, FX_BO OL bInline);	202 void SetGraphicStates(CPDF_PageObject* pObj,

176 void AddDuplicateImage();	203 FX_BOOL bColor,

177 void AddForm(CPDF_Stream*);	204 FX_BOOL bText,

178 void SetGraphicStates(CPDF_PageObject* pObj, FX_BOOL bColor, FX_BOOL bText, FX_BOOL bGraph);	205 FX_BOOL bGraph);

179 void SaveStates(CPDF_AllStates*);	206 void SaveStates(CPDF_AllStates*);

180 void RestoreStates(CPDF_AllStates*);	207 void RestoreStates(CPDF_AllStates*);

181 CPDF_Font* FindFont(const CFX_ByteString& name);	208 CPDF_Font* FindFont(const CFX_ByteString& name);

182 CPDF_ColorSpace* FindColorSpace(const CFX_ByteString& name);	209 CPDF_ColorSpace* FindColorSpace(const CFX_ByteString& name);

183 CPDF_Pattern* FindPattern(const CFX_ByteString& name, FX_BOOL bShading);	210 CPDF_Pattern* FindPattern(const CFX_ByteString& name, FX_BOOL bShading);

184 CPDF_Object* FindResourceObj(const CFX_ByteStringC& type, con st CFX_ByteString& name);	211 CPDF_Object* FindResourceObj(const CFX_ByteStringC& type,

185	212 const CFX_ByteString& name);

186 protected:	213

187 struct OpCode {	214 protected:

188 FX_DWORD m_OpId;	215 struct OpCode {

189 void (CPDF_StreamContentParser::*m_OpHandler)();	216 FX_DWORD m_OpId;

190 };	217 void (CPDF_StreamContentParser::*m_OpHandler)();

191 static const OpCode g_OpCodes[];	218 };

192	219 static const OpCode g_OpCodes[];

193 void Handle_CloseFillStrokePath();	220

194 void Handle_FillStrokePath();	221 void Handle_CloseFillStrokePath();

195 void Handle_CloseEOFillStrokePath();	222 void Handle_FillStrokePath();

196 void Handle_EOFillStrokePath();	223 void Handle_CloseEOFillStrokePath();

197 void Handle_BeginMarkedContent_Dictionary();	224 void Handle_EOFillStrokePath();

198 void Handle_BeginImage();	225 void Handle_BeginMarkedContent_Dictionary();

199 void Handle_BeginMarkedContent();	226 void Handle_BeginImage();

200 void Handle_BeginText();	227 void Handle_BeginMarkedContent();

201 void Handle_BeginSectionUndefined();	228 void Handle_BeginText();

202 void Handle_CurveTo_123();	229 void Handle_BeginSectionUndefined();

203 void Handle_ConcatMatrix();	230 void Handle_CurveTo_123();

204 void Handle_SetColorSpace_Fill();	231 void Handle_ConcatMatrix();

205 void Handle_SetColorSpace_Stroke();	232 void Handle_SetColorSpace_Fill();

206 void Handle_SetDash();	233 void Handle_SetColorSpace_Stroke();

207 void Handle_SetCharWidth();	234 void Handle_SetDash();

208 void Handle_SetCachedDevice();	235 void Handle_SetCharWidth();

209 void Handle_ExecuteXObject();	236 void Handle_SetCachedDevice();

210 void Handle_MarkPlace_Dictionary();	237 void Handle_ExecuteXObject();

211 void Handle_EndImage();	238 void Handle_MarkPlace_Dictionary();

212 void Handle_EndMarkedContent();	239 void Handle_EndImage();

213 void Handle_EndText();	240 void Handle_EndMarkedContent();

214 void Handle_EndSectionUndefined();	241 void Handle_EndText();

215 void Handle_FillPath();	242 void Handle_EndSectionUndefined();

216 void Handle_FillPathOld();	243 void Handle_FillPath();

217 void Handle_EOFillPath();	244 void Handle_FillPathOld();

218 void Handle_SetGray_Fill();	245 void Handle_EOFillPath();

219 void Handle_SetGray_Stroke();	246 void Handle_SetGray_Fill();

220 void Handle_SetExtendGraphState();	247 void Handle_SetGray_Stroke();

221 void Handle_ClosePath();	248 void Handle_SetExtendGraphState();

222 void Handle_SetFlat();	249 void Handle_ClosePath();

223 void Handle_BeginImageData();	250 void Handle_SetFlat();

224 void Handle_SetLineJoin();	251 void Handle_BeginImageData();

225 void Handle_SetLineCap();	252 void Handle_SetLineJoin();

226 void Handle_SetCMYKColor_Fill();	253 void Handle_SetLineCap();

227 void Handle_SetCMYKColor_Stroke();	254 void Handle_SetCMYKColor_Fill();

228 void Handle_LineTo();	255 void Handle_SetCMYKColor_Stroke();

229 void Handle_MoveTo();	256 void Handle_LineTo();

230 void Handle_SetMiterLimit();	257 void Handle_MoveTo();

231 void Handle_MarkPlace();	258 void Handle_SetMiterLimit();

232 void Handle_EndPath();	259 void Handle_MarkPlace();

233 void Handle_SaveGraphState();	260 void Handle_EndPath();

234 void Handle_RestoreGraphState();	261 void Handle_SaveGraphState();

235 void Handle_Rectangle();	262 void Handle_RestoreGraphState();

236 void Handle_SetRGBColor_Fill();	263 void Handle_Rectangle();

237 void Handle_SetRGBColor_Stroke();	264 void Handle_SetRGBColor_Fill();

238 void Handle_SetRenderIntent();	265 void Handle_SetRGBColor_Stroke();

239 void Handle_CloseStrokePath();	266 void Handle_SetRenderIntent();

240 void Handle_StrokePath();	267 void Handle_CloseStrokePath();

241 void Handle_SetColor_Fill();	268 void Handle_StrokePath();

242 void Handle_SetColor_Stroke();	269 void Handle_SetColor_Fill();

243 void Handle_SetColorPS_Fill();	270 void Handle_SetColor_Stroke();

244 void Handle_SetColorPS_Stroke();	271 void Handle_SetColorPS_Fill();

245 void Handle_ShadeFill();	272 void Handle_SetColorPS_Stroke();

246 void Handle_SetCharSpace();	273 void Handle_ShadeFill();

247 void Handle_MoveTextPoint();	274 void Handle_SetCharSpace();

248 void Handle_MoveTextPoint_SetLeading();	275 void Handle_MoveTextPoint();

249 void Handle_SetFont();	276 void Handle_MoveTextPoint_SetLeading();

250 void Handle_ShowText();	277 void Handle_SetFont();

251 void Handle_ShowText_Positioning();	278 void Handle_ShowText();

252 void Handle_SetTextLeading();	279 void Handle_ShowText_Positioning();

253 void Handle_SetTextMatrix();	280 void Handle_SetTextLeading();

254 void Handle_SetTextRenderMode();	281 void Handle_SetTextMatrix();

255 void Handle_SetTextRise();	282 void Handle_SetTextRenderMode();

256 void Handle_SetWordSpace();	283 void Handle_SetTextRise();

257 void Handle_SetHorzScale();	284 void Handle_SetWordSpace();

258 void Handle_MoveToNextLine();	285 void Handle_SetHorzScale();

259 void Handle_CurveTo_23();	286 void Handle_MoveToNextLine();

260 void Handle_SetLineWidth();	287 void Handle_CurveTo_23();

261 void Handle_Clip();	288 void Handle_SetLineWidth();

262 void Handle_EOClip();	289 void Handle_Clip();

263 void Handle_CurveTo_13();	290 void Handle_EOClip();

264 void Handle_NextLineShowText();	291 void Handle_CurveTo_13();

265 void Handle_NextLineShowText_Space();	292 void Handle_NextLineShowText();

266 void Handle_Invalid();	293 void Handle_NextLineShowText_Space();

267	294 void Handle_Invalid();

268 CPDF_Document* const m_pDocument;	295

269 CPDF_Dictionary* m_pPageResources;	296 CPDF_Document* const m_pDocument;

270 CPDF_Dictionary* m_pParentResources;	297 CPDF_Dictionary* m_pPageResources;

271 CPDF_Dictionary* m_pResources;	298 CPDF_Dictionary* m_pParentResources;

272 CPDF_PageObjects* m_pObjectList;	299 CPDF_Dictionary* m_pResources;

273 int m_Level;	300 CPDF_PageObjects* m_pObjectList;

274 CFX_AffineMatrix m_mtContentToUser;	301 int m_Level;

275 CFX_FloatRect m_BBox;	302 CFX_AffineMatrix m_mtContentToUser;

276 CPDF_ParseOptions m_Options;	303 CFX_FloatRect m_BBox;

277 _ContentParam m_ParamBuf1[PARAM_BUF_SIZE];	304 CPDF_ParseOptions m_Options;

278 FX_DWORD m_ParamStartPos;	305 _ContentParam m_ParamBuf1[PARAM_BUF_SIZE];

279 FX_DWORD m_ParamCount;	306 FX_DWORD m_ParamStartPos;

280 FX_BOOL m_bAbort;	307 FX_DWORD m_ParamCount;

281 CPDF_StreamParser* m_pSyntax;	308 FX_BOOL m_bAbort;

282 nonstd::unique_ptr<CPDF_AllStates> m_pCurStates;	309 CPDF_StreamParser* m_pSyntax;

283 CPDF_ContentMark m_CurContentMark;	310 nonstd::unique_ptr<CPDF_AllStates> m_pCurStates;

284 CFX_PtrArray m_ClipTextList;	311 CPDF_ContentMark m_CurContentMark;

285 CPDF_TextObject* m_pLastTextObject;	312 CFX_PtrArray m_ClipTextList;

286 FX_FLOAT m_DefFontSize;	313 CPDF_TextObject* m_pLastTextObject;

287 int m_CompatCount;	314 FX_FLOAT m_DefFontSize;

288 FX_PATHPOINT* m_pPathPoints;	315 int m_CompatCount;

289 int m_PathPointCount;	316 FX_PATHPOINT* m_pPathPoints;

290 int m_PathAllocSize;	317 int m_PathPointCount;

291 FX_FLOAT m_PathStartX;	318 int m_PathAllocSize;

292 FX_FLOAT m_PathStartY;	319 FX_FLOAT m_PathStartX;

293 FX_FLOAT m_PathCurrentX;	320 FX_FLOAT m_PathStartY;

294 FX_FLOAT m_PathCurrentY;	321 FX_FLOAT m_PathCurrentX;

295 int m_PathClipType;	322 FX_FLOAT m_PathCurrentY;

296 CFX_ByteString m_LastImageName;	323 int m_PathClipType;

297 CPDF_Image* m_pLastImage;	324 CFX_ByteString m_LastImageName;

298 CFX_BinaryBuf m_LastImageDict;	325 CPDF_Image* m_pLastImage;

299 CFX_BinaryBuf m_LastImageData;	326 CFX_BinaryBuf m_LastImageDict;

300 CPDF_Dictionary* m_pLastImageDict;	327 CFX_BinaryBuf m_LastImageData;

301 CPDF_Dictionary* m_pLastCloneImageDict;	328 CPDF_Dictionary* m_pLastImageDict;

302 FX_BOOL m_bReleaseLastDict;	329 CPDF_Dictionary* m_pLastCloneImageDict;

303 FX_BOOL m_bSameLastDict;	330 FX_BOOL m_bReleaseLastDict;

304 FX_BOOL m_bColored;	331 FX_BOOL m_bSameLastDict;

305 FX_FLOAT m_Type3Data[6];	332 FX_BOOL m_bColored;

306 FX_BOOL m_bResourceMissing;	333 FX_FLOAT m_Type3Data[6];

307 CFX_PtrArray m_StateStack;	334 FX_BOOL m_bResourceMissing;

308 };	335 CFX_PtrArray m_StateStack;

309 class CPDF_ContentParser	336 };

310 {	337 class CPDF_ContentParser {

311 public:	338 public:

312 enum ParseStatus {	339 enum ParseStatus { Ready, ToBeContinued, Done };

313 Ready,	340

314 ToBeContinued,	341 CPDF_ContentParser();

315 Done	342 ~CPDF_ContentParser();

316 };	343

317	344 ParseStatus GetStatus() { return m_Status; }

318 CPDF_ContentParser();	345 void Start(CPDF_Page* pPage, CPDF_ParseOptions* pOptions);

319 ~CPDF_ContentParser();	346 void Start(CPDF_Form* pForm,

320	347 CPDF_AllStates* pGraphicStates,

321 ParseStatus GetStatus()	348 CFX_AffineMatrix* pParentMatrix,

322 {	349 CPDF_Type3Char* pType3Char,

323 return m_Status;	350 CPDF_ParseOptions* pOptions,

324 }	351 int level);

325 void Start(CPDF_Page* pPage, CPDF_ParseOption s* pOptions);	352 void Continue(IFX_Pause* pPause);

326 void Start(CPDF_Form* pForm, CPDF_AllStates* pGraphicStates, CFX_AffineMatrix* pParentMatrix,	353

327 CPDF_Type3Char* pType3Char, CPDF_ParseOptions* pOp tions, int level);	354 protected:

328 void Continue(IFX_Pause* pPause);	355 void Clear();

329	356 ParseStatus m_Status;

330 protected:	357 CPDF_PageObjects* m_pObjects;

331 void Clear();	358 FX_BOOL m_bForm;

332 ParseStatus m_Status;	359 CPDF_ParseOptions m_Options;

333 CPDF_PageObjects* m_pObjects;	360 CPDF_Type3Char* m_pType3Char;

334 FX_BOOL m_bForm;	361 int m_InternalStage;

335 CPDF_ParseOptions m_Options;	362 CPDF_StreamAcc* m_pSingleStream;

336 CPDF_Type3Char* m_pType3Char;	363 CPDF_StreamAcc** m_pStreamArray;

337 int m_InternalStage;	364 FX_DWORD m_nStreams;

338 CPDF_StreamAcc* m_pSingleStream;	365 uint8_t* m_pData;

339 CPDF_StreamAcc** m_pStreamArray;	366 FX_DWORD m_Size;

340 FX_DWORD m_nStreams;	367 class CPDF_StreamContentParser* m_pParser;

341 uint8_t* m_pData;	368 FX_DWORD m_CurrentOffset;

342 FX_DWORD m_Size;	369 CPDF_StreamFilter* m_pStreamFilter;

343 class CPDF_StreamContentParser* m_pParser;	370 };

344 FX_DWORD m_CurrentOffset;	371 class CPDF_AllStates : public CPDF_GraphicStates {

345 CPDF_StreamFilter* m_pStreamFilter;	372 public:

346 };	373 CPDF_AllStates();

347 class CPDF_AllStates : public CPDF_GraphicStates	374 ~CPDF_AllStates();

348 {	375 void Copy(const CPDF_AllStates& src);

349 public:	376 void ProcessExtGS(CPDF_Dictionary* pGS, CPDF_StreamContentParser* pParser);

350 CPDF_AllStates();	377 void SetLineDash(CPDF_Array*, FX_FLOAT, FX_FLOAT scale);

351 ~CPDF_AllStates();	378 CFX_AffineMatrix m_TextMatrix, m_CTM, m_ParentMatrix;

352 void Copy(const CPDF_AllStates& src);	379 FX_FLOAT m_TextX, m_TextY, m_TextLineX, m_TextLineY;

353 void ProcessExtGS(CPDF_Dictionary* pGS, CPDF_StreamContentParser* pPa rser);	380 FX_FLOAT m_TextLeading, m_TextRise, m_TextHorzScale;

354 void SetLineDash(CPDF_Array*, FX_FLOAT, FX_FLOAT scale);	381 };

355 CFX_AffineMatrix m_TextMatrix, m_CTM, m_ParentMatrix;	382

356 FX_FLOAT m_TextX, m_TextY, m_TextLineX, m_TextLin eY;	383 class CPDF_DocPageData {

357 FX_FLOAT m_TextLeading, m_TextRise, m_TextHorzSca le;	384 public:

358 };	385 explicit CPDF_DocPageData(CPDF_Document* pPDFDoc);

359	386 ~CPDF_DocPageData();

360 class CPDF_DocPageData	387

361 {	388 void Clear(FX_BOOL bRelease = FALSE);

362 public:	389 CPDF_Font* GetFont(CPDF_Dictionary* pFontDict, FX_BOOL findOnly);

363 explicit CPDF_DocPageData(CPDF_Document *pPDFDoc);	390 CPDF_Font* GetStandardFont(const CFX_ByteStringC& fontName,

364 ~CPDF_DocPageData();	391 CPDF_FontEncoding* pEncoding);

365	392 void ReleaseFont(CPDF_Dictionary* pFontDict);

366 void Clear(FX_BOOL bRelease = FALSE);	393 CPDF_ColorSpace* GetColorSpace(CPDF_Object* pCSObj,

367 CPDF_Font* GetFont(CPDF_Dictionary* pFontDict, FX_BOOL find Only);	394 CPDF_Dictionary* pResources);

368 CPDF_Font* GetStandardFont(const CFX_ByteStringC& fontName, CPDF_FontEncoding* pEncoding);	395 CPDF_ColorSpace* GetCopiedColorSpace(CPDF_Object* pCSObj);

369 void ReleaseFont(CPDF_Dictionary* pFontDict);	396 void ReleaseColorSpace(CPDF_Object* pColorSpace);

370 CPDF_ColorSpace* GetColorSpace(CPDF_Object* pCSObj, CPDF_Dictiona ry* pResources);	397 CPDF_Pattern* GetPattern(CPDF_Object* pPatternObj,

371 CPDF_ColorSpace* GetCopiedColorSpace(CPDF_Object* pCSObj);	398 FX_BOOL bShading,

372 void ReleaseColorSpace(CPDF_Object* pColorSpace);	399 const CFX_AffineMatrix* matrix);

373 CPDF_Pattern* GetPattern(CPDF_Object* pPatternObj, FX_BOOL bSh ading, const CFX_AffineMatrix* matrix);	400 void ReleasePattern(CPDF_Object* pPatternObj);

374 void ReleasePattern(CPDF_Object* pPatternObj);	401 CPDF_Image* GetImage(CPDF_Object* pImageStream);

375 CPDF_Image* GetImage(CPDF_Object* pImageStream);	402 void ReleaseImage(CPDF_Object* pImageStream);

376 void ReleaseImage(CPDF_Object* pImageStream);	403 CPDF_IccProfile* GetIccProfile(CPDF_Stream* pIccProfileStream);

377 CPDF_IccProfile* GetIccProfile(CPDF_Stream* pIccProfileStream);	404 void ReleaseIccProfile(CPDF_IccProfile* pIccProfile);

378 void ReleaseIccProfile(CPDF_IccProfile* pIccProfile);	405 CPDF_StreamAcc* GetFontFileStreamAcc(CPDF_Stream* pFontStream);

379 CPDF_StreamAcc* GetFontFileStreamAcc(CPDF_Stream* pFontStream);	406 void ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream,

380 void ReleaseFontFileStreamAcc(CPDF_Stream* pFontStrea m, FX_BOOL bForce = FALSE);	407 FX_BOOL bForce = FALSE);

381 FX_BOOL IsForceClear() const {return m_bForceClear;}	408 FX_BOOL IsForceClear() const { return m_bForceClear; }

382 CPDF_CountedColorSpace* FindColorSpacePtr(CPDF_Object* pCSObj) const;	409 CPDF_CountedColorSpace* FindColorSpacePtr(CPDF_Object* pCSObj) const;

383 CPDF_CountedPattern* FindPatternPtr(CPDF_Object* pPatternObj) const;	410 CPDF_CountedPattern* FindPatternPtr(CPDF_Object* pPatternObj) const;

384	411

385 private:	412 private:

386 using CPDF_CountedFont = CPDF_CountedObject<CPDF_Font>;	413 using CPDF_CountedFont = CPDF_CountedObject<CPDF_Font>;

387 using CPDF_CountedIccProfile = CPDF_CountedObject<CPDF_IccProfile>;	414 using CPDF_CountedIccProfile = CPDF_CountedObject<CPDF_IccProfile>;

388 using CPDF_CountedImage = CPDF_CountedObject<CPDF_Image>;	415 using CPDF_CountedImage = CPDF_CountedObject<CPDF_Image>;

389 using CPDF_CountedStreamAcc = CPDF_CountedObject<CPDF_StreamAcc>;	416 using CPDF_CountedStreamAcc = CPDF_CountedObject<CPDF_StreamAcc>;

390	417

391 using CPDF_ColorSpaceMap = std::map<CPDF_Object, CPDF_CountedColorSpace>;	418 using CPDF_ColorSpaceMap = std::map<CPDF_Object, CPDF_CountedColorSpace>;

392 using CPDF_FontFileMap = std::map<CPDF_Stream, CPDF_CountedStreamAcc>;	419 using CPDF_FontFileMap = std::map<CPDF_Stream, CPDF_CountedStreamAcc>;

393 using CPDF_FontMap = std::map<CPDF_Dictionary, CPDF_CountedFont>;	420 using CPDF_FontMap = std::map<CPDF_Dictionary, CPDF_CountedFont>;

394 using CPDF_IccProfileMap = std::map<CPDF_Stream, CPDF_CountedIccProfile>;	421 using CPDF_IccProfileMap = std::map<CPDF_Stream, CPDF_CountedIccProfile>;

395 using CPDF_ImageMap = std::map<FX_DWORD, CPDF_CountedImage*>;	422 using CPDF_ImageMap = std::map<FX_DWORD, CPDF_CountedImage*>;

396 using CPDF_PatternMap = std::map<CPDF_Object, CPDF_CountedPattern>;	423 using CPDF_PatternMap = std::map<CPDF_Object, CPDF_CountedPattern>;

397	424

398 CPDF_Document* const m_pPDFDoc;	425 CPDF_Document* const m_pPDFDoc;

399 CFX_MapByteStringToPtr m_HashProfileMap;	426 CFX_MapByteStringToPtr m_HashProfileMap;

400 FX_BOOL m_bForceClear;	427 FX_BOOL m_bForceClear;

401	428

402 CPDF_ColorSpaceMap m_ColorSpaceMap;	429 CPDF_ColorSpaceMap m_ColorSpaceMap;

403 CPDF_FontFileMap m_FontFileMap;	430 CPDF_FontFileMap m_FontFileMap;

404 CPDF_FontMap m_FontMap;	431 CPDF_FontMap m_FontMap;

405 CPDF_IccProfileMap m_IccProfileMap;	432 CPDF_IccProfileMap m_IccProfileMap;

406 CPDF_ImageMap m_ImageMap;	433 CPDF_ImageMap m_ImageMap;

407 CPDF_PatternMap m_PatternMap;	434 CPDF_PatternMap m_PatternMap;

408 };	435 };

409	436

410 class CPDF_Function	437 class CPDF_Function {

411 {	438 public:

412 public:	439 static CPDF_Function* Load(CPDF_Object* pFuncObj);

413 static CPDF_Function* Load(CPDF_Object* pFuncObj);	440 virtual ~CPDF_Function();

414 virtual ~CPDF_Function();	441 FX_BOOL Call(FX_FLOAT* inputs,

415 FX_BOOL Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, i nt& nresults) const;	442 int ninputs,

416 int CountInputs()	443 FX_FLOAT* results,

417 {	444 int& nresults) const;

418 return m_nInputs;	445 int CountInputs() { return m_nInputs; }

419 }	446 int CountOutputs() { return m_nOutputs; }

420 int CountOutputs()	447

421 {	448 protected:

422 return m_nOutputs;	449 CPDF_Function();

423 }	450 int m_nInputs, m_nOutputs;

424 protected:	451 FX_FLOAT* m_pDomains;

425 CPDF_Function();	452 FX_FLOAT* m_pRanges;

426 int m_nInputs, m_nOutputs;	453 FX_BOOL Init(CPDF_Object* pObj);

427 FX_FLOAT* m_pDomains;	454 virtual FX_BOOL v_Init(CPDF_Object* pObj) = 0;

428 FX_FLOAT* m_pRanges;	455 virtual FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const = 0;

429 FX_BOOL Init(CPDF_Object* pObj);	456 };

430 virtual FX_BOOL v_Init(CPDF_Object* pObj) = 0;	457 class CPDF_IccProfile {

431 virtual FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const = 0;	458 public:

432 };	459 CPDF_IccProfile(const uint8_t* pData, FX_DWORD dwSize);

433 class CPDF_IccProfile	460 ~CPDF_IccProfile();

434 {	461 int32_t GetComponents() const { return m_nSrcComponents; }

435 public:	462 FX_BOOL m_bsRGB;

436 CPDF_IccProfile(const uint8_t* pData, FX_DWORD dwSize);	463 void* m_pTransform;

437 ~CPDF_IccProfile();	464

438 int32_t GetComponents() const { return m_nSrcComponents; }	465 private:

439 FX_BOOL m_bsRGB;	466 int32_t m_nSrcComponents;

440 void* m_pTransform;	467 };

441 private:	468

442 int32_t m_nSrcComponents;	469 class CPDF_DeviceCS : public CPDF_ColorSpace {

443 };	470 public:

444	471 CPDF_DeviceCS(CPDF_Document* pDoc, int family);

445 class CPDF_DeviceCS : public CPDF_ColorSpace	472

446 {	473 FX_BOOL GetRGB(FX_FLOAT* pBuf,

447 public:	474 FX_FLOAT& R,

448 CPDF_DeviceCS(CPDF_Document* pDoc, int family);	475 FX_FLOAT& G,

449	476 FX_FLOAT& B) const override;

450 FX_BOOL GetRGB(FX_FLOAT* pBuf,	477 FX_BOOL SetRGB(FX_FLOAT* pBuf,

451 FX_FLOAT& R,	478 FX_FLOAT R,

452 FX_FLOAT& G,	479 FX_FLOAT G,

453 FX_FLOAT& B) const override;	480 FX_FLOAT B) const override;

454 FX_BOOL SetRGB(FX_FLOAT* pBuf,	481 FX_BOOL v_GetCMYK(FX_FLOAT* pBuf,

455 FX_FLOAT R,	482 FX_FLOAT& c,

456 FX_FLOAT G,	483 FX_FLOAT& m,

457 FX_FLOAT B) const override;	484 FX_FLOAT& y,

458 FX_BOOL v_GetCMYK(FX_FLOAT* pBuf,	485 FX_FLOAT& k) const override;

459 FX_FLOAT& c,	486 FX_BOOL v_SetCMYK(FX_FLOAT* pBuf,

460 FX_FLOAT& m,	487 FX_FLOAT c,

461 FX_FLOAT& y,	488 FX_FLOAT m,

462 FX_FLOAT& k) const override;	489 FX_FLOAT y,

463 FX_BOOL v_SetCMYK(FX_FLOAT* pBuf,	490 FX_FLOAT k) const override;

464 FX_FLOAT c,	491 void TranslateImageLine(uint8_t* pDestBuf,

465 FX_FLOAT m,	492 const uint8_t* pSrcBuf,

466 FX_FLOAT y,	493 int pixels,

467 FX_FLOAT k) const override;	494 int image_width,

468 void TranslateImageLine(uint8_t* pDestBuf,	495 int image_height,

469 const uint8_t* pSrcBuf,	496 FX_BOOL bTransMask = FALSE) const override;

470 int pixels,	497 };

471 int image_width,	498

472 int image_height,	499 class CPDF_PatternCS : public CPDF_ColorSpace {

473 FX_BOOL bTransMask = FALSE) const override;	500 public:

474 };	501 explicit CPDF_PatternCS(CPDF_Document* pDoc)

475	502 : CPDF_ColorSpace(pDoc, PDFCS_PATTERN, 1),

476 class CPDF_PatternCS : public CPDF_ColorSpace	503 m_pBaseCS(nullptr),

477 {	504 m_pCountedBaseCS(nullptr) {}

478 public:	505 ~CPDF_PatternCS() override;

479 explicit CPDF_PatternCS(CPDF_Document* pDoc)	506 FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;

480 : CPDF_ColorSpace(pDoc, PDFCS_PATTERN, 1),	507 FX_BOOL GetRGB(FX_FLOAT* pBuf,

481 m_pBaseCS(nullptr),	508 FX_FLOAT& R,

482 m_pCountedBaseCS(nullptr) {	509 FX_FLOAT& G,

483 }	510 FX_FLOAT& B) const override;

484 ~CPDF_PatternCS() override;	511 CPDF_ColorSpace* GetBaseCS() const override;

485 FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;	512

486 FX_BOOL GetRGB(FX_FLOAT* pBuf,	513 private:

487 FX_FLOAT& R,	514 CPDF_ColorSpace* m_pBaseCS;

488 FX_FLOAT& G,	515 CPDF_CountedColorSpace* m_pCountedBaseCS;

489 FX_FLOAT& B) const override;

490 CPDF_ColorSpace* GetBaseCS() const override;

491

492 private:

493 CPDF_ColorSpace* m_pBaseCS;

494 CPDF_CountedColorSpace* m_pCountedBaseCS;

495 };	516 };

496	517

497 #endif // CORE_SRC_FPDFAPI_FPDF_PAGE_PAGEINT_H_	518 #endif // CORE_SRC_FPDFAPI_FPDF_PAGE_PAGEINT_H_

OLD	NEW

« no previous file with comments | « core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp ('k') | core/src/fpdfapi/fpdf_parser/filters_int.h » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')