Merge to XFA: Kill CFX_Object.
[pdfium.git] / core / src / reflow / reflowedpage.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 _REFLOWED_PAGE_H
8 #define _REFLOWED_PAGE_H
9 #include "../../include/reflow/reflowengine.h"
10 #define GET_SIGNED(a) ( (a)>0 ? a/a : (a==0 ? 0 : -a/a) )
11 class CRF_Data;
12 class CRF_LineData;
13 class CRF_CharData;
14 class CRF_PathData;
15 class CRF_ImageData;
16 class CRF_Table;
17 class CRF_AttrOperation;
18 class CRF_OperationDate;
19 class CPDF_ReflowedPage;
20 class CPDF_Rect;
21 typedef CFX_SegmentedArray<CRF_Data*> CRF_DataPtrArray;
22 class CRF_CharState;
23 typedef CFX_SegmentedArray<CRF_CharState> CRF_CharStateArray;
24 #define SST_GE          1
25 #define SST_BLSE        2
26 #define SST_ILSE        3
27 #define SST_IE          4
28 class CPDF_LayoutProcessor_Reflow : public IPDF_LayoutProcessor
29 {
30 public:
31     CPDF_LayoutProcessor_Reflow();
32     ~CPDF_LayoutProcessor_Reflow();
33     void Init(FX_FLOAT TopIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, CPDF_ReflowedPage* pReflowedPage, int flags, FX_FLOAT lineSpace);
34
35     LayoutStatus        StartProcess(IPDF_LayoutElement* pElement, IFX_Pause* pPause, const CFX_AffineMatrix* pPDFMatrix = NULL);
36     LayoutStatus        Continue();
37     int                         GetPosition();
38 protected:
39     void        FitPageMode();
40     void        ProcessElement(IPDF_LayoutElement* pElement, FX_FLOAT reflowWidth);
41     FX_FLOAT GetElmWidth(IPDF_LayoutElement* pElement);
42     CFX_FloatRect GetElmBBox(IPDF_LayoutElement* pElement);
43     void        ProcessTable(FX_FLOAT dx);
44     void        ProcessObjs(IPDF_LayoutElement* pElement, FX_FLOAT reflowWidth);
45     void        ProcessObject(CPDF_PageObject* pObj, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix);
46     void        ProcessTextObject(CPDF_TextObject *pObj, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix);
47     void        ProcessPathObject(CPDF_PathObject *pObj, FX_FLOAT reflowWidth);
48     void        ProcessUnitaryObjs(CPDF_PageObjects *pObjs, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix);
49     FX_INT32 LogicPreObj(CPDF_TextObject* pObj);
50     int ProcessInsertObject(CPDF_TextObject* pObj, CFX_AffineMatrix formMatrix);
51     FX_WCHAR GetPreChar();
52     FX_BOOL IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2);
53     int GetCharWidth(FX_DWORD charCode, CPDF_Font* pFont) const;
54     FX_BOOL     IsCanBreakAfter(FX_DWORD unicode);
55     FX_BOOL     IsCanBreakBefore(FX_DWORD unicode);
56     FX_INT32 GetElementTypes(LayoutType layoutType);
57     void                                CreateRFData(CPDF_PageObject* pObj, CFX_AffineMatrix* pMatrix = NULL);
58     CRF_CharState*              GetCharState(CPDF_TextObject* pObj, CPDF_Font* pFont, FX_FLOAT fHeight, FX_ARGB color);
59     FX_FLOAT            ConverWidth(FX_FLOAT width);
60     void        AddData2CurrLine(CRF_Data* pData);
61     void        AddTemp2CurrLine(int begin, int count );
62     void        Transform(const CFX_AffineMatrix* pMatrix, CRF_Data* pData);
63     void        Transform(const CFX_AffineMatrix* pMatrix, CRF_DataPtrArray* pDataArray, int beginPos, int count = 0);
64     FX_FLOAT GetDatasWidth( int beginPos, int endpos);
65     void        UpdateCurrLine();
66     FX_BOOL     FinishedCurrLine();
67     int m_flags;
68     CFX_AffineMatrix m_PDFMatrix;
69     LayoutStatus        m_Status;
70     CPDF_TextObject* m_pPreObj;
71     CFX_AffineMatrix m_perMatrix;
72     IPDF_LayoutElement* m_pLayoutElement;
73     IPDF_LayoutElement* m_pRootElement;
74     FX_FLOAT            m_CurrRefWidth;
75     IFX_Pause*          m_pPause;
76     LayoutEnum          m_CurrWritingMode;
77     CPDF_ReflowedPage*  m_pReflowedPage;
78     FX_FLOAT            m_fRefWidth;
79     FX_FLOAT            m_TopIndent;
80     FX_FLOAT            m_fLineSpace;
81     FX_FLOAT            m_fScreenHeight;
82     FX_FLOAT            m_fCurrMaxWidth;
83     FX_FLOAT            m_fCurrLineWidth;
84     FX_FLOAT            m_fCurrLineHeight;
85     CRF_DataPtrArray*   m_pCurrLine;
86     CRF_DataPtrArray*   m_pTempLine;
87     FX_BOOL                     m_bIllustration;
88     FX_FLOAT            m_fLineHeight;
89     LayoutEnum          m_TextAlign;
90     FX_FLOAT            m_StartIndent;
91     CFX_ArrayTemplate<CRF_Table*> m_TableArray;
92     int                         m_PausePosition;
93 };
94 struct RF_TableCell {
95     int                 m_BeginPos;
96     int                 m_EndPos;
97     FX_FLOAT m_MaxWidth;
98     FX_FLOAT m_PosX;
99     FX_FLOAT    m_PosY;
100     FX_FLOAT    m_CellWidth;
101     FX_FLOAT m_CellHeight;
102     int                 m_RowSpan;
103     int                 m_ColSpan;
104     LayoutEnum  m_BlockAlign;
105     LayoutEnum  m_InlineAlign;
106 };
107 typedef CFX_ArrayTemplate<RF_TableCell*> CRF_TableCellArray;
108 class CRF_Table 
109 {
110 public:
111     CRF_Table()
112     {
113         m_TableWidth = 0;
114         m_nCol = 0;
115     }
116     CRF_TableCellArray  m_pCellArray;
117     CFX_WordArray               m_nCell;
118     int                                 m_nCol;
119     FX_FLOAT                    m_TableWidth;
120     FX_FLOAT                    m_ReflowPageHeight;
121 };
122 class CRF_CharState 
123 {
124 public:
125     CPDF_Font*  m_pFont;
126     FX_ARGB             m_Color;
127     FX_BOOL             m_bVert;
128     FX_FLOAT m_fFontSize;
129     FX_FLOAT m_fAscent;
130     FX_FLOAT m_fDescent;
131
132     CPDF_TextObject*    m_pTextObj;
133 };
134 class CRF_PageInfo 
135 {
136 public:
137     CRF_PageInfo(CPDF_PageObject* pPageObj, CRF_PageInfo* pParent = NULL)
138         : m_pPageObj(pPageObj) , m_pParent(pParent)
139     {
140     }
141     CPDF_PageObject* GetPageObj()
142     {
143         return m_pPageObj;
144     }
145     CPDF_Dictionary* GetFormDict()
146     {
147         if (NULL == m_pParent) {
148             return NULL;
149         }
150         CPDF_PageObject* pParentObj = m_pParent->GetPageObj();
151         if (NULL == pParentObj || PDFPAGE_FORM != pParentObj->m_Type) {
152             return NULL;
153         }
154         return ((CPDF_FormObject*)pParentObj)->m_pForm->m_pResources;
155     }
156 protected:
157     CPDF_PageObject*            m_pPageObj;
158     CRF_PageInfo*                       m_pParent;
159 };
160 class CPDF_ReflowedPage : public IPDF_ReflowedPage, public CFX_PrivateData
161 {
162 public:
163
164     CPDF_ReflowedPage(CFX_GrowOnlyPool* pMemoryPool);
165     ~CPDF_ReflowedPage();
166     CFX_PrivateData*    GetPrivateDataCtrl()
167     {
168         return this;
169     };
170     void                GetDisplayMatrix(CFX_AffineMatrix& matrix, FX_INT32 xPos, FX_INT32 yPos, FX_INT32 xSize, FX_INT32 ySize, FX_INT32 iRotate, const CFX_AffineMatrix* pPageMatrix);
171
172     FX_FLOAT    GetPageHeight() ;
173     FX_FLOAT    GetPageWidth()
174     {
175         return m_PageWidth;
176     };
177     void                FocusGetData(const CFX_AffineMatrix matrix, FX_INT32 x, FX_INT32 y, CFX_ByteString& str);
178     FX_BOOL             FocusGetPosition(const CFX_AffineMatrix matrix, CFX_ByteString str, FX_INT32& x, FX_INT32& y);
179     CRF_DataPtrArray*   m_pReflowed;
180     FX_FLOAT                    m_PageWidth;
181     FX_FLOAT                    m_PageHeight;
182     FX_BOOL                             m_bWaiting;
183     CRF_CharStateArray* m_pCharState;
184     CFX_GrowOnlyPool*   m_pMemoryPool;
185     FX_BOOL                             m_bCreateMemoryPool;
186     CPDF_Page*                  m_pPDFPage;
187     FX_BOOL                                     RetainPageObjsMemberShip();
188     void                                        MarkPageObjMemberShip(CPDF_PageObject* pObj, CRF_PageInfo* pParent);
189     void                                        ReleasePageObjsMemberShip();
190     CPDF_Dictionary*            GetFormResDict(CPDF_PageObject* pObj);
191
192     CFX_MapPtrToPtr*            m_pPageInfos;
193 };
194 class CPDF_ProgressiveReflowPageParser : public IPDF_ProgressiveReflowPageParser
195 {
196 public:
197     CPDF_ProgressiveReflowPageParser();
198     ~CPDF_ProgressiveReflowPageParser() ;
199     void                        Init();
200
201     ParseStatus         GetStatus()
202     {
203         return m_Status;
204     };
205
206     void                        SetParserStyle(RF_ParseStyle style)
207     {
208         m_ParseStyle = style;
209     };
210     void                        Start(IPDF_ReflowedPage* pReflowPage, CPDF_Page* pPage, FX_FLOAT TopIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, IFX_Pause* pPause, int flags);
211     void                        Continue(IFX_Pause* pPause);
212     int                         GetPosition() ;
213
214     void                        Clear();
215     ParseStatus         m_Status;
216 protected:
217     RF_ParseStyle               m_ParseStyle;
218     CPDF_Page*                  m_pPDFPage;
219     IFX_Pause*                  m_pPause;
220     CPDF_ReflowedPage*  m_pReflowPage;
221     FX_FLOAT                    m_TopIndent;
222     FX_FLOAT                    m_ReflowedWidth;
223     FX_FLOAT                    m_fScreenHeight;
224     IPDF_LayoutProvider*        m_pProvider;
225     IPDF_LayoutProcessor*       m_pReflowEngine;
226     int                                 m_nObjProcessed;
227     int m_flags;
228 };
229 class CPDF_ProgressiveReflowPageRender : public IPDF_ProgressiveReflowPageRender
230 {
231 public:
232     CPDF_ProgressiveReflowPageRender();
233     ~CPDF_ProgressiveReflowPageRender() ;
234
235     RenderStatus                        GetStatus()
236     {
237         return m_Status;
238     };
239
240
241     void                SetDisplayColor(FX_COLORREF color);
242     void                Start(IPDF_ReflowedPage* pReflowPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pMatrix, IFX_Pause* pPause, int DitherBits);
243     void                Continue(IFX_Pause* pPause);
244     int                 GetPosition();
245
246
247     void                                Clear();
248 protected:
249     void                                Display(IFX_Pause* pPause);
250     RenderStatus m_Status;
251     CPDF_ReflowedPage*  m_pReflowPage;
252     CFX_AffineMatrix*   m_pDisplayMatrix;
253     int                                 m_CurrNum;
254     IFX_FontEncoding*   m_pFontEncoding;
255     CFX_RenderDevice*   m_pFXDevice;
256     int                                 m_DitherBits;
257     FX_COLORREF                 m_DisplayColor;
258     typedef struct CRF_TextDataAtt {
259         CRF_TextDataAtt()
260         {
261             pFont = NULL;
262             fFontSize = 0.0f;
263             Color = 0;
264         }
265         CRF_TextDataAtt(CPDF_Font* font, FX_FLOAT fontSize, FX_ARGB color)
266         {
267             pFont = font;
268             fFontSize = fontSize;
269             Color = color;
270         }
271         CPDF_Font*  pFont;
272         FX_FLOAT    fFontSize;
273         FX_ARGB         Color;
274     } CRF_TEXTDATAATT;
275     inline bool isTextDataAttSame(CRF_TEXTDATAATT data1, CRF_TEXTDATAATT data2)
276     {
277         if (data1.pFont != data2.pFont) {
278             return false;
279         }
280         if (data1.Color != data2.Color) {
281             return false;
282         }
283         if (fabs(data1.fFontSize - data2.fFontSize) > 0.0f) {
284             return false;
285         }
286         return true;
287     };
288 };
289 #define TYPE_UNKNOW             0
290 #define TYPE_TEXT               1
291 #define TYPE_PATH               2
292 #define TYPE_IMAGE              3
293 #define TYPE_LINE               4
294 class CRF_Data 
295 {
296 public:
297     typedef enum {Unknow, Text, Image, Path, Line, paragraph} RF_DataType;
298     CRF_Data()
299     {
300         m_Type = Unknow;
301         m_Width = 0;
302         m_PosY = 0;
303         m_PosX = 0;
304         m_Height = 0;
305     }
306     RF_DataType GetType()
307     {
308         return m_Type;
309     }
310     virtual             ~CRF_Data() {}
311     RF_DataType         m_Type;
312     FX_FLOAT    m_PosX;
313     FX_FLOAT    m_PosY;
314     FX_FLOAT    m_Width;
315     FX_FLOAT    m_Height;
316 };
317 class CRF_LineData : public CRF_Data
318 {
319 public:
320     CRF_LineData()
321     {
322         m_Type = Line;
323     }
324 };
325 class CRF_CharData : public CRF_Data
326 {
327 public:
328     CRF_CharData()
329     {
330         m_Type = Text;
331         m_CharCode = -1;
332     }
333     CRF_CharState*      m_pCharState;
334     FX_DWORD            m_CharCode;
335 };
336 class CRF_ImageData : public CRF_Data
337 {
338 public:
339     CRF_ImageData()
340     {
341         m_Type = Image;
342         m_pBitmap = NULL;
343     }
344     ~CRF_ImageData()
345     {
346         if(m_pBitmap) {
347             delete m_pBitmap;
348         }
349         m_pBitmap = NULL;
350     }
351     CFX_AffineMatrix m_Matrix;
352     CFX_DIBitmap*       m_pBitmap;
353 };
354 class CRF_PathData : public CRF_Data
355 {
356 public:
357     CRF_PathData()
358     {
359         m_Type = Path;
360         m_bDecoration = FALSE;
361     }
362     ~CRF_PathData() {};
363     FX_BOOL                     m_bDecoration;
364     CPDF_Path                   m_pPathData;
365     CFX_AffineMatrix    m_pPath2Device;
366     CPDF_GraphState             m_pGraphState;
367     FX_ARGB             m_fill_argb;
368     FX_ARGB             m_stroke_argb;
369     int                 m_fill_mode;
370 };
371 #endif