Initial commit.

10 files changed, 4830 insertions, 0 deletions

diff --git a/core/src/reflow/autoreflow.cpp b/core/src/reflow/autoreflow.cpp
new file mode 100644
index 0000000000..8c37960932
--- /dev/null
+++ b/core/src/reflow/autoreflow.cpp
@@ -0,0 +1,781 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "autoreflow.h"
+#define approachto(a,b,c) (FXSYS_fabs((float)((a)-(b)))>(c) ? 0 : 1)
+int FPDF_ProcessInterObj(const CPDF_PageObject* pPrevObj, const CPDF_PageObject* pObj)
+{
+    CFX_AffineMatrix matrix;
+    FX_RECT PreRect = pPrevObj->GetBBox(&matrix);
+    FX_RECT rect = pObj->GetBBox(&matrix);
+    int flag = 0;
+    if(PreRect.top > rect.bottom) {
+        flag = 0;
+    } else if(rect.top > PreRect.bottom) {
+        flag = 1;
+    } else if(PreRect.right < rect.left) {
+        flag = 0;
+    } else if(PreRect.left > rect.right) {
+        flag = 1;
+    } else if(pObj->m_Type != PDFPAGE_TEXT) {
+        flag = 1;
+    } else if(pPrevObj->m_Type != PDFPAGE_TEXT) {
+        flag = 0;
+    } else {
+        if((PreRect.top < rect.top && PreRect.bottom > rect.bottom) ||
+                (PreRect.top > rect.top && PreRect.bottom < rect.bottom)) {
+            if(PreRect.left > rect.left) {
+                flag = 1;
+            } else {
+                flag = 0;
+            }
+        } else {
+            CPDF_TextObject* pPrevTextObj = (CPDF_TextObject* )pPrevObj;
+            CPDF_TextObject* pTextObj = (CPDF_TextObject* )pObj;
+            CPDF_TextObjectItem item, prevItem;
+            pPrevTextObj->GetItemInfo(0, &prevItem);
+            pTextObj->GetItemInfo(0, &item);
+            CFX_AffineMatrix TextMatrix;
+            pTextObj->GetTextMatrix(&TextMatrix);
+            FX_FLOAT originX, originY, prevOriginX, preOriginY;
+            TextMatrix.Transform(item.m_OriginX, item.m_OriginY, originX, originY);
+            pPrevTextObj->GetTextMatrix(&TextMatrix);
+            TextMatrix.Transform(prevItem.m_OriginX, prevItem.m_OriginY, prevOriginX, preOriginY);
+            if(preOriginY > originY) {
+                flag = 0;
+            } else {
+                flag = 1;
+            }
+        }
+    }
+    return flag;
+}
+void CPDF_AutoReflowLayoutProvider::Conver2AppreceOrder(const CPDF_PageObjects* pStreamOrderObjs, CPDF_PageObjects* pAppraceOrderObjs)
+{
+    FX_POSITION pos = pStreamOrderObjs->GetFirstObjectPosition();
+    CFX_AffineMatrix matrix;
+    while(pos) {
+        CPDF_PageObject* pObj = pStreamOrderObjs->GetNextObject(pos);
+        CFX_AffineMatrix matrix;
+        if(pObj->m_Type != PDFPAGE_TEXT) {
+            continue;
+        }
+        FX_POSITION pos1 = pAppraceOrderObjs->GetLastObjectPosition();
+        while(pos1) {
+            CPDF_PageObject* pTempObj = pAppraceOrderObjs->GetPrevObject(pos1);
+            if(FPDF_ProcessInterObj(pObj, pTempObj) == 1) {
+                if(!pos1) {
+                    pos1 = pAppraceOrderObjs->GetFirstObjectPosition();
+                } else {
+                    pAppraceOrderObjs->GetNextObject(pos1);
+                }
+                break;
+            }
+        }
+        pAppraceOrderObjs->InsertObject(pos1, pObj);
+    }
+    pos = pStreamOrderObjs->GetFirstObjectPosition();
+    while(pos) {
+        CPDF_PageObject* pObj = pStreamOrderObjs->GetNextObject(pos);
+        if(pObj->m_Type != PDFPAGE_IMAGE) {
+            continue;
+        }
+        FX_POSITION pos1 = pAppraceOrderObjs->GetLastObjectPosition();
+        while(pos1) {
+            CPDF_PageObject* pTempObj = pAppraceOrderObjs->GetPrevObject(pos1);
+            if(FPDF_ProcessInterObj(pObj, pTempObj) == 1) {
+                if(!pos1) {
+                    pos1 = pAppraceOrderObjs->GetFirstObjectPosition();
+                } else {
+                    pAppraceOrderObjs->GetNextObject(pos1);
+                }
+                break;
+            }
+        }
+        pAppraceOrderObjs->InsertObject(pos1, pObj);
+    }
+}
+IPDF_LayoutProvider* IPDF_LayoutProvider::Create_LayoutProvider_AutoReflow(CPDF_PageObjects* pPage, FX_BOOL bReadOrder)
+{
+    return FX_NEW CPDF_AutoReflowLayoutProvider(pPage, bReadOrder);
+}
+CPDF_AutoReflowElement::CPDF_AutoReflowElement(LayoutType layoutType , CPDF_AutoReflowElement* pParent)
+{
+    m_ElmType = layoutType;
+    m_pParentElm = pParent;
+    if(pParent) {
+        pParent->m_ChildArray.Add(this);
+    }
+    m_SpaceBefore = 0;
+}
+CPDF_AutoReflowElement::~CPDF_AutoReflowElement()
+{
+    m_ChildArray.RemoveAll();
+    m_ObjArray.RemoveAll();
+}
+int	CPDF_AutoReflowElement::CountAttrValues(LayoutAttr attr_type)
+{
+    return 1;
+}
+LayoutEnum CPDF_AutoReflowElement::GetEnumAttr(LayoutAttr attr_type, int index )
+{
+    return LayoutInvalid;
+}
+FX_FLOAT	CPDF_AutoReflowElement::GetNumberAttr(LayoutAttr attr_type, int index )
+{
+    switch (attr_type) {
+        case LayoutSpaceBefore:
+            return m_SpaceBefore;
+        default:
+            return 0;
+    }
+}
+FX_COLORREF	CPDF_AutoReflowElement::GetColorAttr(LayoutAttr attr_type, int index )
+{
+    return 0;
+}
+#define WritingMode_UNKNOW	0
+#define WritingMode_LRTB	1
+#define WritingMode_RLTB	2
+#define WritingMode_TBRL	3
+CPDF_AutoReflowLayoutProvider::CPDF_AutoReflowLayoutProvider(CPDF_PageObjects* pPage, FX_BOOL bReadOrder)
+{
+    m_pPDFPage = (CPDF_Page*)pPage;
+    FX_FLOAT width = m_pPDFPage->GetPageWidth();
+    FX_FLOAT height = m_pPDFPage->GetPageHeight();
+    m_pPDFPage->GetDisplayMatrix(m_PDFDisplayMatrix, 0, 0, (int)(m_pPDFPage->GetPageWidth()), (int)(m_pPDFPage->GetPageHeight()), 0);
+    m_bReadOrder = bReadOrder;
+    m_Status = LayoutReady;
+    m_pRoot = NULL;
+    m_pCurrElm = NULL;
+    m_pPreObj = NULL;
+    m_Step = 0;
+    m_WritingMode = WritingMode_UNKNOW;
+}
+CPDF_AutoReflowLayoutProvider::~CPDF_AutoReflowLayoutProvider()
+{
+    m_pPDFPage = NULL;
+    ReleaseElm(m_pRoot);
+}
+void CPDF_AutoReflowLayoutProvider::ReleaseElm(CPDF_AutoReflowElement*& pElm, FX_BOOL bReleaseChildren)
+{
+    if(bReleaseChildren) {
+        int count = pElm->CountChildren();
+        for(int i = 0; i < count; i++) {
+            CPDF_AutoReflowElement* pChild = (CPDF_AutoReflowElement*)pElm->GetChild(i);
+            ReleaseElm(pChild);
+        }
+    }
+    delete pElm;
+    pElm = NULL;
+}
+void CPDF_AutoReflowLayoutProvider::AddObjectArray(CPDF_AutoReflowElement* pElm, CFX_PtrList& ObjList)
+{
+    if(!pElm) {
+        return;
+    }
+    FX_POSITION pos = ObjList.GetHeadPosition();
+    while (pos) {
+        pElm->m_ObjArray.Add((CPDF_PageObject*)ObjList.GetNext(pos));
+    }
+}
+void CPDF_AutoReflowLayoutProvider::GenerateStructTree()
+{
+    if (m_Step < AUTOREFLOW_STEP_GENERATELINE) {
+        GenerateLine(m_cellArray);
+        if(m_cellArray.GetSize() == 0) {
+            m_Status = LayoutError;
+            return;
+        }
+        if(m_pPause && m_pPause->NeedToPauseNow()) {
+            m_Step = AUTOREFLOW_STEP_GENERATELINE;
+            m_Status = LayoutToBeContinued;
+            return;
+        }
+    }
+    if (m_Step < AUTOREFLOW_STEP_GENERATEParagraph) {
+        GenerateParagraph(m_cellArray);
+        if(m_pPause && m_pPause->NeedToPauseNow()) {
+            m_Step = AUTOREFLOW_STEP_GENERATEParagraph;
+            m_Status = LayoutToBeContinued;
+            return;
+        }
+    }
+    if (m_Step < AUTOREFLOW_STEP_CREATEELEMENT) {
+        CreateElement();
+        if(m_pPause && m_pPause->NeedToPauseNow()) {
+            m_Step = AUTOREFLOW_STEP_CREATEELEMENT;
+            m_Status = LayoutToBeContinued;
+            return;
+        }
+    }
+    if (m_Step < AUTOREFLOW_STEP_REMOVEDATA) {
+        int count = m_cellArray.GetSize();
+        for(int i = 0; i < count; i++) {
+            CRF_CELL* pCell = (CRF_CELL*)m_cellArray.GetAt(i);
+            if(pCell) {
+                pCell->m_ObjList.RemoveAll();
+                delete pCell;
+            }
+        }
+        m_cellArray.RemoveAll();
+        if(m_pPause && m_pPause->NeedToPauseNow()) {
+            m_Step = AUTOREFLOW_STEP_REMOVEDATA;
+            m_Status = LayoutToBeContinued;
+            return;
+        }
+    }
+    m_Step = AUTOREFLOW_STEP_REMOVEDATA;
+    m_Status = LayoutFinished;
+    return;
+}
+void CPDF_AutoReflowLayoutProvider::CreateElement()
+{
+    int count = m_cellArray.GetSize();
+    CRF_CELL* plastCell = NULL;
+    CRF_CELL* pCell = NULL;
+    CRF_CELL* pNextCell = NULL;
+    CPDF_AutoReflowElement* pParent = m_pRoot;
+    CPDF_AutoReflowElement* pCurrElm = NULL;
+    int i;
+    for(i = 0; i < count; i++) {
+        pCell = (CRF_CELL*)m_cellArray.GetAt(i);
+        if(!pCell) {
+            continue;
+        }
+        if(i < count - 1) {
+            pNextCell = (CRF_CELL*)m_cellArray.GetAt(i + 1);
+        } else {
+            pNextCell = NULL;
+        }
+        pCurrElm = NULL;
+        pCurrElm = FX_NEW CPDF_AutoReflowElement(LayoutParagraph, pParent);
+        if(pCurrElm->GetType() == LayoutParagraph && plastCell) {
+            int SpaceBefore = 0;
+            if(pCell->m_CellWritingMode != plastCell->m_CellWritingMode ) {
+                SpaceBefore = 20;
+            } else if(pCell->m_CellWritingMode == WritingMode_LRTB) {
+                SpaceBefore = plastCell->m_BBox.bottom - pCell->m_BBox.top;
+            } else if(pCell->m_CellWritingMode == WritingMode_TBRL) {
+                SpaceBefore = plastCell->m_BBox.left - pCell->m_BBox.right;
+            }
+            if(SpaceBefore > 0) {
+                pCurrElm->m_SpaceBefore = SpaceBefore > 50 ? 50.0f : SpaceBefore;
+            }
+        }
+        AddObjectArray(pCurrElm, pCell->m_ObjList);
+        plastCell = pCell;
+    }
+}
+void CPDF_AutoReflowLayoutProvider::GenerateParagraph(CFX_PtrArray& cellArray)
+{
+    int count = cellArray.GetSize();
+    if(count <= 1) {
+        return;
+    }
+    CRF_CELL* plastCell = (CRF_CELL*)cellArray.GetAt(0);
+    if(plastCell->m_BBox.Height() > plastCell->m_BBox.Width()) {
+        m_WritingMode = WritingMode_TBRL;
+    } else {
+        m_WritingMode = WritingMode_LRTB;
+    }
+    FX_BOOL bEnforce = FALSE;
+    int i = 0;
+    for(i = 1; i < count; i++) {
+        CRF_CELL* pCell = (CRF_CELL*)cellArray.GetAt(i);
+        if(!pCell) {
+            continue;
+        }
+        int c = pCell->m_ObjList.GetCount();
+        FX_BOOL bMerge = FALSE;
+        FX_POSITION pos1 = plastCell->m_ObjList.GetTailPosition();
+        CPDF_PageObject* pLastObj = (CPDF_PageObject*)plastCell->m_ObjList.GetPrev(pos1);
+        pos1 = pCell->m_ObjList.GetHeadPosition();
+        CPDF_PageObject* pCurObj = (CPDF_PageObject*)pCell->m_ObjList.GetNext(pos1);
+        int WritingMode = GetRectEnd(pCell->m_BBox);
+        if(pCell->m_CellWritingMode == WritingMode_UNKNOW) {
+            if(pCell->m_BBox.Height() > pCell->m_BBox.Width()) {
+                pCell->m_CellWritingMode = WritingMode_TBRL;
+            } else {
+                pCell->m_CellWritingMode = WritingMode_LRTB;
+            }
+        }
+        WritingMode = pCell->m_CellWritingMode;
+        if(WritingMode == WritingMode_LRTB && (m_Style.m_Language & LP_Lang_ChinesePRC || m_Style.m_Language & LP_Lang_ChineseTaiwan
+                                               || m_Style.m_Language & LP_Lang_Japanese || m_Style.m_Language & LP_Lang_Korean)) {
+            if(pCurObj->m_Type == PDFPAGE_TEXT) {
+                CPDF_TextObject* pText;
+                pText = (CPDF_TextObject*)pCurObj;
+                if(pText->CountItems()) {
+                    CPDF_TextObjectItem item;
+                    pText->GetItemInfo(0, &item);
+                    CFX_WideString str = pText->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+                    FX_WCHAR unicode = str.GetAt(0);
+                    if(unicode == 32) {
+                        plastCell = pCell;
+                        bMerge = FALSE;
+                        bEnforce = FALSE;
+                        continue;
+                    }
+                }
+            }
+        }
+        if(m_WritingMode == WritingMode) {
+            if(bEnforce) {
+                bMerge = FALSE;
+                bEnforce = FALSE;
+                if(pCurObj->m_Type == PDFPAGE_TEXT) {
+                    CPDF_TextObject* pText;
+                    pText = (CPDF_TextObject*)pCurObj;
+                    if(pText->CountItems()) {
+                        CPDF_TextObjectItem item;
+                        pText->GetItemInfo(0, &item);
+                        CFX_WideString str = pText->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+                        FX_WCHAR unicode = str.GetAt(0);
+                        if(unicode > 96 && unicode < 123) {
+                            bMerge = TRUE;
+                        }
+                    }
+                } else {
+                    CPDF_ImageObject* pImage = (CPDF_ImageObject*)pCurObj;
+                    FX_RECT imageBBox = pImage->GetBBox(&m_PDFDisplayMatrix);
+                    if(GetRectEnd(plastCell->m_BBox) - GetRectEnd(pCell->m_BBox) < GetRectWidth(imageBBox)) {
+                        bMerge = TRUE;
+                    }
+                }
+            } else {
+                if(!approachto(GetRectStart(pCell->m_BBox), GetRectStart(plastCell->m_BBox), GetRectHeight(pCell->m_BBox) / 4)) {
+                    if(approachto(GetRectStart(plastCell->m_BBox), GetRectStart(pCell->m_BBox), GetRectHeight(pCell->m_BBox) * 2.3) &&
+                            GetRectStart(plastCell->m_BBox) - GetRectStart(pCell->m_BBox) > 0) {
+                        if(pCurObj->m_Type == PDFPAGE_TEXT || pLastObj->m_Type == PDFPAGE_TEXT) {
+                            CPDF_TextObject* pText;
+                            if(pCurObj->m_Type == PDFPAGE_TEXT) {
+                                pText = (CPDF_TextObject*)pCurObj;
+                            } else {
+                                pText = (CPDF_TextObject*)pLastObj;
+                            }
+                            CPDF_TextObjectItem item;
+                            pText->GetItemInfo(0, &item);
+                            CFX_WideString str = pText->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+                            FX_WCHAR unicode = str.GetAt(0);
+                            if(unicode > 255) {
+                                bMerge = TRUE;
+                            }
+                        }
+                    }
+                } else if(!approachto(GetRectEnd(pCell->m_BBox), GetRectEnd(plastCell->m_BBox), GetRectHeight(pCell->m_BBox) * 3)) {
+                    FX_RECT rect = pLastObj->GetBBox(&m_PDFDisplayMatrix);
+                    if(approachto(GetRectStart(pCell->m_BBox), GetRectStart(plastCell->m_BBox), GetRectHeight(pCell->m_BBox) / 4)) {
+                        if(GetRectEnd(rect) - GetRectEnd(pCell->m_BBox) > 0) {
+                            bMerge = TRUE;
+                            bEnforce = TRUE;
+                        } else if(GetRectEnd(rect) - GetRectEnd(pCell->m_BBox) <= 0 &&
+                                  GetRectEnd(rect) - GetRectEnd(pCell->m_BBox) > GetRectHeight(pCell->m_BBox) * -3) {
+                            if(pCurObj->m_Type == PDFPAGE_TEXT) {
+                                CPDF_TextObject* pText = (CPDF_TextObject*)pCurObj;
+                                CPDF_TextObjectItem item;
+                                pText->GetItemInfo(0, &item);
+                                CFX_WideString str = pText->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+                                FX_WCHAR unicode = str.GetAt(0);
+                                if(unicode > 96 && unicode < 123) {
+                                    bMerge = TRUE;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    bMerge = TRUE;
+                }
+            }
+        } else {
+            m_WritingMode = WritingMode;
+            bEnforce = FALSE;
+        }
+        if(bMerge) {
+            if(GetRectEnd(plastCell->m_BBox) - GetRectEnd(pCell->m_BBox) > 30) {
+                bEnforce = TRUE;
+            }
+            FX_POSITION pos = pCell->m_ObjList.GetHeadPosition();
+            while(pos) {
+                plastCell->m_ObjList.AddTail(pCell->m_ObjList.GetNext(pos));
+            }
+            plastCell->m_BBox.Union(pCell->m_BBox);
+            pCell->m_ObjList.RemoveAll();
+            delete pCell;
+            cellArray.RemoveAt(i);
+            i--;
+            count--;
+        } else {
+            plastCell = pCell;
+        }
+    }
+}
+void CPDF_AutoReflowLayoutProvider::ProcessObj(CFX_PtrArray& cellArray, CPDF_PageObject* pObj, CFX_AffineMatrix matrix)
+{
+}
+FX_INT32 CPDF_AutoReflowLayoutProvider::LogicPreObj(CPDF_PageObject* pObj)
+{
+    CPDF_PageObject* pPreObj = m_pPreObj;
+    m_pPreObj = pObj;
+    if(!pPreObj) {
+        return 0;
+    }
+    if(pPreObj->m_Type != pObj->m_Type) {
+        return 0;
+    }
+    CFX_FloatRect rcCurObj(pObj->m_Left, pObj->m_Bottom, pObj->m_Right, pObj->m_Top);
+    CFX_FloatRect rcPreObj(pPreObj->m_Left, pPreObj->m_Bottom, pPreObj->m_Right, pPreObj->m_Top);
+    if(pObj->m_Type == PDFPAGE_IMAGE) {
+        if(rcPreObj.Contains(rcCurObj)) {
+            return 2;
+        }
+        if(rcCurObj.Contains(rcPreObj)) {
+            return 2;
+        }
+        return 0;
+    }
+    if(pObj->m_Type == PDFPAGE_TEXT) {
+        if(!((rcPreObj.bottom > rcCurObj.top) || (rcPreObj.top < rcCurObj.bottom))) {
+            FX_FLOAT height = FX_MIN(rcPreObj.Height(), rcCurObj.Height());
+            if((rcCurObj.left - rcPreObj.right) > height / 3) {
+                return 3;
+            }
+        }
+        if(FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) >= 2 || FXSYS_fabs(rcPreObj.Height() - rcCurObj.Height()) >= 2 ) {
+            return 0;
+        }
+        CPDF_TextObject* pPreTextObj = (CPDF_TextObject*)pPreObj;
+        CPDF_TextObject* pCurTextObj = (CPDF_TextObject*)pObj;
+        int nPreCount = pPreTextObj->CountItems();
+        int nCurCount = pCurTextObj->CountItems();
+        if (nPreCount != nCurCount) {
+            return 0;
+        }
+        FX_BOOL bSame = TRUE;
+        for (int i = 0; i < nPreCount; i++) {
+            CPDF_TextObjectItem itemPer, itemCur;
+            pPreTextObj->GetItemInfo(i, &itemPer);
+            pCurTextObj->GetItemInfo(i, &itemCur);
+            if (itemCur.m_CharCode != itemPer.m_CharCode) {
+                return 0;
+            }
+            if (itemCur.m_OriginX != itemPer.m_OriginX) {
+                bSame = FALSE;
+            }
+            if (itemCur.m_OriginY != itemPer.m_OriginY) {
+                bSame = FALSE;
+            }
+        }
+        if(rcPreObj.left == rcCurObj.left && rcPreObj.top == rcCurObj.top) {
+            return 1;
+        }
+        if(FXSYS_fabs(rcPreObj.left - rcCurObj.left) < rcPreObj.Width() / 3
+                && FXSYS_fabs(rcPreObj.top - rcCurObj.top) < rcPreObj.Height() / 3) {
+            return 2;
+        }
+    }
+    return 0;
+}
+void CPDF_AutoReflowLayoutProvider::GenerateLine(CFX_PtrArray& cellArray)
+{
+    CRF_CELL* pCell = NULL;
+    CFX_AffineMatrix matrix;
+    FX_POSITION pos = m_pPDFPage->GetFirstObjectPosition();
+    if(!pos) {
+        return;
+    }
+    FX_FLOAT PDFWidth = m_pPDFPage->GetPageWidth();
+    FX_FLOAT PDFHeight = m_pPDFPage->GetPageHeight();
+    m_pPDFPage->GetDisplayMatrix(m_PDFDisplayMatrix, 0, 0, (int)PDFWidth, (int)PDFHeight, 0);
+    CPDF_PageObject* pPerObj = NULL;
+    int a = 0;
+    CFX_FloatRect pageBBox = m_pPDFPage->m_BBox;
+    FX_FLOAT PrevX = 0 , PrevY = 0, PosX, PosY;
+    while(pos) {
+        CPDF_PageObject* pObj = m_pPDFPage->GetNextObject(pos);
+        if(!pObj || pObj->m_Type == PDFPAGE_PATH) {
+            continue;
+        }
+        int logic = LogicPreObj(pObj);
+        if(logic == 2) {
+            if(pCell) {
+                pCell->m_ObjList.SetAt(pCell->m_ObjList.GetTailPosition(), pObj);
+            }
+            continue;
+        }
+        if (pObj->m_Type == PDFPAGE_TEXT) {
+            CPDF_TextObject* pTextObj = (CPDF_TextObject*)pObj;
+            int textmode = pTextObj->m_TextState.GetObject()->m_TextMode;
+            if(m_Style.m_bIgnoreInvisibleText && pTextObj->m_TextState.GetObject()->m_TextMode == 3) {
+                continue;
+            }
+            PosX = pTextObj->GetPosX();
+            PosY = pTextObj->GetPosY();
+            m_PDFDisplayMatrix.Transform(PosX, PosY);
+        } else {
+            PosX = 0;
+            PosY = 0;
+        }
+        FX_BOOL bNewLine = TRUE;
+        FX_RECT ObjBBox = pObj->GetBBox(&m_PDFDisplayMatrix);
+        if(ObjBBox.left > PDFWidth || ObjBBox.right < 0 ||
+                ObjBBox.bottom < 0 || ObjBBox.top > PDFHeight) {
+            continue;
+        }
+        if(ObjBBox.IsEmpty()) {
+            continue;
+        }
+        a++;
+        if(!pCell) {
+            bNewLine = TRUE;
+            m_WritingMode = GetWritingMode(NULL, pObj);
+        } else {
+            int WritingMode = GetWritingMode(pPerObj, pObj);
+            if(m_WritingMode == WritingMode || m_WritingMode == WritingMode_UNKNOW || WritingMode == WritingMode_UNKNOW) {
+                if(WritingMode != WritingMode_UNKNOW) {
+                    m_WritingMode = WritingMode;
+                }
+                if(m_WritingMode == WritingMode_TBRL) {
+                    if(!(GetRectBottom(ObjBBox) > GetRectTop(pCell->m_BBox) ||
+                            GetRectTop(ObjBBox) < GetRectBottom(pCell->m_BBox))) {
+                        bNewLine = FALSE;
+                    }
+                } else {
+                    if(!(GetRectBottom(ObjBBox) < GetRectTop(pCell->m_BBox) ||
+                            GetRectTop(ObjBBox) > GetRectBottom(pCell->m_BBox))) {
+                        bNewLine = FALSE;
+                    }
+                    if (pObj->m_Type == PDFPAGE_TEXT) {
+                        if(FXSYS_fabs(PrevY - PosY) < 1 ) {
+                            bNewLine = FALSE;
+                        }
+                    }
+                }
+            } else {
+                m_WritingMode = WritingMode;
+            }
+        }
+        pPerObj = pObj;
+        if(bNewLine) {
+            int c = pCell ? pCell->m_ObjList.GetCount() : 0;
+            pCell = FX_NEW CRF_CELL;
+            pCell->m_CellWritingMode = m_WritingMode;
+            pCell->m_BBox = ObjBBox;
+            if(pObj->m_Type == PDFPAGE_TEXT) {
+                FX_FLOAT x = ((CPDF_TextObject*)pObj)->GetPosX(), y = ((CPDF_TextObject*)pObj)->GetPosY();
+                m_PDFDisplayMatrix.Transform(x, y);
+                if(x < ObjBBox.left) {
+                    pCell->m_BBox.left = (int)x;
+                }
+            }
+            pCell->m_ObjList.AddTail(pObj);
+            cellArray.Add(pCell);
+        } else {
+            pCell->m_ObjList.AddTail(pObj);
+            pCell->m_BBox.Union(ObjBBox);
+        }
+        PrevX = PosX;
+        PrevY = PosY;
+    }
+}
+FX_FLOAT CPDF_AutoReflowLayoutProvider::GetLayoutOrderHeight(CPDF_PageObject* pCurObj)
+{
+    CFX_FloatRect rcCurObj(pCurObj->m_Left, pCurObj->m_Bottom, pCurObj->m_Right, pCurObj->m_Top);
+    if (m_WritingMode == WritingMode_TBRL) {
+        return rcCurObj.Width();
+    }
+    return rcCurObj.Height();
+}
+FX_FLOAT CPDF_AutoReflowLayoutProvider::GetLayoutOrderWidth(CPDF_PageObject* pCurObj)
+{
+    CFX_FloatRect rcCurObj(pCurObj->m_Left, pCurObj->m_Bottom, pCurObj->m_Right, pCurObj->m_Top);
+    if (m_WritingMode == WritingMode_TBRL) {
+        return rcCurObj.Height();
+    }
+    return rcCurObj.Width();
+}
+int CPDF_AutoReflowLayoutProvider:: GetRectWidth(FX_RECT rect)
+{
+    if(m_WritingMode == WritingMode_TBRL) {
+        return rect.Height();
+    }
+    return rect.Width();
+}
+int CPDF_AutoReflowLayoutProvider:: GetRectHeight(FX_RECT rect)
+{
+    if(m_WritingMode == WritingMode_TBRL) {
+        return rect.Width();
+    }
+    return rect.Height();
+}
+int CPDF_AutoReflowLayoutProvider:: GetRectStart(FX_RECT rect)
+{
+    if(m_WritingMode == WritingMode_TBRL) {
+        return rect.top;
+    }
+    return rect.left;
+}
+int CPDF_AutoReflowLayoutProvider:: GetRectEnd(FX_RECT rect)
+{
+    if(m_WritingMode == WritingMode_TBRL) {
+        return rect.bottom;
+    }
+    return rect.right;
+}
+int CPDF_AutoReflowLayoutProvider:: GetRectTop(FX_RECT rect)
+{
+    if(m_WritingMode == WritingMode_TBRL) {
+        return rect.right;
+    }
+    return rect.top;
+}
+int CPDF_AutoReflowLayoutProvider:: GetRectBottom(FX_RECT rect)
+{
+    if(m_WritingMode == WritingMode_TBRL) {
+        return rect.left;
+    }
+    return rect.bottom;
+}
+int CPDF_AutoReflowLayoutProvider::GetWritingMode(CPDF_PageObject* pPreObj, CPDF_PageObject* pCurObj)
+{
+    CFX_FloatRect rcCurObj(pCurObj->m_Left, pCurObj->m_Bottom, pCurObj->m_Right, pCurObj->m_Top);
+    if(pCurObj->m_Type == PDFPAGE_TEXT) {
+        CPDF_TextObject* ptextObj = (CPDF_TextObject* )pCurObj;
+        int count = ptextObj->CountItems();
+        if(count > 1) {
+            CPDF_TextObjectItem Item1, Item2;
+            ptextObj->GetItemInfo(0, &Item1);
+            ptextObj->GetItemInfo(count - 1, &Item2);
+            if(Item2.m_CharCode == -1 && count > 2) {
+                ptextObj->GetItemInfo(2, &Item2);
+            }
+            CFX_AffineMatrix textMatrix;
+            ptextObj->GetTextMatrix(&textMatrix);
+            textMatrix.Transform(Item1.m_OriginX, Item1.m_OriginY);
+            textMatrix.Transform(Item2.m_OriginX, Item2.m_OriginY);
+            FX_FLOAT dx = FXSYS_fabs(Item1.m_OriginX - Item2.m_OriginX);
+            FX_FLOAT dy = FXSYS_fabs(Item1.m_OriginY - Item2.m_OriginY);
+            return dx >= dy ? WritingMode_LRTB : WritingMode_TBRL;
+        } else {
+            if(m_WritingMode != WritingMode_UNKNOW) {
+                return m_WritingMode;
+            }
+        }
+    }
+    if(pPreObj) {
+        FX_FLOAT threshold = rcCurObj.Width() / 4;
+        if(m_WritingMode == WritingMode_LRTB) {
+            if(FXSYS_fabs(pPreObj->m_Bottom - pCurObj->m_Bottom) < threshold * 2
+                    && FXSYS_fabs(pPreObj->m_Top - pCurObj->m_Top) < threshold * 2) {
+                return m_WritingMode;
+            }
+            FX_FLOAT mid = (pCurObj->m_Bottom + pCurObj->m_Top) / 2;
+            if(mid > pPreObj->m_Bottom && mid < pPreObj->m_Top && pCurObj->m_Right > pPreObj->m_Right) {
+                return m_WritingMode;
+            }
+        } else if(m_WritingMode == WritingMode_TBRL) {
+            if(FXSYS_fabs(pPreObj->m_Left - pCurObj->m_Left) < threshold * 2
+                    && FXSYS_fabs(pPreObj->m_Right - pCurObj->m_Right) < threshold * 2) {
+                return m_WritingMode;
+            }
+            FX_FLOAT mid = (pCurObj->m_Right + pCurObj->m_Left) / 2;
+            if(mid > pPreObj->m_Left && mid < pPreObj->m_Right && pCurObj->m_Bottom < pPreObj->m_Bottom) {
+                return m_WritingMode;
+            }
+        }
+        if(FXSYS_fabs(pPreObj->m_Left - pCurObj->m_Left) < threshold &&
+                FXSYS_fabs(pPreObj->m_Bottom - pCurObj->m_Bottom) > threshold * 2) {
+            return WritingMode_TBRL;
+        }
+        if(FXSYS_fabs(pPreObj->m_Left - pCurObj->m_Left) > threshold &&
+                FXSYS_fabs(pPreObj->m_Bottom - pCurObj->m_Bottom) < threshold * 2) {
+            return WritingMode_LRTB;
+        }
+        int count = 0;
+        if(pPreObj->m_Type == PDFPAGE_TEXT) {
+            CPDF_TextObject* ptextObj = (CPDF_TextObject* )pCurObj;
+            count = ptextObj->CountItems();
+        }
+        if(pPreObj->m_Type != PDFPAGE_TEXT || count == 1) {
+            if(pCurObj->m_Left > pPreObj->m_Right) {
+                FX_FLOAT mid = (pCurObj->m_Top + pCurObj->m_Bottom) / 2;
+                if(mid < pPreObj->m_Top && mid > pPreObj->m_Bottom) {
+                    return WritingMode_LRTB;
+                }
+            }
+            if(pCurObj->m_Top < pPreObj->m_Bottom) {
+                FX_FLOAT mid = (pCurObj->m_Left + pCurObj->m_Right) / 2;
+                if(mid < pPreObj->m_Right && mid > pPreObj->m_Left) {
+                    return WritingMode_TBRL;
+                }
+            }
+        }
+    }
+    return WritingMode_UNKNOW;
+}
+LayoutStatus CPDF_AutoReflowLayoutProvider::StartLoad(IFX_Pause* pPause)
+{
+    m_pPause = pPause;
+    m_pRoot = FX_NEW CPDF_AutoReflowElement(LayoutDocument);
+    if(!m_pRoot) {
+        return LayoutError;
+    }
+    m_Step = 0;
+    return Continue();
+}
+LayoutStatus CPDF_AutoReflowLayoutProvider::Continue()
+{
+    GenerateStructTree();
+    return m_Status;
+}
+int	CPDF_AutoReflowLayoutProvider::GetPosition()
+{
+    if(m_Step == 0) {
+        return 0;
+    } else {
+        return m_Step * 100 / AUTOREFLOW_STEP_REMOVEDATA;
+    }
+}
+FX_FLOAT CPDF_AutoReflowLayoutProvider::GetObjMinCell(CPDF_PageObject* pObj)
+{
+    if(!pObj) {
+        return 0;
+    }
+    if(pObj->m_Type != PDFPAGE_TEXT) {
+        CFX_AffineMatrix matrix;
+        FX_RECT rect = pObj->GetBBox(&matrix);
+        return (FX_FLOAT)(rect.Width());
+    }
+    CPDF_TextObject* pTextObj = (CPDF_TextObject* )pObj;
+    int count = pTextObj->CountItems();
+    for(int i = 0; i < count; i++) {
+        CPDF_TextObjectItem Item;
+        pTextObj->GetItemInfo(i, &Item);
+        if(Item.m_CharCode == -1) {
+            continue;
+        }
+        if((Item.m_CharCode > 47 && Item.m_CharCode < 58) || (Item.m_CharCode > 64 && Item.m_CharCode < 91)
+                || (Item.m_CharCode > 96 && Item.m_CharCode < 123)) {
+            continue;
+        }
+        if(Item.m_CharCode > 127 || (Item.m_CharCode > 32 && Item.m_CharCode < 35) || Item.m_CharCode == 37 ||
+                (Item.m_CharCode > 38 && Item.m_CharCode < 42) || Item.m_CharCode == 44 || Item.m_CharCode == 46 ||
+                Item.m_CharCode == 58 || Item.m_CharCode == 59 || Item.m_CharCode == 63 || Item.m_CharCode == 93) {
+            if(i == count - 1) {
+                CFX_AffineMatrix matrix;
+                FX_RECT rect = pObj->GetBBox(&matrix);
+                return (FX_FLOAT)(rect.Width());
+            } else {
+                pTextObj->GetItemInfo(i + 1, &Item);
+                return Item.m_OriginX;
+            }
+        }
+        return Item.m_OriginX;
+    }
+    CFX_AffineMatrix matrix;
+    FX_RECT rect = pObj->GetBBox(&matrix);
+    return (FX_FLOAT)(rect.Width());
+}
diff --git a/core/src/reflow/autoreflow.h b/core/src/reflow/autoreflow.h
new file mode 100644
index 0000000000..d98f33bf4e
--- /dev/null
+++ b/core/src/reflow/autoreflow.h
@@ -0,0 +1,122 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#ifndef _AUTOREFLOW_H
+#define _AUTOREFLOW_H
+#include "../../include/reflow/reflowengine.h"
+#include "reflowedpage.h"
+class CPDF_AutoReflowElement;
+class CPDF_AutoReflowLayoutProvider;
+typedef CFX_ArrayTemplate<CPDF_AutoReflowElement*> CAR_ElmPtrArray;
+typedef CFX_ArrayTemplate<CPDF_PageObject*> CAR_ObjPtrArray;
+class CRF_CELL : public CFX_Object
+{
+public:
+    CRF_CELL() { };
+    ~CRF_CELL() { };
+    CFX_PtrList		m_ObjList;
+    int			m_CellWritingMode;
+    FX_RECT		m_BBox;
+};
+class CPDF_AutoReflowElement : public IPDF_LayoutElement, public CFX_Object
+{
+public:
+    CPDF_AutoReflowElement(LayoutType layoutType = LayoutUnknown , CPDF_AutoReflowElement* pParent = NULL) ;
+    ~CPDF_AutoReflowElement();
+    LayoutType GetType()
+    {
+        return m_ElmType;
+    }
+    void	GetRect(CFX_FloatRect& rcRect) {};
+
+    int  CountAttrValues(LayoutAttr attr_type);
+    LayoutEnum  GetEnumAttr(LayoutAttr attr_type, int index);
+    FX_FLOAT GetNumberAttr(LayoutAttr attr_type, int index);
+    FX_COLORREF GetColorAttr(LayoutAttr attr_type, int index);
+
+    int  CountChildren()
+    {
+        return m_ChildArray.GetSize();
+    }
+    IPDF_LayoutElement* GetChild(int index)
+    {
+        return m_ChildArray.GetAt(index);
+    }
+
+    IPDF_LayoutElement* GetParent()
+    {
+        return m_pParentElm;
+    }
+    int		CountObjects()
+    {
+        return m_ObjArray.GetSize();
+    }
+    CPDF_PageObject*	GetObject(int index)
+    {
+        return m_ObjArray.GetAt(index);
+    }
+    CPDF_AutoReflowElement* m_pParentElm;
+    LayoutType		m_ElmType;
+    CAR_ElmPtrArray m_ChildArray;
+    CAR_ObjPtrArray m_ObjArray;
+    FX_FLOAT		m_SpaceBefore;
+};
+#define AUTOREFLOW_STEP_GENERATELINE		1
+#define AUTOREFLOW_STEP_GENERATEParagraph	2
+#define AUTOREFLOW_STEP_CREATEELEMENT		3
+#define AUTOREFLOW_STEP_REMOVEDATA			4
+class CPDF_AutoReflowLayoutProvider : public IPDF_LayoutProvider, public CFX_Object
+{
+public:
+    CPDF_AutoReflowLayoutProvider(CPDF_PageObjects* pPage, FX_BOOL bReadOrder);
+    ~CPDF_AutoReflowLayoutProvider();
+    void	SetLayoutProviderStyle(LAYOUTPROVIDER_STYLE Style)
+    {
+        m_Style = Style;
+    }
+    LayoutStatus StartLoad(IFX_Pause* pPause = NULL);
+    LayoutStatus Continue();
+    int	 		GetPosition();
+    IPDF_LayoutElement* GetRoot()
+    {
+        return m_pRoot;
+    }
+    FX_FLOAT GetObjMinCell(CPDF_PageObject* pObj);
+    void Conver2AppreceOrder(const CPDF_PageObjects* pStreamOrderObjs, CPDF_PageObjects* pAppraceOrderObjs);
+    void	ReleaseElm(CPDF_AutoReflowElement*& pElm, FX_BOOL bReleaseChildren = TRUE);
+    void GenerateCell();
+    void GenerateStructTree();
+    void GenerateLine(CFX_PtrArray& cellArray);
+    void GenerateParagraph(CFX_PtrArray& cellArray);
+    void CreateElement();
+    void AddObjectArray(CPDF_AutoReflowElement* pElm, CFX_PtrList& ObjList);
+    FX_FLOAT GetLayoutOrderHeight(CPDF_PageObject* pCurObj);
+    FX_FLOAT GetLayoutOrderWidth(CPDF_PageObject* pCurObj);
+    int GetWritingMode(CPDF_PageObject* pPreObj, CPDF_PageObject* pCurObj);
+    int GetRectStart(FX_RECT rect);
+    int GetRectEnd(FX_RECT rect);
+    int GetRectTop(FX_RECT rect);
+    int GetRectBottom(FX_RECT rect);
+    int GetRectHeight(FX_RECT rect);
+    int GetRectWidth(FX_RECT rect);
+    void ProcessObj(CFX_PtrArray& cellArray, CPDF_PageObject* pObj, CFX_AffineMatrix matrix);
+    FX_INT32 LogicPreObj(CPDF_PageObject* pObj);
+
+    CPDF_AutoReflowElement* m_pRoot;
+    CPDF_AutoReflowElement* m_pCurrElm;
+    CPDF_Page*	m_pPDFPage;
+    IFX_Pause*	m_pPause;
+    CFX_AffineMatrix m_PDFDisplayMatrix;
+    CPDF_PageObject* m_pPreObj;
+    LayoutStatus m_Status;
+    int m_WritingMode;
+    CFX_PtrArray m_CellArray;
+    FX_BOOL		 m_bReadOrder;
+    LAYOUTPROVIDER_STYLE m_Style;
+    CFX_PtrArray m_cellArray;
+    int			m_Step;
+};
+#endif
diff --git a/core/src/reflow/layoutprocessor_reflow.cpp b/core/src/reflow/layoutprocessor_reflow.cpp
new file mode 100644
index 0000000000..d2fa7e9371
--- /dev/null
+++ b/core/src/reflow/layoutprocessor_reflow.cpp
@@ -0,0 +1,1560 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "../../include/reflow/reflowengine.h"
+#include "reflowedpage.h"
+#include "layoutprovider_taggedpdf.h"
+IPDF_LayoutProcessor* IPDF_LayoutProcessor::Create_LayoutProcessor_Reflow(FX_FLOAT TopIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, void* pReflowedPage, int flags, FX_FLOAT lineSpace )
+{
+    if(pReflowedPage == NULL || fWidth <= 20) {
+        return NULL;
+    }
+    CPDF_LayoutProcessor_Reflow* pReflowEngine = FX_NEW CPDF_LayoutProcessor_Reflow();
+    if (NULL == pReflowEngine) {
+        return NULL;
+    }
+    pReflowEngine->Init(TopIndent, fWidth, fHeight, (CPDF_ReflowedPage*)pReflowedPage, flags, lineSpace);
+    return pReflowEngine;
+}
+CPDF_LayoutProcessor_Reflow::CPDF_LayoutProcessor_Reflow()
+{
+    m_pPause = NULL;
+    m_pLayoutElement = NULL;
+    m_fRefWidth = 0;
+    m_fRefWidth = 0;
+    m_fCurrLineWidth = 0;
+    m_fCurrLineHeight = 0;
+    m_bIllustration = FALSE;
+    m_pPreObj = NULL;
+    m_pCurrLine = FX_NEW CRF_DataPtrArray(50);
+    m_pTempLine = FX_NEW CRF_DataPtrArray(50);
+    m_StartIndent = 0;
+    m_PausePosition = 0;
+}
+CPDF_LayoutProcessor_Reflow::~CPDF_LayoutProcessor_Reflow()
+{
+    if (m_pCurrLine) {
+        m_pCurrLine->RemoveAll();
+        delete m_pCurrLine;
+    }
+    m_pCurrLine = NULL;
+    if (m_pTempLine) {
+        m_pTempLine->RemoveAll();
+        delete m_pTempLine;
+    }
+    m_pTempLine = NULL;
+}
+void CPDF_LayoutProcessor_Reflow::Init(FX_FLOAT TopIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, CPDF_ReflowedPage* pReflowedPage, int flags, FX_FLOAT lineSpace)
+{
+    m_pLayoutElement = NULL;
+    m_TopIndent = TopIndent;
+    m_Status = LayoutReady;
+    m_flags = flags;
+    m_pReflowedPage = pReflowedPage;
+    m_fScreenHeight = fHeight;
+    m_fRefWidth = fWidth;
+    m_fCurrLineHeight = 0;
+    m_fCurrLineWidth = 0;
+    m_fLineSpace = lineSpace;
+    pReflowedPage->m_PageWidth = fWidth;
+    pReflowedPage->m_PageHeight = TopIndent;
+}
+void CPDF_LayoutProcessor_Reflow::FitPageMode()
+{
+    if(m_flags & RF_PARSER_PAGEMODE && m_fScreenHeight > 20) {
+        float fitPageHeight = m_fScreenHeight;
+        CPDF_ReflowedPage* pRFPage = m_pReflowedPage;
+        int count = pRFPage->m_pReflowed->GetSize();
+        CFX_WordArray dy;
+        dy.Add(0);
+        int pos = 0;
+        int screenCount = 1;
+        FX_FLOAT h = pRFPage->GetPageHeight();
+        while (h > screenCount * fitPageHeight) {
+            FX_FLOAT tempPageHeight = screenCount * fitPageHeight;
+            int j = 0;
+            FX_FLOAT tempDy = 0;
+            for(int i = 0; i < count; i++) {
+                CRF_Data* pData = (*pRFPage->m_pReflowed)[i];
+                FX_FLOAT posY;
+                posY = pData->m_PosY;
+                if(FXSYS_fabs(posY) > tempPageHeight &&
+                        FXSYS_fabs(posY + pData->m_Height) < tempPageHeight) {
+                    if(j == 0) {
+                        j = i;
+                    }
+                    if(pData->m_Height > fitPageHeight) {
+                        FX_FLOAT zoom;
+                        FX_FLOAT spaceh = screenCount * fitPageHeight + posY + pData->m_Height;
+                        if(spaceh < fitPageHeight / 3 * 2) {
+                            spaceh = fitPageHeight;
+                        }
+                        zoom = spaceh / pData->m_Height;
+                        tempDy = spaceh - pData->m_Height;
+                        pData->m_Height = spaceh;
+                        pData->m_Width *= zoom;
+                        break;
+                    }
+                    FX_FLOAT dy = pData->m_PosY + pData->m_Height + tempPageHeight;
+                    if(dy > tempDy) {
+                        tempDy = dy;
+                    }
+                } else if(FXSYS_fabs(posY + pData->m_Height) > tempPageHeight) {
+                    break;
+                }
+            }
+            for(; j < count; j++) {
+                CRF_Data* pData = (*pRFPage->m_pReflowed)[j];
+                FX_FLOAT posY;
+                posY = pData->m_PosY;
+                if(FXSYS_fabs(posY) > tempPageHeight ) {
+                    pData->m_PosY -= tempDy;
+                }
+                if(pData->m_Height >= fitPageHeight) {
+                    pData->m_Height = fitPageHeight - 1;
+                    if(pData->GetType() == CRF_Data::Text) {
+                        CRF_CharData* pCharData = (CRF_CharData*)pData;
+                        pCharData->m_pCharState->m_fFontSize = pData->m_Height;
+                    }
+                }
+            }
+            pRFPage->m_PageHeight += tempDy;
+            h += tempDy;
+            screenCount++;
+        }
+    }
+}
+LayoutStatus CPDF_LayoutProcessor_Reflow::StartProcess(IPDF_LayoutElement* pElement, IFX_Pause* pPause, const CFX_AffineMatrix* pPDFMatrix)
+{
+    if(!pElement) {
+        return LayoutError;
+    }
+    m_pPause = pPause;
+    m_PDFMatrix = *pPDFMatrix;
+    m_pRootElement = pElement;
+    ProcessElement(m_pRootElement, m_fRefWidth);
+    if(m_Status == LayoutToBeContinued) {
+        return LayoutToBeContinued;
+    }
+    m_Status = LayoutFinished;
+    FitPageMode();
+    return LayoutFinished;
+}
+LayoutStatus CPDF_LayoutProcessor_Reflow::Continue()
+{
+    int size = m_pReflowedPage->m_pReflowed->GetSize();
+    ProcessElement(m_pRootElement, m_CurrRefWidth);
+    size = m_pReflowedPage->m_pReflowed->GetSize();
+    if(m_Status == LayoutReady) {
+        m_Status = LayoutFinished;
+        FitPageMode();
+    }
+    return m_Status;
+}
+int CPDF_LayoutProcessor_Reflow::GetPosition()
+{
+    return m_PausePosition;
+}
+FX_BOOL	CPDF_LayoutProcessor_Reflow::IsCanBreakAfter(FX_DWORD unicode)
+{
+    if(unicode == -1) {
+        return FALSE;
+    }
+    switch(unicode) {
+        case 40:
+        case 91:
+        case 123:
+            return FALSE;
+    }
+    if(unicode >= 256) {
+        return TRUE;
+    } else if(unicode >= 48 && unicode <= 57) {
+        return FALSE;
+    } else if(unicode >= 64 && unicode <= 90) {
+        return FALSE;
+    } else if(unicode >= 97 && unicode <= 122) {
+        return FALSE;
+    }
+    return TRUE;
+}
+FX_BOOL	CPDF_LayoutProcessor_Reflow::IsCanBreakBefore(FX_DWORD unicode)
+{
+    if(unicode == -1) {
+        return FALSE;
+    }
+    switch(unicode) {
+        case 33:
+        case 41:
+        case 44:
+        case 46:
+        case 59:
+        case 63:
+        case 93:
+        case 125:
+            return FALSE;
+    }
+    if(unicode >= 256) {
+        return TRUE;
+    } else if(unicode >= 48 && unicode <= 57) {
+        return FALSE;
+    } else if(unicode >= 64 && unicode <= 90) {
+        return FALSE;
+    } else if(unicode >= 97 && unicode <= 122) {
+        return FALSE;
+    }
+    return TRUE;
+}
+void CPDF_LayoutProcessor_Reflow::ProcessTable(FX_FLOAT dx)
+{
+    if(m_pReflowedPage->m_pReflowed->GetSize() == 0) {
+        return;
+    }
+    CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
+    int rowCount = pTable->m_nCell.GetSize();
+    int n = 0;
+    FX_FLOAT* dyRow = FX_Alloc(FX_FLOAT, rowCount + 1);
+    FXSYS_memset32(dyRow, 0, sizeof(FX_FLOAT) * (rowCount + 1));
+    dyRow[0] = 0 ;
+    dyRow[0] = - pTable->m_ReflowPageHeight;
+    int tableColCount = 0;
+    int i;
+    for(i = 0; i < rowCount; i++) {
+        int colCount = pTable->m_nCell.GetAt(i);
+        if(colCount > tableColCount) {
+            tableColCount = colCount;
+        }
+    }
+    int cellCount = tableColCount * rowCount;
+    RF_TableCell** pVirtualTable = FX_Alloc(RF_TableCell*, cellCount);
+    FXSYS_memset32(pVirtualTable, 0, sizeof(RF_TableCell*) * cellCount);
+    for(i = 0; i < rowCount; i++) {
+        int colCount = pTable->m_nCell.GetAt(i);
+        FX_FLOAT rowWidth = 0;
+        int j = 0;
+        int s = pTable->m_pCellArray.GetSize();
+        for(j = 0; j < colCount; j++) {
+            RF_TableCell* pCell = (RF_TableCell*)pTable->m_pCellArray.GetAt(n++);
+            if(pCell->m_EndPos < pCell->m_BeginPos) {
+                continue;
+            }
+            int pos = i * tableColCount;
+            while(pos < cellCount && pVirtualTable[pos] != NULL) {
+                pos++;
+            }
+            if(pos >= (i + 1) * tableColCount) {
+                pos = i * tableColCount + j;
+            }
+            int RowSpan = pCell->m_RowSpan;
+            int ColSpan = pCell->m_ColSpan;
+            if(RowSpan + i > rowCount) {
+                RowSpan = rowCount - i;
+            }
+            if(ColSpan + j > colCount) {
+                ColSpan = colCount - j;
+            }
+            for(int m = 0; m < RowSpan; m++) {
+                for(int nn = 0; nn < ColSpan; nn++) {
+                    if(pos + nn >= cellCount) {
+                        break;
+                    }
+                    pVirtualTable[pos + nn] = pCell;
+                }
+                pos += tableColCount;
+            }
+            FX_FLOAT dxCell = dx;
+            for(pos = i * tableColCount; pVirtualTable[pos] != pCell && pos < cellCount; pos++) {
+                dxCell += (pVirtualTable[pos])->m_MaxWidth;
+            }
+            CRF_Data* pData = (*m_pReflowedPage->m_pReflowed)[pCell->m_BeginPos];
+            FX_FLOAT dy = dyRow[i] - pData->m_Height - pData->m_PosY;
+            CFX_AffineMatrix matrix(1, 0, 0, 1, dxCell, dy);
+            Transform(&matrix, m_pReflowedPage->m_pReflowed, pCell->m_BeginPos, pCell->m_EndPos - pCell->m_BeginPos + 1);
+            if(pCell->m_RowSpan + i <= rowCount) {
+                if(FXSYS_fabs(dyRow[pCell->m_RowSpan + i]) < FXSYS_fabs(dyRow[i] - pCell->m_CellHeight)) {
+                    dyRow[pCell->m_RowSpan + i] = dyRow[i] - pCell->m_CellHeight;
+                }
+            }
+        }
+    }
+    n = 0;
+    for(i = 0; i < rowCount; i++) {
+        int colCount = pTable->m_nCell.GetAt(i);
+        for(int j = 0; j < colCount; j++) {
+            RF_TableCell* pCell = (RF_TableCell*)pTable->m_pCellArray.GetAt(n++);
+            switch(pCell->m_BlockAlign) {
+                case LayoutAfter: {
+                        FX_FLOAT dy = dyRow[i + pCell->m_RowSpan] - pCell->m_CellHeight - dyRow[i];
+                        CFX_AffineMatrix matrix(1, 0, 0, 1, 0, dy);
+                        Transform(&matrix, m_pReflowedPage->m_pReflowed, pCell->m_BeginPos, pCell->m_EndPos - pCell->m_BeginPos + 1);
+                    }
+                    break;
+                case LayoutMiddle:
+                case LayoutJustify: {
+                        FX_FLOAT dy = (dyRow[i + pCell->m_RowSpan] + pCell->m_CellHeight - dyRow[i]) / 2;
+                        CFX_AffineMatrix matrix(1, 0, 0, 1, 0, dy);
+                        Transform(&matrix, m_pReflowedPage->m_pReflowed, pCell->m_BeginPos, pCell->m_EndPos - pCell->m_BeginPos + 1);
+                        break;
+                    }
+                default:
+                    break;
+            }
+        }
+    }
+    CRF_Data* pData = (*m_pReflowedPage->m_pReflowed)[m_pReflowedPage->m_pReflowed->GetSize() - 1];
+    m_pReflowedPage->m_PageHeight = - dyRow[rowCount] + pData->m_Height;
+    FX_Free(pVirtualTable);
+    FX_Free(dyRow);
+    int size = pTable->m_pCellArray.GetSize();
+    for(i = 0; i < size; i++) {
+        RF_TableCell* pCell = pTable->m_pCellArray.GetAt(i);
+        FX_Free(pCell);
+    }
+    pTable->m_pCellArray.RemoveAll();
+    pTable->m_nCell.RemoveAll();
+    int s = sizeof(CRF_Table);
+    delete pTable;
+    m_TableArray.RemoveAt(m_TableArray.GetSize() - 1);
+}
+CFX_FloatRect CPDF_LayoutProcessor_Reflow::GetElmBBox(IPDF_LayoutElement* pElement)
+{
+    CFX_FloatRect rect;
+    int objCount = pElement->CountObjects();
+    int count = pElement->CountChildren();
+    if(objCount == 0 && count == 0) {
+        return rect;
+    }
+    CFX_AffineMatrix matrix;
+    int i;
+    for(i = 0; i < objCount; i++) {
+        CPDF_PageObject* pObj = pElement->GetObject(0);
+        if(!pObj) {
+            continue;
+        }
+        if( rect.Height() == 0 ) {
+            rect = pObj->GetBBox(&matrix);
+        } else {
+            rect.Union(pObj->GetBBox(&matrix));
+        }
+    }
+    for(i = 0; i < count; i++) {
+        IPDF_LayoutElement* pChildElement = pElement->GetChild(i);
+        if( rect.Height() == 0 ) {
+            rect = GetElmBBox(pChildElement);
+        } else {
+            rect.Union(GetElmBBox(pChildElement));
+        }
+    }
+    return rect;
+}
+FX_FLOAT CPDF_LayoutProcessor_Reflow::GetElmWidth(IPDF_LayoutElement* pElement)
+{
+    if(!pElement) {
+        return 0;
+    }
+    LayoutType layoutType = pElement->GetType();
+    FX_FLOAT width = 0;
+    if(layoutType == LayoutTable || layoutType == LayoutTableDataCell || layoutType == LayoutTableHeaderCell) {
+        width = pElement->GetNumberAttr(LayoutWidth);
+        if(width > 0) {
+            return width;
+        }
+    } else if( layoutType == LayoutTableRow) {
+        int count = pElement->CountChildren();
+        for(int i = 0; i < count; i++) {
+            IPDF_LayoutElement* pElm = pElement->GetChild(i);
+            width += pElm->GetNumberAttr(LayoutWidth);
+        }
+        if(width > 0) {
+            return width;
+        }
+    }
+    CFX_FloatRect rect = GetElmBBox(pElement);
+    return rect.Width();
+}
+FX_BOOL GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
+                        FX_FLOAT& interlow, FX_FLOAT& interhigh);
+FX_BOOL IsSameLine(FX_BOOL bHorizontal, CFX_FloatRect Rect1, CFX_FloatRect Rect2)
+{
+    if(bHorizontal) {
+        FX_FLOAT inter_top, inter_bottom;
+        if (!GetIntersection(Rect1.bottom, Rect1.top, Rect2.bottom, Rect2.top,
+                             inter_bottom, inter_top)) {
+            return FALSE;
+        }
+        FX_FLOAT lineHeight = Rect1.top - Rect1.bottom;
+        if(lineHeight > 20 && lineHeight > Rect2.Height() * 2) {
+            return FALSE;
+        }
+        if(lineHeight > 5 && Rect2.Height() / 2 > lineHeight) {
+            return FALSE;
+        }
+        FX_FLOAT inter_h = inter_top - inter_bottom;
+        if (inter_h < (lineHeight) / 2 && inter_h < Rect2.Height() / 2) {
+            return FALSE;
+        }
+    } else {
+        FX_FLOAT inter_left, inter_right;
+        if(!GetIntersection(Rect1.left, Rect1.right, Rect2.left, Rect2.right, inter_left, inter_right)) {
+            return FALSE;
+        }
+        FX_FLOAT inter_w = inter_right - inter_left;
+        if (inter_w < (Rect1.right - Rect1.left) / 2 && inter_w < (Rect2.right - Rect2.left) / 2) {
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+FX_INT32 IsCanMergeParagraph(IPDF_LayoutElement* pPrevElement, IPDF_LayoutElement* pNextElement)
+{
+    FX_INT32 analogial = 100;
+    FX_INT32 nPrevObj = pPrevElement->CountObjects(), i;
+    CPDF_PageObject* pPrevObj = NULL;
+    CFX_FloatRect prevRect, rect;
+    CFX_PtrArray prevLine, line;
+    FX_BOOL bParagraphStart = FALSE;
+    for(i = 0; i < nPrevObj; i++) {
+        CPDF_PageObject* pObj = pPrevElement->GetObject(i);
+        if(!pPrevObj) {
+            pPrevObj = pObj;
+            rect = CFX_FloatRect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right, pObj->m_Top);
+            line.Add(pObj);
+            continue;
+        }
+        CFX_FloatRect objRect = CFX_FloatRect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right, pObj->m_Top);
+        if(IsSameLine(TRUE, rect, objRect)) {
+            line.Add(pObj);
+            rect.Union(objRect);
+        } else {
+            prevLine.RemoveAll();
+            prevLine.Append(line);
+            prevRect = rect;
+            line.RemoveAll();
+            line.Add(pObj);
+            rect = objRect;
+            if(!bParagraphStart) {
+                if (prevRect.left > rect.left + rect.Height() * 1.5) {
+                    bParagraphStart = TRUE;
+                }
+            }
+        }
+    }
+    if(prevLine.GetSize()) {
+        if(FXSYS_fabs(rect.right - prevRect.right) > rect.Height()) {
+            analogial -= 50;
+        }
+    }
+    CPDF_PageObject* pObj = pPrevElement->GetObject(nPrevObj - 1);
+    if(pObj->m_Type == PDFPAGE_TEXT) {
+        CPDF_TextObject* pText = (CPDF_TextObject*)pObj;
+        FX_INT32 nItem = pText->CountItems();
+        CPDF_TextObjectItem item;
+        pText->GetItemInfo(nItem - 1, &item);
+        CFX_WideString wStr = pText->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+        if(wStr.IsEmpty()) {
+            wStr = (FX_WCHAR)item.m_CharCode;
+        }
+        FX_WCHAR wch = wStr.GetAt(wStr.GetLength() - 1);
+        switch(wch) {
+            case '.':
+            case 12290:
+            case 65311:
+            case 63:
+            case 33:
+            case 65281:
+                analogial -= 50;
+                break;
+        }
+    }
+    prevLine.RemoveAll();
+    prevLine.Append(line);
+    line.RemoveAll();
+    FX_INT32 nNextObj = pNextElement->CountObjects();
+    pPrevObj = NULL;
+    FX_BOOL bFirst = TRUE;
+    for(i = 0; i < nNextObj; i++) {
+        CPDF_PageObject* pObj = pNextElement->GetObject(i);
+        if(!pPrevObj) {
+            pPrevObj = pObj;
+            rect = CFX_FloatRect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right, pObj->m_Top);
+            line.Add(pObj);
+            continue;
+        }
+        CFX_FloatRect objRect = CFX_FloatRect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right, pObj->m_Top);
+        if(IsSameLine(TRUE, rect, objRect)) {
+            line.Add(pObj);
+            rect.Union(objRect);
+        } else {
+            if(FXSYS_fabs(rect.right - prevRect.right) < rect.Height() && FXSYS_fabs(rect.left - prevRect.left) < rect.Height()) {
+                analogial += 50;
+            }
+            prevLine.RemoveAll();
+            prevLine.Append(line);
+            prevRect = rect;
+            line.RemoveAll();
+            line.Add(pObj);
+            rect = objRect;
+            if(!bFirst) {
+                break;
+            }
+            bFirst = FALSE;
+        }
+    }
+    if(prevLine.GetSize()) {
+        if(bParagraphStart) {
+            if(prevRect.left - rect.left > rect.Height() && prevRect.left - rect.left < rect.Height() * 3) {
+                analogial -= 50;
+            }
+        } else {
+            if(FXSYS_fabs(prevRect.left - rect.left) < rect.Height()) {
+                analogial -= 50;
+            }
+        }
+    }
+    return analogial;
+}
+void CPDF_LayoutProcessor_Reflow::ProcessElement(IPDF_LayoutElement* pElement, FX_FLOAT reflowWidth)
+{
+    if(pElement == NULL) {
+        return;
+    }
+    if(m_Status == LayoutReady) {
+        LayoutType layoutType = pElement->GetType();
+        FX_INT32 ElementType = GetElementTypes(layoutType);
+        switch(ElementType) {
+            case SST_IE:
+                m_bIllustration = TRUE;
+                break;
+            case SST_BLSE:
+                FinishedCurrLine();
+                FX_FLOAT StartIndent = 0;
+                if(IPDF_LayoutElement* pParent = pElement->GetParent()) {
+                    StartIndent = pParent->GetNumberAttr(LayoutStartIndent);
+                }
+                FX_FLOAT currStartIndent = pElement->GetNumberAttr(LayoutStartIndent);
+                m_StartIndent = ConverWidth(currStartIndent);
+                FX_FLOAT width = reflowWidth;
+                if(StartIndent != currStartIndent) {
+                    reflowWidth -= m_StartIndent;
+                }
+                FX_FLOAT spaceBefore = pElement->GetNumberAttr(LayoutSpaceBefore);
+                m_pReflowedPage->m_PageHeight += spaceBefore;
+                m_TextAlign = pElement->GetEnumAttr(LayoutTextAlign);
+                if(IPDF_LayoutElement* pParent = pElement->GetParent()) {
+                    StartIndent = pParent->GetNumberAttr(LayoutEndIndent);
+                    FX_FLOAT currEndIndent = pElement->GetNumberAttr(LayoutEndIndent);
+                    if(StartIndent != currStartIndent) {
+                        reflowWidth -= ConverWidth(currEndIndent);
+                    }
+                }
+                if(reflowWidth * 2 < width) {
+                    reflowWidth = width;
+                    m_StartIndent = 0;
+                }
+                break;
+        }
+        switch(layoutType) {
+            case LayoutTable: {
+                    CRF_Table* pTable = FX_NEW CRF_Table;
+                    if (NULL == pTable) {
+                        break;
+                    }
+                    m_TableArray.Add(pTable);
+                    pTable->m_ReflowPageHeight = m_pReflowedPage->m_PageHeight;
+                    pTable->m_TableWidth = GetElmWidth(pElement);
+                    break;
+                }
+            case LayoutTableRow: {
+                    if(!m_TableArray.GetSize()) {
+                        break;
+                    }
+                    int count = pElement->CountChildren();
+                    CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
+                    int f = 0;
+                    for(int i = 0; i < count; i++) {
+                        IPDF_LayoutElement* pChildElement = pElement->GetChild(i);
+                        LayoutType type = pChildElement->GetType();
+                        if(type == LayoutTableDataCell || type == LayoutTableHeaderCell) {
+                            f++;
+                        }
+                    }
+                    pTable->m_nCell.Add(f);
+                    break;
+                }
+            case LayoutTableDataCell:
+            case LayoutTableHeaderCell: {
+                    if(!m_TableArray.GetSize()) {
+                        break;
+                    }
+                    RF_TableCell* pCell = FX_Alloc(RF_TableCell, 1);
+                    FXSYS_memset32(pCell, 0 , sizeof(RF_TableCell));
+                    CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
+                    int pos = pTable->m_nCell.GetSize() - 1;
+                    pCell->m_BeginPos = m_pReflowedPage->m_pReflowed->GetSize();
+                    FX_FLOAT cellWidth = pElement->GetNumberAttr(LayoutWidth);
+                    if(cellWidth == 0 || pCell->m_MaxWidth > pTable->m_TableWidth) {
+                        CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
+                        pCell->m_MaxWidth = reflowWidth / pTable->m_nCell.GetAt(pTable->m_nCell.GetSize() - 1);
+                    } else {
+                        pCell->m_MaxWidth = pElement->GetNumberAttr(LayoutWidth) * reflowWidth / pTable->m_TableWidth;
+                    }
+                    pCell->m_ColSpan = (int)(pElement->GetNumberAttr(LayoutColSpan));
+                    pCell->m_RowSpan = (int)(pElement->GetNumberAttr(LayoutRowSpan));
+                    if(!pCell->m_ColSpan) {
+                        pCell->m_ColSpan = 1;
+                    }
+                    if(!pCell->m_RowSpan ) {
+                        pCell->m_RowSpan = 1;
+                    }
+                    pCell->m_BlockAlign = pElement->GetEnumAttr(LayoutBlockAlign);
+                    m_TextAlign = pElement->GetEnumAttr(LayoutInlineAlign);
+                    pCell->m_PosX = 0;
+                    pCell->m_PosY = 0;
+                    reflowWidth = pCell->m_MaxWidth;
+                    pTable->m_pCellArray.Add(pCell);
+                    break;
+                }
+            default:
+                break;
+        }
+        m_fLineHeight = pElement->GetNumberAttr(LayoutLineHeight);
+        int ReflowedSize = m_pReflowedPage->m_pReflowed->GetSize();
+        if(pElement->CountObjects()) {
+            ProcessObjs(pElement, reflowWidth);
+        }
+    }
+    int count = pElement->CountChildren();
+    for(int i = 0; i < count; i++) {
+        IPDF_LayoutElement* pChildElement = pElement->GetChild(i);
+        ProcessElement(pChildElement, reflowWidth);
+        if(m_pPause && m_pRootElement == pElement && m_Status != LayoutToBeContinued ) {
+            if(m_pPause->NeedToPauseNow()) {
+                m_pLayoutElement = pChildElement;
+                m_Status = LayoutToBeContinued;
+                m_CurrRefWidth = reflowWidth;
+                m_PausePosition = (i + 1) * 100 / (count + 1);
+                return ;
+            }
+        }
+        if(m_Status == LayoutToBeContinued && m_pLayoutElement == pChildElement) {
+            m_Status = LayoutReady;
+        }
+    }
+    if(m_Status == LayoutReady) {
+        FX_FLOAT dx = 0;
+        LayoutType layoutType = pElement->GetType();
+        FX_INT32 ElementType = GetElementTypes(layoutType);
+        switch(ElementType) {
+            case SST_IE:
+                m_bIllustration = FALSE;
+                FinishedCurrLine();
+                break;
+            case SST_BLSE:
+                FinishedCurrLine();
+                FX_FLOAT StartIndent = 0;
+                if(IPDF_LayoutElement* pParent = pElement->GetParent()) {
+                    StartIndent = pParent->GetNumberAttr(LayoutStartIndent);
+                }
+                FX_FLOAT currStartIndent = pElement->GetNumberAttr(LayoutStartIndent);
+                if(StartIndent != currStartIndent) {
+                    reflowWidth += ConverWidth(currStartIndent);
+                    dx += ConverWidth(currStartIndent);
+                }
+                FX_FLOAT spaceAfter = pElement->GetNumberAttr(LayoutSpaceAfter);
+                m_pReflowedPage->m_PageHeight += spaceAfter;
+                break;
+        }
+        switch(layoutType) {
+            case LayoutTableDataCell:
+            case LayoutTableHeaderCell: {
+                    if(!m_TableArray.GetSize()) {
+                        break;
+                    }
+                    CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
+                    RF_TableCell* pCell = pTable->m_pCellArray.GetAt(pTable->m_pCellArray.GetSize() - 1);
+                    pCell->m_EndPos = m_pReflowedPage->m_pReflowed->GetSize() - 1;
+                    if(pCell->m_EndPos < pCell->m_BeginPos) {
+                        pCell->m_CellHeight = 0;
+                    } else {
+                        CRF_Data* pBeginData = (*m_pReflowedPage->m_pReflowed)[pCell->m_BeginPos];
+                        CRF_Data* pEndData = (*m_pReflowedPage->m_pReflowed)[pCell->m_EndPos];
+                        pCell->m_CellHeight = pBeginData->m_Height > pEndData->m_Height ? pBeginData->m_Height : pEndData->m_Height;
+                        pCell->m_CellHeight -= pEndData->m_PosY - pBeginData->m_PosY;
+                    }
+                    break;
+                }
+            case LayoutTableRow: {
+                    if(!m_TableArray.GetSize()) {
+                        break;
+                    }
+                    CRF_Table* pTable = m_TableArray.GetAt(m_TableArray.GetSize() - 1);
+                    if(pTable->m_nCol == 0) {
+                        pTable->m_nCol = pTable->m_pCellArray.GetSize();
+                    }
+                    break;
+                }
+            case LayoutTable: {
+                    ProcessTable(dx);
+                    break;
+                }
+            default:
+                if(dx) {
+                    CFX_AffineMatrix matrix(1, 0, 0, 1, dx, 0);
+                    int ReflowedSize = m_pReflowedPage->m_pReflowed->GetSize();
+                    Transform(&matrix, m_pReflowedPage->m_pReflowed, ReflowedSize, m_pReflowedPage->m_pReflowed->GetSize() - ReflowedSize);
+                }
+        }
+    }
+    if(m_pRootElement == pElement) {
+        m_PausePosition = 100;
+    }
+}
+FX_INT32 CPDF_LayoutProcessor_Reflow::GetElementTypes(LayoutType layoutType)
+{
+    switch(layoutType) {
+        case LayoutParagraph:
+        case LayoutHeading:
+        case LayoutHeading1:
+        case LayoutHeading2:
+        case LayoutHeading3:
+        case LayoutHeading4:
+        case LayoutHeading5:
+        case LayoutHeading6:
+        case LayoutList:
+        case LayoutListItem:
+        case LayoutListLabel:
+        case LayoutListBody:
+        case LayoutTable:
+        case LayoutTableHeaderCell:
+        case LayoutTableDataCell:
+        case LayoutTableRow:
+        case LayoutTableHeaderGroup:
+        case LayoutTableBodyGroup:
+        case LayoutTableFootGroup:
+        case LayoutTOCI:
+        case LayoutCaption:
+            return SST_BLSE;
+        case LayoutFigure:
+        case LayoutFormula:
+        case LayoutForm:
+            return SST_IE;
+        case LayoutSpan:
+        case LayoutQuote:
+        case LayoutNote:
+        case LayoutReference:
+        case LayoutBibEntry:
+        case LayoutCode:
+        case LayoutLink:
+        case LayoutAnnot:
+        case LayoutRuby:
+        case LayoutWarichu:
+            return SST_ILSE;
+        default:
+            return SST_GE;
+    }
+    return FALSE;
+}
+FX_FLOAT	CPDF_LayoutProcessor_Reflow::ConverWidth(FX_FLOAT width)
+{
+    return width;
+}
+void CPDF_LayoutProcessor_Reflow::ProcessObject(CPDF_PageObject* pObj, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix)
+{
+    if(!pObj) {
+        return;
+    }
+    if(pObj->m_Type == PDFPAGE_TEXT) {
+        ProcessTextObject( (CPDF_TextObject *)pObj, reflowWidth, objMatrix);
+    } else if(pObj->m_Type == PDFPAGE_IMAGE) {
+        if(!(m_flags & RF_PARSER_IMAGE)) {
+            return;
+        }
+        CPDF_PageObjects* pObjs = FX_NEW CPDF_PageObjects(FALSE);
+        if (NULL == pObjs) {
+            return;
+        }
+        FX_POSITION pos = pObjs->GetLastObjectPosition();
+        pos = pObjs->InsertObject(pos, pObj);
+        CFX_AffineMatrix matrix;
+        FX_RECT rect = pObj->GetBBox(&matrix);
+        CPDF_ImageObject* ImageObj = (CPDF_ImageObject*)pObj;
+        ProcessUnitaryObjs(pObjs, reflowWidth, objMatrix);
+        delete pObjs;
+    } else if(pObj->m_Type == PDFPAGE_PATH) {
+    } else if(pObj->m_Type == PDFPAGE_FORM) {
+        CPDF_FormObject* pForm = (CPDF_FormObject*)pObj;
+        FX_POSITION pos = pForm->m_pForm->GetFirstObjectPosition();
+        objMatrix.Concat(pForm->m_FormMatrix);
+        while (pos) {
+            CPDF_PageObject* pObj1 = pForm->m_pForm->GetNextObject(pos);
+            ProcessObject(pObj1, reflowWidth, objMatrix);
+        }
+    }
+}
+void CPDF_LayoutProcessor_Reflow::ProcessObjs(IPDF_LayoutElement* pElement, FX_FLOAT reflowWidth)
+{
+    m_fCurrMaxWidth = reflowWidth;
+    int ObjCount = pElement->CountObjects();
+    for(int i = 0; i < ObjCount; i++) {
+        CPDF_PageObject* pObj = pElement->GetObject(i);
+        ProcessObject(pObj, reflowWidth, m_PDFMatrix);
+        continue;
+    }
+}
+void CPDF_LayoutProcessor_Reflow::AddTemp2CurrLine(int begin, int count)
+{
+    if(begin < 0 || count <= 0 || !m_pReflowedPage || !m_pReflowedPage->m_pReflowed || !m_pTempLine) {
+        return;
+    } else {
+        count += begin;
+    }
+    int size = m_pReflowedPage->m_pReflowed->GetSize();
+    int temps = m_pTempLine->GetSize();
+    for(int i = begin; i < count; i++) {
+        CRF_Data* pData = (*m_pTempLine)[i];
+        AddData2CurrLine(pData);
+    }
+}
+void CPDF_LayoutProcessor_Reflow::AddData2CurrLine(CRF_Data* pData)
+{
+    if(pData == NULL || m_pCurrLine == NULL) {
+        return;
+    }
+    m_pCurrLine->Add(pData);
+    m_fCurrLineWidth = pData->m_PosX + pData->m_Width;
+    if(pData->m_Height > m_fCurrLineHeight) {
+        m_fCurrLineHeight = pData->m_Height;
+    }
+}
+void CPDF_LayoutProcessor_Reflow::UpdateCurrLine()
+{
+}
+void CPDF_LayoutProcessor_Reflow::Transform(const CFX_AffineMatrix* pMatrix, CRF_DataPtrArray* pDataArray, int beginPos, int count)
+{
+    if (!pDataArray) {
+        return;
+    }
+    if(count == 0) {
+        count = pDataArray->GetSize();
+    } else {
+        count += beginPos;
+    }
+    for(int i = beginPos; i < count; i++) {
+        CRF_Data* pData = (*pDataArray)[i];
+        Transform(pMatrix, pData);
+    }
+}
+void CPDF_LayoutProcessor_Reflow::Transform(const CFX_AffineMatrix* pMatrix, CRF_Data* pData)
+{
+    if(pData->GetType() == CRF_Data::Path) {
+        CRF_PathData* pPathData = (CRF_PathData*)pData;
+        pPathData->m_pPath2Device.Concat(*pMatrix);
+    }
+    pMatrix->Transform(pData->m_PosX, pData->m_PosY, pData->m_PosX, pData->m_PosY);
+}
+FX_BOOL CPDF_LayoutProcessor_Reflow::FinishedCurrLine()
+{
+    if (NULL == m_pCurrLine) {
+        return FALSE;
+    }
+    int count = m_pCurrLine->GetSize();
+    if(count == 0) {
+        return FALSE;
+    }
+    if(m_fLineHeight > m_fCurrLineHeight) {
+        m_fCurrLineHeight = m_fLineHeight;
+    } else {
+        m_fCurrLineHeight += 2;
+    }
+    if(m_pReflowedPage->m_pReflowed->GetSize() > 0) {
+        m_fCurrLineHeight += m_fLineSpace;
+    }
+    FX_FLOAT height = m_pReflowedPage->m_PageHeight + m_fCurrLineHeight;
+    FX_FLOAT lineHeight = m_fLineHeight;
+    if(lineHeight == 0) {
+        lineHeight = m_fCurrLineHeight;
+    }
+    FX_FLOAT dx = 0;
+    switch(m_TextAlign) {
+        case LayoutCenter:
+            dx = (m_fCurrMaxWidth - m_fCurrLineWidth) / 2;
+            break;
+        case LayoutEnd:
+            dx = m_fCurrMaxWidth - m_fCurrLineWidth;
+            break;
+        case LayoutJustify:
+            break;
+        default:
+            break;
+    }
+    FX_FLOAT dy = - height;
+    int refedSize = m_pReflowedPage->m_pReflowed->GetSize();
+    if(count == 13) {
+        int a = 0;
+    }
+    for(int i = 0; i < count; i++) {
+        CRF_Data* pData = (*m_pCurrLine)[i];
+        m_pReflowedPage->m_pReflowed->Add(pData);
+        FX_FLOAT x = m_StartIndent + dx * (m_TextAlign == LayoutJustify ? i + 1 : 1);
+        CFX_AffineMatrix matrix(1, 0, 0, 1, x, dy);
+        Transform(&matrix, pData);
+    }
+    m_pCurrLine->RemoveAll();
+    m_fCurrLineWidth = 0;
+    m_pReflowedPage->m_PageHeight += m_fCurrLineHeight;
+    m_fCurrLineHeight = 0;
+    return TRUE;
+}
+CRF_CharState* CPDF_LayoutProcessor_Reflow::GetCharState(CPDF_TextObject* pObj, CPDF_Font* pFont, FX_FLOAT fHeight, FX_ARGB color)
+{
+    if (NULL == m_pReflowedPage->m_pCharState) {
+        return NULL;
+    }
+    int count = m_pReflowedPage->m_pCharState->GetSize();
+    for(int i = count - 1; i >= 0; i--) {
+        CRF_CharState* pState = (CRF_CharState*)m_pReflowedPage->m_pCharState->GetAt(i);
+        if(pState->m_Color == color && pState->m_fFontSize == fHeight && pState->m_pFont == pFont && pState->m_pTextObj == pObj) {
+            return pState;
+        }
+    }
+    CRF_CharState pState;
+    pState.m_pTextObj = pObj;
+    pState.m_Color = color;
+    pState.m_pFont = pFont;
+    pState.m_fFontSize = fHeight;
+    int ascent = pFont->GetTypeAscent();
+    int descent = pFont->GetTypeDescent();
+    pState.m_fAscent = ascent * fHeight / (ascent - descent);
+    if(descent == 0) {
+        pState.m_fDescent = 0;
+    } else {
+        pState.m_fDescent = descent * fHeight / (ascent - descent);
+    }
+    pState.m_bVert = FALSE;
+    CPDF_CIDFont *pCIDFont = pFont->GetCIDFont();
+    if(pCIDFont) {
+        pState.m_bVert = pCIDFont->IsVertWriting();
+    }
+    m_pReflowedPage->m_pCharState->Add(pState);
+    return (CRF_CharState*)m_pReflowedPage->m_pCharState->GetAt(count);
+}
+int CPDF_LayoutProcessor_Reflow::GetCharWidth(FX_DWORD charCode, CPDF_Font* pFont) const
+{
+    if(charCode == -1) {
+        return 0;
+    }
+    int w = pFont->GetCharWidthF(charCode);
+    if(w == 0) {
+        CFX_ByteString str;
+        pFont->AppendChar(str, charCode);
+        w = pFont->GetStringWidth(str, 1);
+        if(w == 0) {
+            FX_RECT BBox;
+            pFont->GetCharBBox(charCode, BBox);
+            w = BBox.right - BBox.left;
+        }
+    }
+    return w;
+}
+void CPDF_LayoutProcessor_Reflow::CreateRFData(CPDF_PageObject* pObj, CFX_AffineMatrix* pObjMatrix)
+{
+    if (NULL == m_pReflowedPage->m_pMemoryPool) {
+        return;
+    }
+    if(pObj->m_Type == PDFPAGE_TEXT) {
+        CPDF_TextObject* pTextObj = (CPDF_TextObject* )pObj;
+        int count = pTextObj->CountItems();
+        if(!count) {
+            return;
+        }
+        if(count == 1) {
+            CPDF_TextObjectItem Item;
+            pTextObj->GetItemInfo(0, &Item);
+            if(Item.m_CharCode == 49) {
+                int a = 0;
+            }
+        }
+        CPDF_Font * pFont = pTextObj->GetFont();
+        FX_FLOAT fs = pTextObj->GetFontSize();
+        FX_FLOAT* pmatrix = pTextObj->m_TextState.GetMatrix();
+        FX_FLOAT matrix1 = pmatrix[1];
+        if(pmatrix[2] == 0) {
+            matrix1 = 0;
+        }
+        CFX_AffineMatrix textMatrix(pmatrix[0], matrix1, pmatrix[2], pmatrix[3], 0, 0);
+        FX_FLOAT height = FXSYS_fabs(textMatrix.TransformDistance(fs));
+        if(pObjMatrix) {
+            height = FXSYS_fabs(pObjMatrix->TransformDistance(height));
+        }
+        int r = 0, g = 0, b = 0;
+        pTextObj->m_ColorState.GetFillColor()->GetRGB(r, g, b);
+        FX_ARGB col = r * 0x10000;
+        col += g * 0x100;
+        col += b;
+        CRF_CharState* pState = GetCharState(pTextObj, pFont, height, col);
+        FX_FLOAT dx = 0, dy = 0;
+        FX_RECT ObjBBox;
+        if(pObjMatrix) {
+            ObjBBox = pTextObj->GetBBox(pObjMatrix);
+            dx = (float)ObjBBox.left;
+            dy = (float)ObjBBox.bottom;
+        } else {
+            CFX_AffineMatrix matrix;
+            ObjBBox = pTextObj->GetBBox(&matrix);
+        }
+        FX_FLOAT objWidth = 0;
+        CFX_ByteString str;
+        FX_BOOL bOrder = TRUE;
+        CFX_PtrArray tempArray;
+        int i = 0;
+        CPDF_TextObjectItem Item;
+        pTextObj->GetItemInfo(i, &Item);
+        dx = Item.m_OriginX;
+        dy = Item.m_OriginY;
+        textMatrix.Transform(Item.m_OriginX, Item.m_OriginY, dx, dy);
+        CRF_CharData* pLastData = NULL;
+        FX_FLOAT horzScale = pTextObj->m_TextState.GetFontSizeV() / pTextObj->m_TextState.GetFontSizeH();
+        while(i < count) {
+            pTextObj->GetItemInfo(i, &Item);
+            if(Item.m_CharCode == -1) {
+                i++;
+                continue;
+            }
+            FX_FLOAT OriginX, OriginY;
+            textMatrix.Transform(Item.m_OriginX, Item.m_OriginY, OriginX, OriginY);
+            CRF_CharData* pData = (CRF_CharData*)m_pReflowedPage->m_pMemoryPool->Alloc(sizeof(CRF_CharData));
+            if (NULL == pData) {
+                continue;
+            }
+            pData->m_Type = CRF_Data::Text;
+            if(FXSYS_fabs(OriginY - dy) > FXSYS_fabs(OriginX - dx)) {
+                pData->m_PosY = dy;
+                pData->m_PosX = pLastData->m_PosX + pLastData->m_Width + textMatrix.TransformDistance(pTextObj->m_TextState.GetObject()->m_CharSpace);
+            } else {
+                pData->m_PosY = OriginY;
+                pData->m_PosX = OriginX;
+            }
+            int size = tempArray.GetSize();
+            if(size && pData->m_PosX < pLastData->m_PosX ) {
+                for (int j = 0; j < size; j++) {
+                    CRF_CharData* pData1 = (CRF_CharData*)tempArray.GetAt(j);
+                    if(pData1->m_PosX > pData->m_PosX) {
+                        tempArray.InsertAt(j, pData);
+                        break;
+                    }
+                }
+            } else {
+                tempArray.Add(pData);
+            }
+            pLastData = pData;
+            pData->m_CharCode = Item.m_CharCode;
+            pData->m_Height = FXSYS_fabs(height);
+            int w = GetCharWidth(Item.m_CharCode, pFont);
+            pData->m_Width = FXSYS_fabs(fs * textMatrix.TransformDistance((FX_FLOAT)w) / 1000);
+            if(horzScale) {
+                pData->m_Width /= horzScale;
+            }
+            pData->m_pCharState = pState;
+            i++;
+        }
+        count = tempArray.GetSize();
+        for (int j = 0; j < count; j++) {
+            CRF_CharData* pData = (CRF_CharData*)tempArray.GetAt(j);
+            if (m_pTempLine) {
+                m_pTempLine->Add(pData);
+            }
+        }
+        tempArray.RemoveAll();
+    } else if(pObj->m_Type == PDFPAGE_IMAGE) {
+        CPDF_ImageObject* pImageObj = (CPDF_ImageObject* )pObj;
+        CRF_ImageData* pRFImage = (CRF_ImageData*)m_pReflowedPage->m_pMemoryPool->Alloc(sizeof(CRF_ImageData));
+        if (NULL == pRFImage) {
+            return;
+        }
+        pRFImage->m_pBitmap = NULL;
+        pRFImage->m_Type = CRF_Data::Image;
+        if (m_pTempLine) {
+            m_pTempLine->Add(pRFImage);
+        }
+        CPDF_Image *pImage = pImageObj->m_pImage;
+        if (!pImage->m_pDIBSource || !pImage->m_pMask) {
+            if(pImage->StartLoadDIBSource(m_pReflowedPage->GetFormResDict(pImageObj), m_pReflowedPage->m_pPDFPage->m_pResources, 0, 0, TRUE)) {
+                pImage->Continue(NULL);
+            }
+        }
+        CFX_DIBSource* pDibSource = pImage->DetachBitmap();
+        if (pDibSource) {
+            pRFImage->m_pBitmap = pDibSource->Clone();
+            delete pDibSource;
+        }
+        CFX_DIBSource* pMask = pImage->DetachMask();
+        if (pMask) {
+            if (!pMask->IsAlphaMask()) {
+                CFX_DIBitmap* pMaskBmp = pMask->Clone();
+                pMaskBmp->ConvertFormat(FXDIB_8bppMask);
+                pRFImage->m_pBitmap->MultiplyAlpha(pMaskBmp);
+                delete pMaskBmp;
+            } else {
+                pRFImage->m_pBitmap->MultiplyAlpha(pMask);
+            }
+            delete pMask;
+        }
+        CFX_FloatRect ObjBBox;
+        if(pObjMatrix) {
+            ObjBBox = pImageObj->GetBBox(pObjMatrix);
+        } else {
+            CFX_AffineMatrix matrix;
+            ObjBBox = pImageObj->GetBBox(&matrix);
+        }
+        pRFImage->m_Width = ObjBBox.Width();
+        pRFImage->m_Height = ObjBBox.Height();
+        pRFImage->m_PosX = 0;
+        pRFImage->m_PosY = 0;
+        CFX_AffineMatrix matrix(1, 0, 0, -1, 0, 0);
+        matrix.Concat(pImageObj->m_Matrix);
+        matrix.Concat(*pObjMatrix);
+        pRFImage->m_Matrix.Set(matrix.a == 0 ? 0 : matrix.a / FXSYS_fabs(matrix.a),
+                               matrix.b == 0 ? 0 : matrix.b / FXSYS_fabs(matrix.b),
+                               matrix.c == 0 ? 0 : matrix.c / FXSYS_fabs(matrix.c),
+                               matrix.d == 0 ? 0 : matrix.d / FXSYS_fabs(matrix.d), 0, 0);
+    } else if(pObj->m_Type == PDFPAGE_PATH) {
+    }
+}
+FX_FLOAT CPDF_LayoutProcessor_Reflow:: GetDatasWidth(int beginPos, int endpos)
+{
+    if(endpos < beginPos || !m_pTempLine) {
+        return 0;
+    }
+    if(endpos > m_pTempLine->GetSize() - 1) {
+        endpos = m_pTempLine->GetSize() - 1;
+    }
+    CRF_Data* pBeginData = (*m_pTempLine)[beginPos];
+    CRF_Data* pEndData = (*m_pTempLine)[endpos];
+    return pEndData->m_PosX - pBeginData->m_PosX + pEndData->m_Width;
+}
+FX_WCHAR CPDF_LayoutProcessor_Reflow::GetPreChar()
+{
+    if (NULL == m_pCurrLine) {
+        return -1;
+    }
+    int index = m_pCurrLine->GetSize() - 1;
+    CRF_CharData* pCharData = NULL;
+    while (index >= 0 && !pCharData) {
+        CRF_Data* pData = (*m_pCurrLine)[index];
+        if(pData->GetType() == CRF_Data::Text) {
+            pCharData = (CRF_CharData*)pData;
+        } else {
+            return -1;
+        }
+        index --;
+    }
+    if(m_pReflowedPage) {
+        index = m_pReflowedPage->m_pReflowed->GetSize() - 1;
+    }
+    while(!pCharData && index >= 0) {
+        CRF_Data* pData = (*m_pReflowedPage->m_pReflowed)[index];
+        if(pData->GetType() == CRF_Data::Text) {
+            pCharData = (CRF_CharData*)pData;
+        } else {
+            return -1;
+        }
+        index --;
+    }
+    if(pCharData) {
+        CFX_WideString str = pCharData->m_pCharState->m_pFont->UnicodeFromCharCode(pCharData->m_CharCode);
+        return str.GetAt(0);
+    }
+    return -1;
+}
+int CPDF_LayoutProcessor_Reflow::ProcessInsertObject(CPDF_TextObject* pObj, CFX_AffineMatrix formMatrix)
+{
+    if(!pObj || !m_pPreObj || !m_pCurrLine) {
+        return 0;
+    }
+    if(m_pCurrLine->GetSize() == 0) {
+        return 0;
+    }
+    CPDF_TextObjectItem item;
+    int nItem = m_pPreObj->CountItems();
+    m_pPreObj->GetItemInfo(nItem - 1, &item);
+    FX_FLOAT last_pos = item.m_OriginX;
+    FX_FLOAT last_width = GetCharWidth(item.m_CharCode, m_pPreObj->GetFont()) * m_pPreObj->GetFontSize() / 1000;
+    last_width = FXSYS_fabs(last_width);
+    pObj->GetItemInfo(0, &item);
+    FX_FLOAT this_width = GetCharWidth(item.m_CharCode, pObj->GetFont()) * pObj->GetFontSize() / 1000;
+    this_width = FXSYS_fabs(this_width);
+    FX_FLOAT threshold = last_width > this_width ? last_width / 4 : this_width / 4;
+    CFX_AffineMatrix prev_matrix, prev_reverse;
+    m_pPreObj->GetTextMatrix(&prev_matrix);
+    prev_matrix.Concat(m_perMatrix);
+    prev_reverse.SetReverse(prev_matrix);
+    FX_FLOAT x = pObj->GetPosX(), y = pObj->GetPosY();
+    formMatrix.Transform(x, y);
+    prev_reverse.Transform(x, y);
+    FX_WCHAR preChar  = GetPreChar();
+    CFX_WideString wstrItem = pObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+    FX_WCHAR curChar = wstrItem.GetAt(0);
+    if (FXSYS_fabs(y) > threshold * 2) {
+        if (preChar == L'-') {
+            return 3;
+        }
+        if (preChar != L' ') {
+            return 1;
+        }
+        return 2;
+    }
+    if ((x - last_pos - last_width) > threshold && curChar != L' ' && preChar != L' ') {
+        return 1;
+    }
+    return 0;
+}
+FX_INT32 CPDF_LayoutProcessor_Reflow::LogicPreObj(CPDF_TextObject* pObj)
+{
+    CPDF_TextObject* pPreObj = m_pPreObj;
+    m_pPreObj = pObj;
+    if(!pObj || !pPreObj) {
+        return 0;
+    }
+    CPDF_TextObjectItem item;
+    pPreObj->GetItemInfo(pPreObj->CountItems() - 1, &item);
+    FX_FLOAT last_pos = item.m_OriginX;
+    FX_FLOAT last_width = pPreObj->GetFont()->GetCharWidthF(item.m_CharCode) * pPreObj->GetFontSize() / 1000;
+    last_width = FXSYS_fabs(last_width);
+    pObj->GetItemInfo(0, &item);
+    FX_FLOAT this_width = pObj->GetFont()->GetCharWidthF(item.m_CharCode) * pObj->GetFontSize() / 1000;
+    this_width = FXSYS_fabs(this_width);
+    FX_FLOAT threshold = last_width > this_width ? last_width / 4 : this_width / 4;
+    CFX_AffineMatrix prev_matrix, prev_reverse;
+    pPreObj->GetTextMatrix(&prev_matrix);
+    prev_reverse.SetReverse(prev_matrix);
+    FX_FLOAT x = pObj->GetPosX(), y = pObj->GetPosY();
+    prev_reverse.Transform(x, y);
+    CFX_WideString wstrItem = pObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
+    FX_WCHAR curChar = wstrItem.GetAt(0);
+    if (FXSYS_fabs(y) > threshold * 2) {
+        return 2;
+    }
+    FX_WCHAR preChar = 0;
+    if (FXSYS_fabs(last_pos + last_width - x) > threshold && curChar != L' ') {
+        return 1;
+    }
+    return 0;
+    m_pPreObj = pObj;
+    if(!pPreObj) {
+        return 0;
+    }
+    if(pPreObj->m_Type != pObj->m_Type) {
+        return 0;
+    }
+    CFX_FloatRect rcCurObj(pObj->m_Left, pObj->m_Bottom, pObj->m_Right, pObj->m_Top);
+    CFX_FloatRect rcPreObj(pPreObj->m_Left, pPreObj->m_Bottom, pPreObj->m_Right, pPreObj->m_Top);
+    if(pObj->m_Type == PDFPAGE_IMAGE) {
+        if(rcPreObj.Contains(rcCurObj)) {
+            return 2;
+        }
+        if(rcCurObj.Contains(rcPreObj)) {
+            return 2;
+        }
+        return 0;
+    }
+    if(pObj->m_Type == PDFPAGE_TEXT) {
+        if(!((rcPreObj.bottom > rcCurObj.top) || (rcPreObj.top < rcCurObj.bottom))) {
+            FX_FLOAT height = FX_MIN(rcPreObj.Height(), rcCurObj.Height());
+            if((rcCurObj.left - rcPreObj.right) > height / 3) {
+                return 3;
+            }
+        }
+        if(FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) >= 2 || FXSYS_fabs(rcPreObj.Height() - rcCurObj.Height()) >= 2 ) {
+            return 0;
+        }
+        CPDF_TextObject* pPreTextObj = (CPDF_TextObject*)pPreObj;
+        CPDF_TextObject* pCurTextObj = (CPDF_TextObject*)pObj;
+        int nPreCount = pPreTextObj->CountItems();
+        int nCurCount = pCurTextObj->CountItems();
+        if (nPreCount != nCurCount) {
+            return 0;
+        }
+        FX_BOOL bSame = TRUE;
+        for (int i = 0; i < nPreCount; i++) {
+            CPDF_TextObjectItem itemPer, itemCur;
+            pPreTextObj->GetItemInfo(i, &itemPer);
+            pCurTextObj->GetItemInfo(i, &itemCur);
+            if (itemCur.m_CharCode != itemPer.m_CharCode) {
+                return 0;
+            }
+            if (itemCur.m_OriginX != itemPer.m_OriginX) {
+                bSame = FALSE;
+            }
+            if (itemCur.m_OriginY != itemPer.m_OriginY) {
+                bSame = FALSE;
+            }
+        }
+        if(rcPreObj.left == rcCurObj.left && rcPreObj.top == rcCurObj.top) {
+            return 1;
+        }
+        if(FXSYS_fabs(rcPreObj.left - rcCurObj.left) < rcPreObj.Width() / 3
+                && FXSYS_fabs(rcPreObj.top - rcCurObj.top) < rcPreObj.Height() / 3) {
+            return 2;
+        }
+    }
+    return 0;
+}
+FX_BOOL CPDF_LayoutProcessor_Reflow::IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2)
+{
+    if (!pTextObj1 || !pTextObj2) {
+        return FALSE;
+    }
+    CFX_FloatRect rcPreObj(pTextObj2->m_Left, pTextObj2->m_Bottom, pTextObj2->m_Right, pTextObj2->m_Top);
+    CFX_FloatRect rcCurObj(pTextObj1->m_Left, pTextObj1->m_Bottom, pTextObj1->m_Right, pTextObj1->m_Top);
+    if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty()) {
+        return FALSE;
+    }
+    if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
+        rcPreObj.Intersect(rcCurObj);
+        if (rcPreObj.IsEmpty()) {
+            return FALSE;
+        }
+        if (FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) > rcCurObj.Width() / 2) {
+            return FALSE;
+        }
+        if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize()) {
+            return FALSE;
+        }
+    }
+    int nPreCount = pTextObj2->CountItems();
+    int nCurCount = pTextObj1->CountItems();
+    if (nPreCount != nCurCount) {
+        return FALSE;
+    }
+    for (int i = 0; i < nPreCount; i++) {
+        CPDF_TextObjectItem itemPer, itemCur;
+        pTextObj2->GetItemInfo(i, &itemPer);
+        pTextObj1->GetItemInfo(i, &itemCur);
+        if (itemCur.m_CharCode != itemPer.m_CharCode) {
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+void CPDF_LayoutProcessor_Reflow::ProcessTextObject(CPDF_TextObject *pTextObj, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix)
+{
+    if(reflowWidth < 0 || !m_pCurrLine || !m_pTempLine) {
+        return;
+    }
+    if(IsSameTextObject(pTextObj, m_pPreObj)) {
+        return;
+    }
+    CPDF_PageObject* pPreObj = m_pPreObj;
+    FX_INT32 logic = ProcessInsertObject(pTextObj, objMatrix);
+    m_pPreObj = pTextObj;
+    m_perMatrix.Copy(objMatrix);
+    int size = m_pTempLine->GetSize();
+    int curs = m_pCurrLine->GetSize();
+    CreateRFData(pTextObj);
+    size = m_pTempLine->GetSize();
+    int reds = m_pReflowedPage->m_pReflowed->GetSize();
+    if(size == 0) {
+        return;
+    }
+    if(logic == 1) {
+        m_fCurrLineWidth += pTextObj->GetBBox(&objMatrix).Height() / 3;
+    } else if(logic == 3 && curs) {
+        m_fCurrLineWidth -= (*m_pCurrLine)[curs - 1]->m_Width;
+        m_pCurrLine->Delete(curs - 1);
+    }
+    int beginPos = 0, endPos = m_pTempLine->GetSize() - 1;
+    while(beginPos <= endPos) {
+        int tempBeginPos = beginPos;
+        int tempEndPos = endPos;
+        FX_FLOAT all_width = GetDatasWidth( beginPos, endPos);
+        if(all_width < reflowWidth - m_fCurrLineWidth) {
+            CRF_CharData* pBeginData = (CRF_CharData*)(*m_pTempLine)[beginPos];
+            CFX_AffineMatrix matrix(1, 0, 0, 1, -pBeginData->m_PosX + m_fCurrLineWidth, -pBeginData->m_PosY);
+            Transform(&matrix, m_pTempLine, beginPos, endPos - beginPos + 1);
+            AddTemp2CurrLine(beginPos, endPos - beginPos + 1);
+            m_pTempLine->RemoveAll();
+            return;
+        }
+        int	midPos ;
+        if(tempBeginPos >= tempEndPos && tempEndPos != 0) {
+            midPos = tempEndPos;
+        } else {
+            while (tempBeginPos < tempEndPos ) {
+                midPos = (tempEndPos - tempBeginPos) / 2 + tempBeginPos;
+                if(midPos == tempBeginPos || midPos == tempEndPos) {
+                    break;
+                }
+                FX_FLOAT w = GetDatasWidth( beginPos, midPos);
+                if(w < reflowWidth - m_fCurrLineWidth) {
+                    tempBeginPos = midPos;
+                } else {
+                    tempEndPos = midPos;
+                }
+            }
+            midPos = tempBeginPos;
+            if(midPos == 0) {
+                FX_FLOAT w = GetDatasWidth( beginPos, 1);
+                if(w > reflowWidth - m_fCurrLineWidth) {
+                    midPos = -1;
+                }
+            }
+        }
+        if(midPos == -1) {
+            int count = m_pCurrLine->GetSize();
+            if(count == 0) {
+                midPos = 0;
+            }
+        }
+        int f = -1;
+        int i = 0;
+        for(i = midPos; i >= beginPos; i--) {
+            CRF_CharData* pData = (CRF_CharData*)(*m_pTempLine)[i];
+            CFX_WideString Wstr = pData->m_pCharState->m_pFont->UnicodeFromCharCode(pData->m_CharCode);
+            FX_WCHAR cha = Wstr.GetAt(0);
+            if(i < m_pTempLine->GetSize() - 1) {
+                CRF_CharData* pNextData = (CRF_CharData*)(*m_pTempLine)[i + 1];
+                if(pNextData->m_PosX - (pData->m_PosX + pData->m_Width) >= pData->m_Height / 4) {
+                    f = i;
+                    i++;
+                }
+            }
+            if(f == -1) {
+                if(IsCanBreakAfter((FX_DWORD)cha)) {
+                    f = i;
+                    i++;
+                } else if(IsCanBreakBefore((FX_DWORD)cha)) {
+                    f = i - 1;
+                    if(f < beginPos) {
+                        f = -1;
+                    }
+                }
+            }
+            if(f != -1) {
+                CRF_CharData* pBeginData = (CRF_CharData*)(*m_pTempLine)[beginPos];
+                CFX_AffineMatrix matrix(1, 0, 0, 1, -pBeginData->m_PosX + m_fCurrLineWidth, -pBeginData->m_PosY);
+                Transform(&matrix, m_pTempLine, beginPos, f - beginPos + 1);
+                CRF_Data* pData = (*m_pTempLine)[0];
+                AddTemp2CurrLine(beginPos, f - beginPos + 1);
+                beginPos = i;
+                FinishedCurrLine();
+                f = 1;
+                break;
+            }
+        }
+        if(f == -1 && i < beginPos) {
+            if( m_pCurrLine->GetSize()) {
+                int count = m_pCurrLine->GetSize();
+                f = -1;
+                for(int i = count - 1; i >= 0; i--) {
+                    CRF_Data* pData = (*m_pCurrLine)[i];
+                    if(pData->GetType() != CRF_Data::Text) {
+                        f = i + 1;
+                    } else {
+                        CRF_CharData* pCharData = (CRF_CharData*)pData;
+                        CFX_WideString Wstr = pCharData->m_pCharState->m_pFont->UnicodeFromCharCode(pCharData->m_CharCode);
+                        FX_WCHAR cha = Wstr.GetAt(0);
+                        if(IsCanBreakAfter(cha)) {
+                            f = i + 1;
+                            i++;
+                        } else if(IsCanBreakBefore(cha)) {
+                            f = i;
+                        }
+                        if(f == 0) {
+                            f = -1;
+                        }
+                    }
+                    if(f != -1) {
+                        FinishedCurrLine();
+                        if(f < count) {
+                            int reflowdCount = m_pReflowedPage->m_pReflowed->GetSize();
+                            int pos = reflowdCount + f - count;
+                            CRF_CharData* pData = (CRF_CharData*)(*m_pReflowedPage->m_pReflowed)[pos];
+                            CFX_AffineMatrix matrix(1, 0, 0, 1, -pData->m_PosX + m_fCurrLineWidth, -pData->m_PosY);
+                            Transform(&matrix, m_pReflowedPage->m_pReflowed, pos, reflowdCount - pos);
+                            for(int j = pos; j < reflowdCount; j++) {
+                                AddData2CurrLine((*m_pReflowedPage->m_pReflowed)[j]);
+                            }
+                            m_pReflowedPage->m_pReflowed->Delete(pos, count - f);
+                            if(logic == 3) {
+                                m_fCurrLineWidth += pTextObj->GetBBox(&objMatrix).Height() / 3;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            if(f == -1) {
+                CRF_CharData* pData = (CRF_CharData*)(*m_pTempLine)[beginPos];
+                CFX_AffineMatrix matrix(1, 0, 0, 1, -pData->m_PosX + m_fCurrLineWidth, -pData->m_PosY);
+                if(beginPos == midPos) {
+                    Transform(&matrix, pData);
+                    FX_RECT rect;
+                    pData->m_pCharState->m_pFont->GetFontBBox(rect);
+                    FX_FLOAT* pmatrix = pTextObj->m_TextState.GetMatrix();
+                    CFX_AffineMatrix textMatrix(pmatrix[0], pmatrix[1], pmatrix[2], pmatrix[3], 0, 0);
+                    FX_FLOAT width = pData->m_Height * (rect.right - rect.left) / 1000;
+                    FX_FLOAT f = (reflowWidth - m_fCurrLineWidth) / width;
+                    pData->m_PosY *= f;
+                    pData->m_Width *= f;
+                    pData->m_Height *= f;
+                    pData->m_pCharState = GetCharState(pData->m_pCharState->m_pTextObj, pData->m_pCharState->m_pFont, pData->m_Height, pData->m_pCharState->m_Color);
+                    AddData2CurrLine(pData);
+                } else {
+                    for(int m = beginPos; m <= midPos; m++) {
+                        CRF_CharData* pData = (CRF_CharData*)(*m_pTempLine)[m];
+                        Transform(&matrix, pData);
+                        AddData2CurrLine(pData);
+                    }
+                }
+                FinishedCurrLine();
+                beginPos = midPos + 1;
+            }
+        }
+    }
+    m_pTempLine->RemoveAll();
+    return;
+}
+void CPDF_LayoutProcessor_Reflow::ProcessUnitaryObjs(CPDF_PageObjects *pObjs, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix)
+{
+    if(!pObjs) {
+        return;
+    }
+    CFX_FloatRect ObjBBox = pObjs->CalcBoundingBox();
+    objMatrix.TransformRect(ObjBBox);
+    FX_FLOAT ObjWidth = ObjBBox.Width();
+    FX_FLOAT ObjHeight = ObjBBox.Height();
+    CFX_AffineMatrix matrix;
+    if(ObjWidth <= reflowWidth - m_fCurrLineWidth) {
+        matrix.Set(1, 0, 0, 1, m_fCurrLineWidth , 0);
+    } else if(ObjWidth <= reflowWidth) {
+        FinishedCurrLine();
+        matrix.Set(1, 0, 0, 1, 0, 0);
+    } else {
+        FinishedCurrLine();
+        FX_FLOAT f = reflowWidth / ObjWidth ;
+        matrix.Set(f, 0, 0, f, 0, 0);
+    }
+    CFX_AffineMatrix tempMatrix = matrix;
+    matrix.Concat(objMatrix);
+    FX_POSITION pos = pObjs->GetFirstObjectPosition();
+    while(pos) {
+        CPDF_PageObject* pObj = pObjs->GetNextObject(pos);
+        if(pObj->m_Type == PDFPAGE_TEXT) {
+            FX_INT32 ret = LogicPreObj((CPDF_TextObject*)pObj);
+            if(ret == 1 || ret == 2) {
+                continue;
+            }
+        }
+        CreateRFData(pObj, &matrix);
+    }
+    if (m_pTempLine) {
+        Transform(&tempMatrix, m_pTempLine, 0, m_pTempLine->GetSize());
+        AddTemp2CurrLine(0, m_pTempLine->GetSize());
+        m_pTempLine->RemoveAll();
+    }
+}
+void CPDF_LayoutProcessor_Reflow::ProcessPathObject(CPDF_PathObject *pObj, FX_FLOAT reflowWidth)
+{
+}
diff --git a/core/src/reflow/layoutprovider_taggedpdf.cpp b/core/src/reflow/layoutprovider_taggedpdf.cpp
new file mode 100644
index 0000000000..c40c1cdb64
--- /dev/null
+++ b/core/src/reflow/layoutprovider_taggedpdf.cpp
@@ -0,0 +1,780 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "layoutprovider_taggedpdf.h"
+CPDF_LayoutElement::CPDF_LayoutElement()
+{
+    m_pTaggedElement = NULL;
+    m_pParentElement = NULL;
+}
+CPDF_LayoutElement::~CPDF_LayoutElement()
+{
+    m_ObjArray.RemoveAll();
+    int size = m_ChildArray.GetSize();
+    for(int i = 0; i < size; i++) {
+        CPDF_LayoutElement* pChild = (CPDF_LayoutElement*)m_ChildArray.GetAt(i);
+        delete pChild;
+        pChild = NULL;
+    }
+    m_ChildArray.RemoveAll();
+}
+LayoutType CPDF_LayoutElement::ConvertLayoutType(FX_BSTR name)
+{
+    if(name == (const char*)("Document")) {
+        return LayoutDocument;
+    } else if(name == (const char*)("Part")) {
+        return LayoutPart;
+    } else if(name == (const char*)("Art")) {
+        return LayoutArt;
+    } else if(name == (const char*)("Sect")) {
+        return LayoutSect;
+    } else if(name == (const char*)("Div")) {
+        return LayoutDiv;
+    } else if(name == (const char*)("BlockQuote")) {
+        return LayoutBlockQuote;
+    } else if(name == (const char*)("Caption")) {
+        return LayoutCaption;
+    } else if(name == (const char*)("TOC")) {
+        return LayoutTOC;
+    } else if(name == (const char*)("TOCI")) {
+        return LayoutTOCI;
+    } else if(name == (const char*)("Index")) {
+        return LayoutIndex;
+    } else if(name == (const char*)("NonStruct")) {
+        return LayoutNonStruct;
+    } else if(name == (const char*)("Private")) {
+        return LayoutPrivate;
+    } else if(name == (const char*)("P")) {
+        return LayoutParagraph;
+    } else if(name == (const char*)("H")) {
+        return LayoutHeading;
+    } else if(name == (const char*)("H1")) {
+        return LayoutHeading1;
+    } else if(name == (const char*)("H2")) {
+        return LayoutHeading2;
+    } else if(name == (const char*)("H3")) {
+        return LayoutHeading3;
+    } else if(name == (const char*)("H4")) {
+        return LayoutHeading4;
+    } else if(name == (const char*)("H5")) {
+        return LayoutHeading5;
+    } else if(name == (const char*)("H6")) {
+        return LayoutHeading6;
+    } else if(name == (const char*)("L")) {
+        return LayoutList;
+    } else if(name == (const char*)("LI")) {
+        return LayoutListItem;
+    } else if(name == (const char*)("Lbl")) {
+        return LayoutListLabel;
+    } else if(name == (const char*)("LBody")) {
+        return LayoutListBody;
+    } else if(name == (const char*)("Table")) {
+        return LayoutTable;
+    } else if(name == (const char*)("TR")) {
+        return LayoutTableRow;
+    } else if(name == (const char*)("TH")) {
+        return LayoutTableHeaderCell;
+    } else if(name == (const char*)("TD")) {
+        return LayoutTableDataCell;
+    } else if(name == (const char*)("THead")) {
+        return LayoutTableHeaderGroup;
+    } else if(name == (const char*)("TBody")) {
+        return LayoutTableBodyGroup;
+    } else if(name == (const char*)("TFoot")) {
+        return LayoutTableFootGroup;
+    } else if(name == (const char*)("Span")) {
+        return LayoutSpan;
+    } else if(name == (const char*)("Quote")) {
+        return LayoutQuote;
+    } else if(name == (const char*)("Note")) {
+        return LayoutNote;
+    } else if(name == (const char*)("Reference")) {
+        return LayoutReference;
+    } else if(name == (const char*)("BibEntry")) {
+        return LayoutBibEntry;
+    } else if(name == (const char*)("Code")) {
+        return LayoutCode;
+    } else if(name == (const char*)("Link")) {
+        return LayoutLink;
+    } else if(name == (const char*)("Annot")) {
+        return LayoutAnnot;
+    } else if(name == (const char*)("Ruby")) {
+        return LayoutRuby;
+    } else if(name == (const char*)("RB")) {
+        return LayoutRubyBase;
+    } else if(name == (const char*)("RT")) {
+        return LayoutRubyAnnot;
+    } else if(name == (const char*)("RP")) {
+        return LayoutRubyPunc;
+    } else if(name == (const char*)("Warichu")) {
+        return LayoutWarichu;
+    } else if(name == (const char*)("WT")) {
+        return LayoutWarichuText;
+    } else if(name == (const char*)("WP")) {
+        return LayoutWarichuPunc;
+    } else if(name == (const char*)("Figure")) {
+        return LayoutFigure;
+    } else if(name == (const char*)("Formula")) {
+        return LayoutFormula;
+    } else if(name == (const char*)("Form")) {
+        return LayoutForm;
+    } else {
+        return LayoutUnknown;
+    }
+}
+CFX_ByteStringC CPDF_LayoutElement::ConvertLayoutType(LayoutType type)
+{
+    FX_BSTR name = "";
+    if(type == LayoutArifact) {
+        return "Arifact";
+    } else if( type == LayoutDocument) {
+        return "Document";
+    } else if( type == LayoutPart) {
+        return "Part";
+    } else if( type == LayoutArt) {
+        return "Art";
+    } else if( type == LayoutSect) {
+        return "Sect";
+    } else if( type == LayoutDiv) {
+        return "Div";
+    } else if( type == LayoutBlockQuote) {
+        return "BlockQuote";
+    } else if( type == LayoutCaption) {
+        return "Caption";
+    } else if( type == LayoutTOC) {
+        return "TOC";
+    } else if( type == LayoutTOCI) {
+        return "TOCI";
+    } else if( type == LayoutIndex) {
+        return "Index";
+    } else if( type == LayoutNonStruct) {
+        return "NonStruct";
+    } else if( type == LayoutPrivate) {
+        return "Private";
+    } else if( type == LayoutParagraph) {
+        return "P";
+    } else if( type == LayoutHeading) {
+        return "H";
+    } else if( type == LayoutHeading1) {
+        return "H1";
+    } else if( type == LayoutHeading2) {
+        return "H2";
+    } else if( type == LayoutHeading3) {
+        return "H3";
+    } else if( type == LayoutHeading4) {
+        return "H4";
+    } else if( type == LayoutHeading5) {
+        return "H5";
+    } else if( type == LayoutHeading6) {
+        return "H6";
+    } else if( type == LayoutList) {
+        return "L";
+    } else if( type == LayoutListItem) {
+        return "LI";
+    } else if( type == LayoutListLabel) {
+        return "Lbl";
+    } else if( type == LayoutListBody) {
+        return "LBody";
+    } else if( type == LayoutTable) {
+        return "Table";
+    } else if( type == LayoutTableRow) {
+        return "TR";
+    } else if( type == LayoutTableHeaderCell) {
+        return "TH";
+    } else if( type == LayoutTableDataCell) {
+        return "TD";
+    } else if( type == LayoutTableHeaderGroup) {
+        return "THead";
+    } else if( type == LayoutTableBodyGroup) {
+        return "TBody";
+    } else if( type == LayoutTableFootGroup) {
+        return "TFoot";
+    } else if( type == LayoutSpan) {
+        return "Span";
+    } else if( type == LayoutQuote) {
+        return "Quote";
+    } else if( type == LayoutNote) {
+        return "Note";
+    } else if( type == LayoutReference) {
+        return "Reference";
+    } else if( type == LayoutBibEntry) {
+        return "BibEntry";
+    } else if( type == LayoutCode) {
+        return "Code";
+    } else if( type == LayoutLink) {
+        return "Link";
+    } else if( type == LayoutAnnot) {
+        return "Annot";
+    } else if( type == LayoutRuby) {
+        return "Ruby";
+    } else if( type == LayoutRubyBase) {
+        return "RB";
+    } else if( type == LayoutRubyAnnot) {
+        return "RT";
+    } else if( type == LayoutRubyPunc) {
+        return "RP";
+    } else if( type == LayoutWarichu) {
+        return "Warichu";
+    } else if( type == LayoutWarichuText) {
+        return "WT";
+    } else if( type == LayoutWarichuPunc) {
+        return "WP";
+    } else if( type == LayoutFigure) {
+        return "Figure";
+    } else if( type == LayoutFormula) {
+        return "Formula";
+    } else if( type == LayoutForm) {
+        return "Form";
+    }
+    return name;
+}
+CFX_ByteStringC CPDF_LayoutElement::ConvertLayoutAttr(LayoutAttr attr)
+{
+    switch(attr) {
+        case LayoutArtifactType:
+            return "Type";
+        case LayoutArtifactAttached:
+            return "Attached";
+        case LayoutArtifactSubType:
+            return "Subtype";
+        case LayoutPlacement:
+            return "Placement";
+        case LayoutWritingMode:
+            return "WritingMode";
+        case LayoutBackgroundColor:
+            return "BackgroundColor";
+        case LayoutBorderColor:
+            return "BorderColor";
+        case LayoutBorderStyle:
+            return "BorderStyle";
+        case LayoutBorderThickness:
+            return "BorderThickness";
+        case LayoutPadding:
+            return "Padding";
+        case LayoutColor:
+            return "Color";
+        case LayoutSpaceBefore:
+            return "SpaceBefore";
+        case LayoutSpaceAfter:
+            return "SpaceAfter";
+        case LayoutStartIndent:
+            return "StartIndent";
+        case LayoutEndIndent:
+            return "EndIndent";
+        case LayoutTextIndent:
+            return "TextIndent";
+        case LayoutTextAlign:
+            return "TextAlign";
+        case LayoutBBox:
+            return "BBox";
+        case LayoutWidth:
+            return "Width";
+        case LayoutHeight:
+            return "Height";
+        case LayoutBlockAlign:
+            return "BlockAlign";
+        case LayoutInlineAlign:
+            return "InlineAlign";
+        case LayoutTBorderStyle:
+            return "TBorderStyle";
+        case LayoutTPadding:
+            return "TPadding";
+        case LayoutBaselineShift:
+            return "BaselineShift";
+        case LayoutLineHeight:
+            return "LineHeight";
+        case LayoutTextDecorationColor:
+            return "TextDecorationColor";
+        case LayoutTextDecorationThickness:
+            return "TextDecorationThickness";
+        case LayoutTextDecorationType:
+            return "TextDecorationType";
+        case LayoutRubyAlign:
+            return "RubyAlign";
+        case LayoutRubyPosition:
+            return "RubyPosition";
+        case LayoutGlyphOrientationVertical:
+            return "GlyphOrientationVertical";
+        case LayoutColumnCount:
+            return "ColumnCount";
+        case LayoutColumnGap:
+            return "ColumnGap";
+        case LayoutColumnWidths:
+            return "ColumnWidths";
+        case LayoutListNumbering:
+            return "ListNumbering";
+        case LayoutFieldRole:
+            return "Role";
+        case LayoutFieldChecked:
+            return "checked";
+        case LayoutFieldDesc:
+            return "Desc";
+        case LayoutRowSpan:
+            return "RowSpan";
+        case LayoutColSpan:
+            return "ColSpan";
+        case LayoutTableHeaders:
+            return "Headers";
+        case LayoutTableHeaderScope:
+            return "Scope";
+        case LayoutTableSummary:
+            return "Summary";
+        default:
+            return "";
+    }
+}
+LayoutEnum CPDF_LayoutElement::ConvertLayoutEnum(CFX_ByteStringC Enum)
+{
+    if(Enum == "Block") {
+        return LayoutBlock;
+    } else if (Enum == "Inline") {
+        return LayoutInline;
+    } else if (Enum == "Before") {
+        return LayoutBefore;
+    } else if (Enum == "Start") {
+        return LayoutStart;
+    } else if (Enum == "End") {
+        return LayoutEnd;
+    } else if (Enum == "LrTb") {
+        return LayoutLrTb;
+    } else if (Enum == "RlTb") {
+        return LayoutRlTb;
+    } else if (Enum == "TbRl") {
+        return LayoutTbRl;
+    } else if (Enum == "None") {
+        return LayoutNone;
+    } else if (Enum == "Hidden") {
+        return LayoutHidden;
+    } else if (Enum == "Dotted") {
+        return LayoutDotted;
+    } else if (Enum == "Dashed") {
+        return LayoutDashed;
+    } else if (Enum == "Solid") {
+        return LayoutSolid;
+    } else if (Enum == "Double") {
+        return LayoutDouble;
+    } else if (Enum == "Groove") {
+        return LayoutGroove;
+    } else if (Enum == "Ridge") {
+        return LayoutRidge;
+    } else if (Enum == "Inset") {
+        return LayoutInset;
+    } else if (Enum == "Outset") {
+        return LayoutOutset;
+    } else if (Enum == "Normal") {
+        return LayoutNormal;
+    } else if (Enum == "Auto") {
+        return LayoutAuto;
+    } else if (Enum == "Center") {
+        return LayoutCenter;
+    } else if (Enum == "Justify") {
+        return LayoutJustify;
+    } else if (Enum == "Middle") {
+        return LayoutMiddle;
+    } else if (Enum == "Underline") {
+        return LayoutUnderline;
+    } else if (Enum == "Overline") {
+        return LayoutOverline;
+    } else if (Enum == "LineThrough") {
+        return LayoutLineThrough;
+    } else if (Enum == "Distribute") {
+        return LayoutDistribute;
+    } else if (Enum == "Disc") {
+        return LayoutDisc;
+    } else if (Enum == "Circle") {
+        return LayoutCircle;
+    } else if (Enum == "Square") {
+        return LayoutSquare;
+    } else if (Enum == "Decimal") {
+        return LayoutDecimal;
+    } else if (Enum == "UpperRoman") {
+        return LayoutUpperRoman;
+    } else if (Enum == "LowerRoman") {
+        return LayoutLowerRoman;
+    } else if (Enum == "UpperAlpha") {
+        return LayoutUpperAlpha;
+    } else if (Enum == "LowerAlpha") {
+        return LayoutLowerAlpha;
+    } else if (Enum == "rb") {
+        return LayoutRB;
+    } else if (Enum == "cb") {
+        return LayoutCB;
+    } else if (Enum == "pb") {
+        return LayoutPB;
+    } else if (Enum == "tv") {
+        return LayoutTV;
+    } else if (Enum == "on") {
+        return LayoutOn;
+    } else if (Enum == "off") {
+        return LayoutOff;
+    } else if (Enum == "neutral") {
+        return LayoutNeutral;
+    } else if (Enum == "Row") {
+        return LayoutRow;
+    } else if (Enum == "Column") {
+        return LayoutColumn;
+    } else if (Enum == "Both") {
+        return LayoutBoth;
+    } else if (Enum == "Left") {
+        return LayoutLeft;
+    } else if (Enum == "Top") {
+        return LayoutTop;
+    } else if (Enum == "Bottom") {
+        return LayoutBottom;
+    } else if (Enum == "Right") {
+        return LayoutRight;
+    } else if (Enum == "Pagination") {
+        return LayoutPagination;
+    } else if (Enum == "Layout") {
+        return LayoutLayout;
+    } else if (Enum == "Page") {
+        return LayoutPage;
+    } else if (Enum == "Background") {
+        return LayoutBackground;
+    } else if (Enum == "Header") {
+        return LayoutHeader;
+    } else if (Enum == "Footer") {
+        return LayoutFooter;
+    } else if (Enum == "Watermark") {
+        return LayoutWatermark;
+    } else {
+        return LayoutInvalid;
+    }
+}
+LayoutType CPDF_LayoutElement::GetType()
+{
+    if(!m_pTaggedElement) {
+        return LayoutUnknown;
+    }
+    CFX_ByteString name = m_pTaggedElement->GetType();
+    return this->ConvertLayoutType(name);
+}
+int	CPDF_LayoutElement::CountAttrValues(LayoutAttr attr_type)
+{
+    if(!m_pTaggedElement) {
+        return 0;
+    }
+    CPDF_Object* pObj = m_pTaggedElement->GetAttr(GetAttrOwner(attr_type), ConvertLayoutAttr(attr_type), IsInheritable(attr_type));
+    if(pObj) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+LayoutEnum CPDF_LayoutElement::GetEnumAttr(LayoutAttr attr_type, int index)
+{
+    if(!m_pTaggedElement) {
+        return LayoutInvalid;
+    }
+    CFX_ByteStringC owner = GetAttrOwner(attr_type);
+    CFX_ByteStringC default_value = GetDefaultNameValue(attr_type);
+    CFX_ByteStringC AttrName = ConvertLayoutAttr(attr_type);
+    CFX_ByteString	AttrValue = m_pTaggedElement->GetName(owner, AttrName, default_value, IsInheritable(attr_type), index);
+    return ConvertLayoutEnum(AttrValue);
+}
+CFX_ByteStringC CPDF_LayoutElement::GetAttrOwner(LayoutAttr attr_type)
+{
+    switch(attr_type) {
+        case LayoutListNumbering:
+            return "List";
+        case LayoutFieldRole:
+        case LayoutFieldChecked :
+        case LayoutFieldDesc:
+            return "PrintField";
+        case LayoutRowSpan:
+        case LayoutColSpan:
+        case LayoutTableHeaders:
+        case LayoutTableHeaderScope:
+        case LayoutTableSummary:
+            return "Table";
+        default:
+            return "Layout";
+    }
+}
+FX_FLOAT	CPDF_LayoutElement::GetNumberAttr(LayoutAttr attr_type, int index)
+{
+    if(!m_pTaggedElement) {
+        return 0;
+    }
+    CFX_ByteStringC owner = GetAttrOwner(attr_type);
+    FX_FLOAT default_value = GetDefaultFloatValue(attr_type);
+    CFX_ByteStringC AttrName = ConvertLayoutAttr(attr_type);
+    FX_FLOAT f = m_pTaggedElement->GetNumber(owner, AttrName, default_value, IsInheritable(attr_type), index);
+    if(attr_type == LayoutWidth && !f) {
+        f = m_pTaggedElement->GetNumber("Table", AttrName, default_value, IsInheritable(attr_type), index);
+    }
+    return f;
+}
+FX_COLORREF	CPDF_LayoutElement::GetColorAttr(LayoutAttr attr_type, int index)
+{
+    if(!m_pTaggedElement) {
+        return 0;
+    }
+    CFX_ByteStringC owner = GetAttrOwner(attr_type);
+    FX_COLORREF default_value = GetDefaultColorValue(attr_type);
+    CFX_ByteStringC AttrName = ConvertLayoutAttr(attr_type);
+    FX_ARGB f = m_pTaggedElement->GetColor(owner, AttrName, default_value, IsInheritable(attr_type), index);
+    return f;
+}
+FX_FLOAT CPDF_LayoutElement::GetDefaultFloatValue(LayoutAttr attr_type)
+{
+    switch(attr_type) {
+        case LayoutColumnCount:
+            return 1;
+        case LayoutRowSpan:
+            return 1;
+        case LayoutColSpan:
+            return 1;
+        default:
+            return 0;
+    }
+}
+FX_COLORREF CPDF_LayoutElement::GetDefaultColorValue(LayoutAttr attr_type)
+{
+    return -1;
+}
+CFX_ByteStringC CPDF_LayoutElement::GetDefaultNameValue(LayoutAttr attr_type)
+{
+    switch(attr_type) {
+        case LayoutPlacement:
+            return "Inline";
+        case LayoutWritingMode:
+            return "LrTb";
+        case LayoutBorderStyle:
+            return "None";
+        case LayoutTextAlign:
+            return "Start";
+        case LayoutBlockAlign:
+            return "Before";
+        case LayoutInlineAlign:
+            return "Start";
+        case LayoutTBorderStyle:
+            return "None";
+        case LayoutTextDecorationType:
+            return "None";
+        case LayoutRubyAlign:
+            return "Distribute";
+        case LayoutRubyPosition:
+            return "Before";
+        case LayoutGlyphOrientationVertical:
+            return "Auto";
+        case LayoutListNumbering:
+            return "None";
+        case LayoutFieldRole:
+            return "None";
+        default:
+            return "";
+    }
+}
+FX_BOOL	CPDF_LayoutElement::IsInheritable(LayoutAttr type)
+{
+    switch(type) {
+        case LayoutWritingMode:
+        case LayoutTextAlign:
+        case LayoutBlockAlign:
+        case LayoutInlineAlign:
+        case LayoutLineHeight:
+        case LayoutGlyphOrientationVertical:
+        case LayoutRubyAlign:
+        case LayoutRubyPosition:
+        case LayoutBorderThickness:
+        case LayoutStartIndent:
+        case LayoutEndIndent:
+        case LayoutTextIndent:
+        case LayoutTPadding:
+        case LayoutTextDecorationThickness:
+        case LayoutBorderColor:
+        case LayoutColor:
+        case LayoutTextDecorationColor:
+            return TRUE;
+        default:
+            return FALSE;
+    }
+}
+int	CPDF_LayoutElement::CountChildren()
+{
+    return m_ChildArray.GetSize();
+}
+IPDF_LayoutElement* CPDF_LayoutElement::GetChild(int index)
+{
+    return (IPDF_LayoutElement*)m_ChildArray.GetAt(index);
+}
+IPDF_LayoutElement* CPDF_LayoutElement::GetParent()
+{
+    return m_pParentElement;
+}
+int	CPDF_LayoutElement::CountObjects()
+{
+    if(m_pTaggedElement == NULL) {
+        return 0;
+    }
+    CFX_PtrArray* pObj = &m_ObjArray;
+    int size = pObj->GetSize();
+    return size;
+}
+CPDF_PageObject* CPDF_LayoutElement::GetObject(int index)
+{
+    if(m_pTaggedElement == NULL) {
+        return NULL;
+    }
+    CFX_PtrArray *pObj = &m_ObjArray;
+    int size = pObj->GetSize();
+    if(index < size) {
+        return (CPDF_PageObject*)pObj->GetAt(index);
+    }
+    return NULL;
+}
+FX_BOOL CPDF_LayoutElement::AddObject(CPDF_PageObject* pObj)
+{
+    return m_ObjArray.Add(pObj);
+}
+IPDF_LayoutProvider* IPDF_LayoutProvider::Create_LayoutProvider_TaggedPDF(CPDF_PageObjects* pPage)
+{
+    if(pPage == NULL) {
+        return NULL;
+    }
+    CPDF_LayoutProvider_TaggedPDF* pProvider = FX_NEW CPDF_LayoutProvider_TaggedPDF;
+    if (!pProvider) {
+        return NULL;
+    }
+    pProvider->Init(pPage);
+    return pProvider;
+}
+CPDF_LayoutProvider_TaggedPDF::CPDF_LayoutProvider_TaggedPDF()
+{
+    m_pPause = NULL;
+    m_pRoot = NULL;
+    m_pPageTree = NULL;
+    m_pCurTaggedElement = NULL;
+}
+CPDF_LayoutProvider_TaggedPDF::~CPDF_LayoutProvider_TaggedPDF()
+{
+    m_pCurTaggedElement = NULL;
+    m_pPause = NULL;
+    if(m_pRoot) {
+        delete m_pRoot;
+    }
+    m_pRoot = NULL;
+    if(m_pPageTree) {
+        delete m_pPageTree;
+    }
+    m_pPageTree = NULL;
+}
+void CPDF_LayoutProvider_TaggedPDF::ProcessElement(CPDF_LayoutElement*pParent, CPDF_StructElement* pTaggedElement)
+{
+    if(!pTaggedElement) {
+        return;
+    }
+    if(!pParent) {
+        m_Status = LayoutError;
+        return;
+    }
+    CPDF_LayoutElement* pElement = FX_NEW CPDF_LayoutElement;
+    if (!pElement) {
+        m_Status = LayoutError;
+        return;
+    }
+    pElement->m_pParentElement = pParent;
+    pElement->m_pTaggedElement = pTaggedElement;
+    pParent->m_ChildArray.Add(pElement);
+    int count = pTaggedElement->CountKids();
+    for(int i = 0; i < count; i++) {
+        CPDF_StructKid Kid = pTaggedElement->GetKid(i);
+        switch(Kid.m_Type) {
+            case CPDF_StructKid::Element: {
+                    ProcessElement(pElement, Kid.m_Element.m_pElement);
+                    if(m_Status != LayoutReady) {
+                        return ;
+                    }
+                }
+                break;
+            case CPDF_StructKid::PageContent: {
+                    int count = m_pPage->CountObjects();
+                    FX_POSITION pos = m_pPage->GetFirstObjectPosition();
+                    if(!pos) {
+                        m_Status = LayoutError;
+                        return ;
+                    }
+                    while (pos) {
+                        CPDF_PageObject* pObj = m_pPage->GetNextObject(pos);
+                        int pbjMCID = pObj->m_ContentMark.GetMCID();
+                        if((FX_DWORD)(pObj->m_ContentMark.GetMCID()) == Kid.m_PageContent.m_ContentId) {
+                            pElement->AddObject(pObj);
+                        }
+                    }
+                }
+                break;
+            case CPDF_StructKid::StreamContent:
+            case CPDF_StructKid::Object:
+            default:
+                break;
+        }
+    }
+}
+LayoutStatus CPDF_LayoutProvider_TaggedPDF::StartLoad(IFX_Pause* pPause)
+{
+    m_pPause = pPause;
+    if(m_pPage->m_pDocument && m_pPage->m_pFormDict) {
+        m_pPageTree = CPDF_StructTree::LoadPage(m_pPage->m_pDocument, m_pPage->m_pFormDict);
+    }
+    if(!m_pPageTree) {
+        m_Status = LayoutError;
+        return LayoutError;
+    }
+    int count = m_pPageTree->CountTopElements();
+    if(count == 0) {
+        m_Status = LayoutError;
+        return LayoutError;
+    }
+    m_pRoot = FX_NEW CPDF_LayoutElement;
+    if (!m_pRoot) {
+        m_Status = LayoutError;
+        return LayoutError;
+    }
+    for(int i = 0; i < count; i++) {
+        CPDF_StructElement* pElement = m_pPageTree->GetTopElement(i);
+        if(pElement) {
+            ProcessElement(m_pRoot, pElement);
+            if(m_Status != LayoutReady) {
+                return m_Status;
+            }
+        }
+    }
+    m_pCurTaggedElement = NULL;
+    m_Status = LayoutFinished;
+    return LayoutFinished;
+}
+LayoutStatus CPDF_LayoutProvider_TaggedPDF::Continue()
+{
+    if(!m_pCurTaggedElement) {
+        return LayoutError;
+    }
+    if(m_Status != LayoutToBeContinued) {
+        return LayoutError;
+    }
+    m_Status = LayoutReady;
+    int count = m_pPageTree->CountTopElements();
+    for(int i = 0; i < count; i++) {
+        CPDF_StructElement* pElement = m_pPageTree->GetTopElement(i);
+        if(pElement) {
+            ProcessElement(m_pRoot, pElement);
+            if(m_Status != LayoutReady) {
+                return m_Status;
+            }
+        }
+    }
+    m_pCurTaggedElement = NULL;
+    m_Status = LayoutFinished;
+    return LayoutFinished;
+}
+int CPDF_LayoutProvider_TaggedPDF::GetPosition()
+{
+    if(m_TopElementIndex == 0) {
+        return 0;
+    }
+    int count = m_pPageTree->CountTopElements();
+    return m_TopElementIndex / count * 100;
+}
diff --git a/core/src/reflow/layoutprovider_taggedpdf.h b/core/src/reflow/layoutprovider_taggedpdf.h
new file mode 100644
index 0000000000..b2c8947a82
--- /dev/null
+++ b/core/src/reflow/layoutprovider_taggedpdf.h
@@ -0,0 +1,82 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#ifndef LayoutProvider_TaggedPDF_H
+#define LayoutProvider_TaggedPDF_H
+#include "../../include/reflow/reflowengine.h"
+class CPDF_LayoutElement : public IPDF_LayoutElement, public CFX_Object
+{
+public:
+    CPDF_LayoutElement();
+    ~CPDF_LayoutElement();
+
+    LayoutType	GetType();
+    void	GetRect(CFX_FloatRect& rcRect) {};
+
+    int		CountAttrValues(LayoutAttr attr_type);
+
+    LayoutEnum	GetEnumAttr(LayoutAttr attr_type, int index);
+    FX_FLOAT	GetNumberAttr(LayoutAttr attr_type, int index);
+    FX_COLORREF	GetColorAttr(LayoutAttr attr_type, int index);
+
+    int		CountChildren();
+
+    IPDF_LayoutElement* GetChild(int index);
+
+    IPDF_LayoutElement* GetParent();
+
+    int	CountObjects();
+    CPDF_PageObject*	GetObject(int index);
+    FX_BOOL AddObject(CPDF_PageObject* pObj);
+    CPDF_StructElement* m_pTaggedElement;
+    CPDF_LayoutElement* m_pParentElement;
+    CFX_PtrArray	m_ChildArray;
+    LayoutType ConvertLayoutType(FX_BSTR name);
+    CFX_ByteStringC ConvertLayoutType(LayoutType type);
+    CFX_ByteStringC ConvertLayoutAttr(LayoutAttr attr);
+    LayoutEnum ConvertLayoutEnum(CFX_ByteStringC Enum);
+
+protected:
+    FX_BOOL		IsInheritable(LayoutAttr attr_type);
+    CFX_ByteStringC GetAttrOwner(LayoutAttr attr_type);
+    CFX_ByteStringC GetDefaultNameValue(LayoutAttr attr_type);
+    FX_FLOAT		GetDefaultFloatValue(LayoutAttr attr_type);
+    FX_COLORREF		GetDefaultColorValue(LayoutAttr attr_type);
+    CFX_PtrArray	m_ObjArray;
+};
+class CPDF_LayoutProvider_TaggedPDF : public IPDF_LayoutProvider, public CFX_Object
+{
+public:
+    CPDF_LayoutProvider_TaggedPDF();
+    ~CPDF_LayoutProvider_TaggedPDF();
+    void			SetLayoutProviderStyle(LAYOUTPROVIDER_STYLE style) {};
+
+    void	Init(CPDF_PageObjects* pPage)
+    {
+        m_pPage = pPage;
+        m_Status = LayoutReady;
+    };
+
+    LayoutStatus	StartLoad(IFX_Pause* pPause = NULL);
+    LayoutStatus	Continue();
+    int		 		GetPosition();
+
+    IPDF_LayoutElement* GetRoot()
+    {
+        return m_pRoot;
+    };
+
+protected:
+    void ProcessElement(CPDF_LayoutElement*pParent, CPDF_StructElement* pTaggedElement);
+    LayoutStatus	m_Status;
+    CPDF_StructElement* m_pCurTaggedElement;
+    CPDF_LayoutElement* m_pRoot;
+    IFX_Pause*			m_pPause;
+    CPDF_PageObjects*	m_pPage;
+    CPDF_StructTree*	m_pPageTree;
+    int					m_TopElementIndex;
+};
+#endif
diff --git a/core/src/reflow/reflowedpage.cpp b/core/src/reflow/reflowedpage.cpp
new file mode 100644
index 0000000000..11baef8718
--- /dev/null
+++ b/core/src/reflow/reflowedpage.cpp
@@ -0,0 +1,622 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "../../include/reflow/reflowengine.h"
+#include "reflowedpage.h"
+CPDF_ProgressiveReflowPageParser::CPDF_ProgressiveReflowPageParser()
+{
+    m_nObjProcessed = 0;
+    m_pReflowEngine = NULL;
+    m_pProvider = NULL;
+}
+CPDF_ProgressiveReflowPageParser::~CPDF_ProgressiveReflowPageParser()
+{
+    if(m_pProvider) {
+        delete m_pProvider;
+    }
+    m_pProvider = NULL;
+    if(m_pReflowEngine) {
+        delete m_pReflowEngine;
+    }
+    m_pReflowEngine = NULL;
+}
+void CPDF_ProgressiveReflowPageParser::Init()
+{
+    m_Status = Ready;
+}
+CPDF_ReflowedPage::CPDF_ReflowedPage(CFX_GrowOnlyPool*	pMemoryPool)
+{
+    m_PageWidth = 0;
+    m_PageHeight = 0;
+    m_bWaiting = TRUE;
+    if(pMemoryPool) {
+        m_pMemoryPool = pMemoryPool;
+        m_bCreateMemoryPool = FALSE;
+    } else {
+        m_pMemoryPool = FX_NEW CFX_GrowOnlyPool;
+        m_bCreateMemoryPool = TRUE;
+    }
+    m_pCharState = FX_NEW CRF_CharStateArray(10);
+    m_pReflowed = FX_NEW CRF_DataPtrArray(500);
+    m_pPageInfos = NULL;
+}
+CPDF_ReflowedPage::~CPDF_ReflowedPage()
+{
+    if (m_pReflowed) {
+        for(int i = 0; i < m_pReflowed->GetSize(); i++) {
+            CRF_Data* pData = (*m_pReflowed)[i];
+            if(pData->m_Type == CRF_Data::Image) {
+                delete ((CRF_ImageData*)pData)->m_pBitmap;
+            }
+        }
+        m_pReflowed->RemoveAll();
+        delete m_pReflowed;
+    }
+    m_pReflowed = NULL;
+    if (m_pCharState) {
+        m_pCharState->RemoveAll();
+        delete m_pCharState;
+    }
+    m_pCharState = NULL;
+    if(m_bCreateMemoryPool && m_pMemoryPool) {
+        m_pMemoryPool->FreeAll();
+    }
+    if (m_pMemoryPool) {
+        delete m_pMemoryPool;
+    }
+    m_pMemoryPool = NULL;
+    m_pPDFPage = NULL;
+    if (m_pPageInfos) {
+        ReleasePageObjsMemberShip();
+    }
+}
+FX_BOOL CPDF_ReflowedPage::RetainPageObjsMemberShip()
+{
+    if (NULL == m_pPDFPage) {
+        return FALSE;
+    }
+    if (NULL == m_pPageInfos) {
+        m_pPageInfos = FX_NEW CFX_MapPtrToPtr();
+    } else {
+        return TRUE;
+    }
+    FX_POSITION	pos = m_pPDFPage->GetFirstObjectPosition();
+    if (!pos)	{
+        return FALSE;
+    }
+    CPDF_PageObject* pPageObj = NULL;
+    while (pos) {
+        pPageObj = m_pPDFPage->GetNextObject(pos);
+        MarkPageObjMemberShip(pPageObj, NULL);
+        pPageObj = NULL;
+    }
+    return TRUE;
+}
+void CPDF_ReflowedPage::MarkPageObjMemberShip(CPDF_PageObject* pObj, CRF_PageInfo* pParent)
+{
+    if (NULL == m_pPageInfos) {
+        return;
+    }
+    CRF_PageInfo* pPageInfo = FX_NEW CRF_PageInfo(pObj, pParent);
+    if (NULL == pPageInfo) {
+        return;
+    }
+    m_pPageInfos->SetAt(pObj, pPageInfo);
+    if (PDFPAGE_FORM != pObj->m_Type) {
+        return;
+    }
+    CPDF_FormObject* pFormObj = (CPDF_FormObject*)pObj;
+    FX_POSITION	pos;
+    pos = pFormObj->m_pForm->GetFirstObjectPosition();
+    if (!pos)	{
+        return;
+    }
+    CPDF_PageObject* pPageObj = NULL;
+    while (pos) {
+        pPageObj = pFormObj->m_pForm->GetNextObject(pos);
+        MarkPageObjMemberShip(pPageObj, pPageInfo);
+        pPageObj = NULL;
+    }
+}
+void CPDF_ReflowedPage::ReleasePageObjsMemberShip()
+{
+    if (NULL == m_pPageInfos) {
+        return;
+    }
+    CPDF_PageObject* pPageObj = NULL;
+    CRF_PageInfo* pPageInfo = NULL;
+    FX_POSITION pos = m_pPageInfos->GetStartPosition();
+    while (pos) {
+        m_pPageInfos->GetNextAssoc(pos, (void*&)pPageObj, (void*&)pPageInfo);
+        delete pPageInfo;
+    }
+    m_pPageInfos->RemoveAll();
+    delete m_pPageInfos;
+    m_pPageInfos = NULL;
+}
+CPDF_Dictionary* CPDF_ReflowedPage::GetFormResDict(CPDF_PageObject* pObj)
+{
+    if (NULL == m_pPageInfos) {
+        return NULL;
+    }
+    if (FALSE == RetainPageObjsMemberShip()) {
+        return NULL;
+    }
+    CRF_PageInfo* pPageInfo = (CRF_PageInfo*)m_pPageInfos->GetValueAt(pObj);
+    if (NULL == pPageInfo) {
+        return NULL;
+    }
+    return pPageInfo->GetFormDict();
+}
+void CPDF_ReflowedPage::GetDisplayMatrix(CFX_AffineMatrix& matrix, FX_INT32 xPos, FX_INT32 yPos, FX_INT32 xSize, FX_INT32 ySize, FX_INT32 iRotate, const CFX_AffineMatrix* pPageMatrix)
+{
+    CFX_AffineMatrix display_matrix;
+    if(m_PageHeight == 0) {
+        matrix.Set(1, 0, 0, -1, 0, 0);
+        return;
+    }
+    FX_INT32 x0, y0, x1, y1, x2, y2;
+    iRotate %= 4;
+    switch (iRotate) {
+        case 0:
+            x0 = xPos;
+            y0 = yPos;
+            x1 = xPos;
+            y1 = yPos + ySize;
+            x2 = xPos + xSize;
+            y2 = yPos;
+            break;
+        case 3:
+            x0 = xPos;
+            y0 = ySize + yPos;
+            x1 =  xPos + xSize;
+            y1 = yPos + ySize;
+            x2 = xPos;
+            y2 = yPos;
+            break;
+        case 2:
+            x0 = xSize + xPos;
+            y0 = ySize + yPos;
+            x1 = xSize + xPos ;
+            y1 = yPos;
+            x2 = xPos;
+            y2 =  ySize + yPos;
+            break;
+        case 1:
+            x0 = xPos + xSize;
+            y0 = yPos;
+            x1 = xPos;
+            y1 = yPos;
+            x2 = xPos + xSize;
+            y2 = yPos + ySize;
+            break;
+    }
+    display_matrix.Set(FXSYS_Div((FX_FLOAT)(x2 - x0), m_PageWidth),
+                       FXSYS_Div((FX_FLOAT)(y2 - y0), m_PageWidth),
+                       FXSYS_Div((FX_FLOAT)(x1 - x0), m_PageHeight),
+                       FXSYS_Div((FX_FLOAT)(y1 - y0), m_PageHeight),
+                       (FX_FLOAT)(x0), (FX_FLOAT)(y0));
+    matrix.Set(1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
+    matrix.Concat(display_matrix);
+    return;
+}
+FX_FLOAT CPDF_ReflowedPage::GetPageHeight()
+{
+    return m_PageHeight;
+}
+void CPDF_ReflowedPage::FocusGetData(const CFX_AffineMatrix matrix, FX_INT32 x, FX_INT32 y, CFX_ByteString& str)
+{
+    if (NULL == m_pReflowed) {
+        return;
+    }
+    CFX_AffineMatrix revMatrix;
+    revMatrix.SetReverse(matrix);
+    FX_FLOAT x1, y1;
+    revMatrix.Transform((float)x, (float)y, x1, y1);
+    int count = m_pReflowed->GetSize();
+    FX_FLOAT dx = 1000, dy = 1000;
+    FX_INT32 pos = 0;
+    FX_INT32 i;
+    for(i = 0; i < count; i++) {
+        CRF_Data* pData = (*m_pReflowed)[i];
+        FX_FLOAT tempdy = FXSYS_fabs(pData->m_PosY - y1);
+        if(FXSYS_fabs(tempdy - dy) < 1) {
+            continue;
+        }
+        CFX_FloatRect rect (0, pData->m_PosY + pData->m_Height, this->m_PageWidth, pData->m_PosY);
+        if(rect.Contains(x1, y1)) {
+            pos = i;
+            dx = 0;
+            dy = 0;
+            break;
+        } else if(tempdy < dy) {
+            dy = tempdy;
+            dx = FXSYS_fabs(pData->m_PosX - x1);
+            pos = i;
+        } else if (tempdy == dy) {
+            FX_FLOAT tempdx = FXSYS_fabs(pData->m_PosX - x1);
+            if(tempdx < dx) {
+                dx = tempdx;
+                pos = i;
+            }
+        } else if (tempdy > dy) {
+            break;
+        }
+    }
+    if(dx != 0 || dy != 0) {
+        count = count < (pos + 10) ? count : (pos + 10);
+        for(i = 0 > (pos - 10) ? 0 : (pos - 10); i < count; i++) {
+            CRF_Data* pData = (*m_pReflowed)[i];
+            FX_FLOAT tempdy = FXSYS_fabs(pData->m_PosY - y1);
+            if(tempdy < dy) {
+                dy = tempdy;
+                dx = FXSYS_fabs(pData->m_PosX - x1);
+                pos = i;
+            } else if (tempdy == dy) {
+                FX_FLOAT tempdx = FXSYS_fabs(pData->m_PosX - x1);
+                if(tempdx < dx) {
+                    dx = tempdx;
+                    pos = i;
+                }
+            }
+        }
+    }
+    str.Format("%d", pos);
+}
+FX_BOOL CPDF_ReflowedPage::FocusGetPosition(const CFX_AffineMatrix matrix, CFX_ByteString str, FX_INT32& x, FX_INT32& y)
+{
+    if (NULL == m_pReflowed) {
+        return FALSE;
+    }
+    FX_INT32 pos = FXSYS_atoi(str);
+    if(pos < 0 || pos >= m_pReflowed->GetSize()) {
+        return FALSE;
+    }
+    CRF_Data* pData = (*m_pReflowed)[pos];
+    FX_FLOAT x1, y1;
+    matrix.Transform(pData->m_PosX, pData->m_PosY + pData->m_Height, x1, y1);
+    x = (int)x1;
+    y = (int)y1;
+    return TRUE;
+}
+int CPDF_ProgressiveReflowPageParser::GetPosition()
+{
+    if(!m_pProvider) {
+        return 0;
+    }
+    if(!m_pReflowEngine) {
+        return m_pProvider->GetPosition() / 2;
+    }
+    return m_pProvider->GetPosition() / 2 + m_pReflowEngine->GetPosition() / 2;
+}
+void CPDF_ProgressiveReflowPageParser::Continue(IFX_Pause* pPause)
+{
+    if (NULL == m_pReflowPage) {
+        return;
+    }
+    if(m_Status != ToBeContinued) {
+        return;
+    }
+    m_pPause = pPause;
+    if(m_pReflowEngine) {
+        if(m_pReflowEngine->Continue() != LayoutToBeContinued) {
+            m_Status = Done;
+        }
+    } else {
+        if(m_pProvider->Continue() == LayoutFinished) {
+            m_pReflowEngine = IPDF_LayoutProcessor::Create_LayoutProcessor_Reflow(m_TopIndent, m_ReflowedWidth, m_fScreenHeight, m_pReflowPage, m_flags, m_ParseStyle.m_LineSpace);
+            CFX_AffineMatrix matrix;
+            m_pPDFPage->GetDisplayMatrix(matrix, 0, 0, (int)(m_pPDFPage->GetPageWidth()), (int)(m_pPDFPage->GetPageHeight()), 0);
+            if(m_pReflowEngine->StartProcess(m_pProvider->GetRoot(), m_pPause, &matrix) != LayoutToBeContinued) {
+                m_Status = Done;
+            }
+        }
+    }
+    if(m_TopIndent && m_Status == Done) {
+        m_pReflowPage->m_PageHeight -= m_TopIndent;
+    }
+}
+void CPDF_ProgressiveReflowPageParser::Clear()
+{
+    this->Init();
+    return;
+}
+FX_BOOL IPDF_ProgressiveReflowPageParser::IsTaggedPage(CPDF_PageObjects*pPage)
+{
+    if(!pPage) {
+        return FALSE;
+    }
+    CPDF_StructTree* pPageTree = CPDF_StructTree::LoadPage(pPage->m_pDocument, pPage->m_pFormDict);
+    if(pPageTree) {
+        int count = pPageTree->CountTopElements();
+        if(count) {
+            for(int i = 0; i < count; i++) {
+                CPDF_StructElement* pElm = pPageTree->GetTopElement(i);
+                if(pElm) {
+                    delete pPageTree;
+                    pPageTree = NULL;
+                    return TRUE;
+                }
+            }
+        }
+        delete pPageTree;
+        pPageTree = NULL;
+        return FALSE;
+    }
+    return FALSE;
+}
+void CPDF_ProgressiveReflowPageParser::Start(IPDF_ReflowedPage* pReflowPage, CPDF_Page* pPage, FX_FLOAT topIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, IFX_Pause* pPause, int flags)
+{
+    if (NULL == pReflowPage) {
+        m_Status = Failed;
+        return;
+    }
+    m_flags = flags;
+    m_pReflowPage = (CPDF_ReflowedPage*)pReflowPage;
+    m_pReflowPage->m_pPDFPage = pPage;
+    m_pReflowPage->ReleasePageObjsMemberShip();
+    m_pPDFPage = pPage;
+    m_TopIndent = topIndent;
+    m_pPause = pPause;
+    m_fScreenHeight = fHeight;
+    m_ReflowedWidth = fWidth;
+    m_pProvider = IPDF_LayoutProvider::Create_LayoutProvider_TaggedPDF(m_pPDFPage);
+    LayoutStatus status = m_pProvider->StartLoad(pPause);
+    if(status == LayoutError) {
+        delete m_pProvider;
+        m_pProvider = IPDF_LayoutProvider::Create_LayoutProvider_AutoReflow(m_pPDFPage, m_flags & RF_PARSER_READERORDER);
+        if (NULL == m_pProvider) {
+            m_Status = Failed;
+            return;
+        }
+        status = m_pProvider->StartLoad(pPause);
+    }
+    if(status == LayoutError) {
+        delete m_pProvider;
+        m_pProvider = NULL;
+        m_Status = Failed;
+        return;
+    }
+    if(status == LayoutToBeContinued) {
+        m_Status = ToBeContinued;
+    } else if (status == LayoutFinished) {
+        m_pReflowEngine = IPDF_LayoutProcessor::Create_LayoutProcessor_Reflow(topIndent, fWidth, fHeight, pReflowPage, m_flags, m_ParseStyle.m_LineSpace);
+        if(NULL == m_pReflowEngine) {
+            delete m_pProvider;
+            m_pProvider = NULL;
+            m_Status = Failed;
+            return;
+        }
+        CFX_AffineMatrix matrix;
+        pPage->GetDisplayMatrix(matrix, 0, 0, (int)(pPage->GetPageWidth()), (int)(pPage->GetPageHeight()), 0);
+        CFX_AffineMatrix matrix1 = pPage->GetPageMatrix();
+        if((status = m_pReflowEngine->StartProcess(m_pProvider->GetRoot(), pPause, &matrix)) != LayoutToBeContinued) {
+            delete m_pReflowEngine;
+            m_pReflowEngine = NULL;
+            m_Status = Done;
+        } else {
+            m_Status = ToBeContinued;
+        }
+    }
+    if(status != LayoutToBeContinued) {
+        delete m_pProvider;
+        m_pProvider = NULL;
+    }
+    if(m_TopIndent && m_Status == Done) {
+        m_pReflowPage->m_PageHeight -= m_TopIndent;
+    }
+    return;
+}
+CPDF_ProgressiveReflowPageRender::~CPDF_ProgressiveReflowPageRender()
+{
+    if(m_pDisplayMatrix) {
+        delete m_pDisplayMatrix;
+    }
+    m_pDisplayMatrix = NULL;
+}
+CPDF_ProgressiveReflowPageRender::CPDF_ProgressiveReflowPageRender()
+{
+    m_Status = Ready;
+    m_pReflowPage = NULL;
+    m_pDisplayMatrix = NULL;
+    m_CurrNum = 0;
+    m_pFontEncoding = NULL;
+    m_DisplayColor = -1;
+}
+static FX_FLOAT _CIDTransformToFloat(FX_BYTE ch)
+{
+    if (ch < 128) {
+        return ch * 1.0f / 127;
+    }
+    return (-255 + ch) * 1.0f / 127;
+}
+int	CPDF_ProgressiveReflowPageRender::GetPosition()
+{
+    if(m_CurrNum == 0 || NULL == m_pReflowPage) {
+        return 0;
+    }
+    int size = m_pReflowPage->m_pReflowed->GetSize();
+    if(size == 0 || m_CurrNum >= size) {
+        return 100;
+    }
+    return (int)(m_CurrNum * 100 / size);
+}
+void CPDF_ProgressiveReflowPageRender::Display(IFX_Pause* pPause)
+{
+    if (NULL == m_pReflowPage) {
+        m_Status = Done;
+        return;
+    }
+    FX_RECT clipBox = m_pFXDevice->GetClipBox();
+    int size = m_pReflowPage->m_pReflowed->GetSize();
+    if (size < 1 || NULL == m_pDisplayMatrix) {
+        m_Status = Done;
+        return;
+    }
+    for(int i = m_CurrNum; i < size; i++) {
+        CRF_Data* pData = (*m_pReflowPage->m_pReflowed)[i];
+        if(!pData) {
+            continue;
+        }
+        CFX_FloatRect rect (pData->m_PosX, pData->m_PosY + pData->m_Height, pData->m_PosX + pData->m_Width, pData->m_PosY);
+        m_pDisplayMatrix->TransformRect(rect);
+        if(rect.left > clipBox.right || rect.right < clipBox.left || rect.bottom > clipBox.bottom || rect.top < clipBox.top) {
+            continue;
+        }
+        if(pData->GetType() == CRF_Data::Text) {
+            CRF_CharData* pCharData = (CRF_CharData*)pData;
+            CPDF_Font* pPDFFont = pCharData->m_pCharState->m_pFont;
+            if(pPDFFont->GetFontType() == PDFFONT_TYPE3) {
+                continue;
+            }
+            FX_FLOAT x = pData->m_PosX, y = pData->m_PosY - pCharData->m_pCharState->m_fDescent;
+            FXTEXT_CHARPOS charpos ;
+            charpos.m_GlyphIndex = pPDFFont->GlyphFromCharCode(pCharData->m_CharCode);
+            charpos.m_FontCharWidth = pPDFFont->m_Font.GetGlyphWidth(charpos.m_GlyphIndex);
+            charpos.m_OriginX       = x;
+            charpos.m_OriginY       = y;
+            FX_FLOAT charW = pData->m_Width * 1000 / pData->m_Height;
+            if(charW != charpos.m_FontCharWidth) {
+                charpos.m_bGlyphAdjust  = TRUE;
+                charpos.m_AdjustMatrix[0] = charW / charpos.m_FontCharWidth;
+                charpos.m_AdjustMatrix[1] = 0;
+                charpos.m_AdjustMatrix[2] = 0;
+                charpos.m_AdjustMatrix[3] = 1;
+            } else {
+                charpos.m_bGlyphAdjust  = FALSE;
+            }
+            FX_BOOL bRet = FALSE;
+            if(m_DisplayColor == -1)
+                bRet = m_pFXDevice->DrawNormalText(1, &charpos, &(pPDFFont->m_Font),
+                                                   NULL, pCharData->m_pCharState->m_fFontSize,
+                                                   m_pDisplayMatrix, pCharData->m_pCharState->m_Color + 0xff000000, FXTEXT_CLEARTYPE);
+            else
+                bRet = m_pFXDevice->DrawNormalText(1, &charpos, &(pPDFFont->m_Font),
+                                                   NULL, pCharData->m_pCharState->m_fFontSize, m_pDisplayMatrix, m_DisplayColor, FXTEXT_CLEARTYPE);
+        } else if(pData->GetType() == CRF_Data::Image) {
+            CRF_ImageData* pImageData = (CRF_ImageData*)pData;
+            if(!pImageData->m_pBitmap) {
+                continue;
+            }
+            int left = 0, top = 0;
+            CFX_DIBitmap* pDiBmp = NULL;
+            CFX_DIBSource* pDispSource = pImageData->m_pBitmap;
+            if(pImageData->m_Matrix.d < 0) {
+                CFX_AffineMatrix matrix(pImageData->m_Matrix.a, 0, 0, -pImageData->m_Matrix.d, 0, 0);
+                int left, top;
+                pDiBmp = pImageData->m_pBitmap->TransformTo(&matrix, left, top);
+                pDispSource = pDiBmp;
+            }
+            if (NULL == pDispSource) {
+                continue;
+            }
+            if (pDispSource->GetFormat() == FXDIB_1bppMask || pDispSource->GetFormat() == FXDIB_8bppMask) {
+                m_pFXDevice->StretchBitMask(pDispSource, (int)(rect.left + 0.5), (int)(rect.bottom + 0.5), (int)(rect.Width() + 0.5), (int)(rect.Height() + 0.5), 0xff000000);
+            } else {
+                m_pFXDevice->StretchDIBits(pDispSource, (int)(rect.left + 0.5), (int)(rect.bottom + 0.5), (int)(rect.Width() + 0.5), (int)(rect.Height() + 0.5));
+            }
+            if(m_pFXDevice->GetBitmap() && m_pFXDevice->GetBitmap()->GetFormat() == FXDIB_8bppRgb &&
+                    m_pFXDevice->GetBitmap()->GetPalette() == NULL) {
+                int nPalette = 0;
+                switch(m_DitherBits) {
+                    case 0:
+                        nPalette = 0;
+                        break;
+                    case 1:
+                        nPalette = 2;
+                        break;
+                    case 2:
+                        nPalette = 4;
+                        break;
+                    case 3:
+                        nPalette = 8;
+                        break;
+                    case 4:
+                        nPalette = 16;
+                        break;
+                    case 5:
+                        nPalette = 32;
+                        break;
+                    case 6:
+                        nPalette = 64;
+                        break;
+                    case 7:
+                        nPalette = 128;
+                        break;
+                    default:
+                        nPalette = 256;
+                        break;
+                }
+                if(nPalette >= 2) {
+                    FX_ARGB * palette = FX_Alloc(FX_ARGB, nPalette);
+                    nPalette --;
+                    palette[0] = 0;
+                    palette[nPalette] = 255;
+                    FX_FLOAT Dither = (FX_FLOAT)255 / (nPalette);
+                    for(int i = 1; i < nPalette; i++) {
+                        palette[i] = (FX_ARGB)(Dither * i + 0.5);
+                    }
+                    FX_RECT tmpRect = rect.GetOutterRect();
+                    m_pFXDevice->GetBitmap()->DitherFS(palette, nPalette + 1, &tmpRect);
+                    FX_Free (palette);
+                }
+            }
+            if(pDiBmp) {
+                delete pDiBmp;
+            }
+        } else if(pData->GetType() == CRF_Data::Path) {
+        }
+        if(!(i % 10)) {
+            if(pPause && pPause->NeedToPauseNow()) {
+                i++;
+                m_CurrNum = i;
+                m_Status = ToBeContinued;
+                return;
+            }
+        }
+    }
+    m_CurrNum = size;
+    m_Status = Done;
+}
+void CPDF_ProgressiveReflowPageRender::Start(IPDF_ReflowedPage* pReflowPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pMatrix, IFX_Pause* pPause, int DitherBits)
+{
+    if(!pReflowPage || !pDevice || !pMatrix) {
+        m_Status = Failed;
+        return;
+    }
+    m_DitherBits = DitherBits;
+    m_Status = Ready;
+    m_CurrNum = 0;
+    m_pReflowPage = (CPDF_ReflowedPage*)pReflowPage;
+    m_pFXDevice = pDevice;
+    if(NULL == m_pDisplayMatrix) {
+        m_pDisplayMatrix = FX_NEW CFX_AffineMatrix;
+    }
+    if (m_pDisplayMatrix) {
+        m_pDisplayMatrix->Copy(*pMatrix);
+    }
+    m_Status = ToBeContinued;
+    Display(pPause);
+}
+void CPDF_ProgressiveReflowPageRender::Continue(IFX_Pause* pPause)
+{
+    Display(pPause);
+}
+void CPDF_ProgressiveReflowPageRender::SetDisplayColor(FX_COLORREF color)
+{
+    m_DisplayColor = color;
+}
+void CPDF_ProgressiveReflowPageRender::Clear()
+{
+    if (m_pDisplayMatrix) {
+        delete m_pDisplayMatrix;
+    }
+    m_pDisplayMatrix = NULL;
+    m_pReflowPage = NULL;
+    m_pFXDevice = NULL;
+    m_CurrNum = 0;
+    m_Status = Ready;
+}
diff --git a/core/src/reflow/reflowedpage.h b/core/src/reflow/reflowedpage.h
new file mode 100644
index 0000000000..b76834132e
--- /dev/null
+++ b/core/src/reflow/reflowedpage.h
@@ -0,0 +1,372 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#ifndef _REFLOWED_PAGE_H
+#define _REFLOWED_PAGE_H
+#include "../../include/reflow/reflowengine.h"
+#define GET_SIGNED(a) ( (a)>0 ? a/a : (a==0 ? 0 : -a/a) )
+class CRF_Data;
+class CRF_LineData;
+class CRF_CharData;
+class CRF_PathData;
+class CRF_ImageData;
+class CRF_Table;
+class CRF_AttrOperation;
+class CRF_OperationDate;
+class CPDF_ReflowedPage;
+class CPDF_Rect;
+class CFX_Object;
+typedef CFX_SegmentedArray<CRF_Data*> CRF_DataPtrArray;
+class CRF_CharState;
+typedef CFX_SegmentedArray<CRF_CharState> CRF_CharStateArray;
+#define SST_GE		1
+#define SST_BLSE	2
+#define SST_ILSE	3
+#define SST_IE		4
+class CPDF_LayoutProcessor_Reflow : public IPDF_LayoutProcessor, public CFX_Object
+{
+public:
+    CPDF_LayoutProcessor_Reflow();
+    ~CPDF_LayoutProcessor_Reflow();
+    void Init(FX_FLOAT TopIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, CPDF_ReflowedPage* pReflowedPage, int flags, FX_FLOAT lineSpace);
+
+    LayoutStatus	StartProcess(IPDF_LayoutElement* pElement, IFX_Pause* pPause, const CFX_AffineMatrix* pPDFMatrix = NULL);
+    LayoutStatus	Continue();
+    int				GetPosition();
+protected:
+    void	FitPageMode();
+    void	ProcessElement(IPDF_LayoutElement* pElement, FX_FLOAT reflowWidth);
+    FX_FLOAT GetElmWidth(IPDF_LayoutElement* pElement);
+    CFX_FloatRect GetElmBBox(IPDF_LayoutElement* pElement);
+    void	ProcessTable(FX_FLOAT dx);
+    void	ProcessObjs(IPDF_LayoutElement* pElement, FX_FLOAT reflowWidth);
+    void	ProcessObject(CPDF_PageObject* pObj, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix);
+    void	ProcessTextObject(CPDF_TextObject *pObj, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix);
+    void	ProcessPathObject(CPDF_PathObject *pObj, FX_FLOAT reflowWidth);
+    void	ProcessUnitaryObjs(CPDF_PageObjects *pObjs, FX_FLOAT reflowWidth, CFX_AffineMatrix objMatrix);
+    FX_INT32 LogicPreObj(CPDF_TextObject* pObj);
+    int ProcessInsertObject(CPDF_TextObject* pObj, CFX_AffineMatrix formMatrix);
+    FX_WCHAR GetPreChar();
+    FX_BOOL IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2);
+    int GetCharWidth(FX_DWORD charCode, CPDF_Font* pFont) const;
+    FX_BOOL	IsCanBreakAfter(FX_DWORD unicode);
+    FX_BOOL	IsCanBreakBefore(FX_DWORD unicode);
+    FX_INT32 GetElementTypes(LayoutType layoutType);
+    void				CreateRFData(CPDF_PageObject* pObj, CFX_AffineMatrix* pMatrix = NULL);
+    CRF_CharState*		GetCharState(CPDF_TextObject* pObj, CPDF_Font* pFont, FX_FLOAT fHeight, FX_ARGB color);
+    FX_FLOAT		ConverWidth(FX_FLOAT width);
+    void	AddData2CurrLine(CRF_Data* pData);
+    void	AddTemp2CurrLine(int begin, int count );
+    void	Transform(const CFX_AffineMatrix* pMatrix, CRF_Data* pData);
+    void	Transform(const CFX_AffineMatrix* pMatrix, CRF_DataPtrArray* pDataArray, int beginPos, int count = 0);
+    FX_FLOAT GetDatasWidth( int beginPos, int endpos);
+    void	UpdateCurrLine();
+    FX_BOOL	FinishedCurrLine();
+    int m_flags;
+    CFX_AffineMatrix m_PDFMatrix;
+    LayoutStatus	m_Status;
+    CPDF_TextObject* m_pPreObj;
+    CFX_AffineMatrix m_perMatrix;
+    IPDF_LayoutElement*	m_pLayoutElement;
+    IPDF_LayoutElement* m_pRootElement;
+    FX_FLOAT		m_CurrRefWidth;
+    IFX_Pause*		m_pPause;
+    LayoutEnum		m_CurrWritingMode;
+    CPDF_ReflowedPage*	m_pReflowedPage;
+    FX_FLOAT		m_fRefWidth;
+    FX_FLOAT		m_TopIndent;
+    FX_FLOAT		m_fLineSpace;
+    FX_FLOAT		m_fScreenHeight;
+    FX_FLOAT		m_fCurrMaxWidth;
+    FX_FLOAT		m_fCurrLineWidth;
+    FX_FLOAT		m_fCurrLineHeight;
+    CRF_DataPtrArray*	m_pCurrLine;
+    CRF_DataPtrArray*	m_pTempLine;
+    FX_BOOL			m_bIllustration;
+    FX_FLOAT		m_fLineHeight;
+    LayoutEnum		m_TextAlign;
+    FX_FLOAT		m_StartIndent;
+    CFX_ArrayTemplate<CRF_Table*> m_TableArray;
+    int				m_PausePosition;
+};
+struct RF_TableCell {
+    int			m_BeginPos;
+    int			m_EndPos;
+    FX_FLOAT m_MaxWidth;
+    FX_FLOAT m_PosX;
+    FX_FLOAT	m_PosY;
+    FX_FLOAT	m_CellWidth;
+    FX_FLOAT m_CellHeight;
+    int			m_RowSpan;
+    int			m_ColSpan;
+    LayoutEnum	m_BlockAlign;
+    LayoutEnum	m_InlineAlign;
+};
+typedef CFX_ArrayTemplate<RF_TableCell*> CRF_TableCellArray;
+class CRF_Table : public CFX_Object
+{
+public:
+    CRF_Table()
+    {
+        m_TableWidth = 0;
+        m_nCol = 0;
+    }
+    CRF_TableCellArray  m_pCellArray;
+    CFX_WordArray		m_nCell;
+    int					m_nCol;
+    FX_FLOAT			m_TableWidth;
+    FX_FLOAT			m_ReflowPageHeight;
+};
+class CRF_CharState : public CFX_Object
+{
+public:
+    CPDF_Font*	m_pFont;
+    FX_ARGB		m_Color;
+    FX_BOOL		m_bVert;
+    FX_FLOAT m_fFontSize;
+    FX_FLOAT m_fAscent;
+    FX_FLOAT m_fDescent;
+
+    CPDF_TextObject*	m_pTextObj;
+};
+class CRF_PageInfo : public CFX_Object
+{
+public:
+    CRF_PageInfo(CPDF_PageObject* pPageObj, CRF_PageInfo* pParent = NULL)
+        : m_pPageObj(pPageObj) , m_pParent(pParent)
+    {
+    }
+    CPDF_PageObject* GetPageObj()
+    {
+        return m_pPageObj;
+    }
+    CPDF_Dictionary* GetFormDict()
+    {
+        if (NULL == m_pParent) {
+            return NULL;
+        }
+        CPDF_PageObject* pParentObj = m_pParent->GetPageObj();
+        if (NULL == pParentObj || PDFPAGE_FORM != pParentObj->m_Type) {
+            return NULL;
+        }
+        return ((CPDF_FormObject*)pParentObj)->m_pForm->m_pResources;
+    }
+protected:
+    CPDF_PageObject*		m_pPageObj;
+    CRF_PageInfo*			m_pParent;
+};
+class CPDF_ReflowedPage : public IPDF_ReflowedPage, public CFX_PrivateData, public CFX_Object
+{
+public:
+
+    CPDF_ReflowedPage(CFX_GrowOnlyPool*	pMemoryPool);
+    ~CPDF_ReflowedPage();
+    CFX_PrivateData*	GetPrivateDataCtrl()
+    {
+        return this;
+    };
+    void		GetDisplayMatrix(CFX_AffineMatrix& matrix, FX_INT32 xPos, FX_INT32 yPos, FX_INT32 xSize, FX_INT32 ySize, FX_INT32 iRotate, const CFX_AffineMatrix* pPageMatrix);
+
+    FX_FLOAT	GetPageHeight() ;
+    FX_FLOAT	GetPageWidth()
+    {
+        return m_PageWidth;
+    };
+    void		FocusGetData(const CFX_AffineMatrix matrix, FX_INT32 x, FX_INT32 y, CFX_ByteString& str);
+    FX_BOOL		FocusGetPosition(const CFX_AffineMatrix matrix, CFX_ByteString str, FX_INT32& x, FX_INT32& y);
+    CRF_DataPtrArray*	m_pReflowed;
+    FX_FLOAT			m_PageWidth;
+    FX_FLOAT			m_PageHeight;
+    FX_BOOL				m_bWaiting;
+    CRF_CharStateArray*	m_pCharState;
+    CFX_GrowOnlyPool*	m_pMemoryPool;
+    FX_BOOL				m_bCreateMemoryPool;
+    CPDF_Page*			m_pPDFPage;
+    FX_BOOL					RetainPageObjsMemberShip();
+    void					MarkPageObjMemberShip(CPDF_PageObject* pObj, CRF_PageInfo* pParent);
+    void					ReleasePageObjsMemberShip();
+    CPDF_Dictionary*		GetFormResDict(CPDF_PageObject* pObj);
+
+    CFX_MapPtrToPtr*		m_pPageInfos;
+};
+class CPDF_ProgressiveReflowPageParser : public IPDF_ProgressiveReflowPageParser, public CFX_Object
+{
+public:
+    CPDF_ProgressiveReflowPageParser();
+    ~CPDF_ProgressiveReflowPageParser() ;
+    void			Init();
+
+    ParseStatus		GetStatus()
+    {
+        return m_Status;
+    };
+
+    void			SetParserStyle(RF_ParseStyle style)
+    {
+        m_ParseStyle = style;
+    };
+    void			Start(IPDF_ReflowedPage* pReflowPage, CPDF_Page* pPage, FX_FLOAT TopIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, IFX_Pause* pPause, int flags);
+    void			Continue(IFX_Pause* pPause);
+    int				GetPosition() ;
+
+    void			Clear();
+    ParseStatus		m_Status;
+protected:
+    RF_ParseStyle		m_ParseStyle;
+    CPDF_Page*			m_pPDFPage;
+    IFX_Pause*			m_pPause;
+    CPDF_ReflowedPage*	m_pReflowPage;
+    FX_FLOAT			m_TopIndent;
+    FX_FLOAT			m_ReflowedWidth;
+    FX_FLOAT			m_fScreenHeight;
+    IPDF_LayoutProvider*	m_pProvider;
+    IPDF_LayoutProcessor*	m_pReflowEngine;
+    int					m_nObjProcessed;
+    int m_flags;
+};
+class CPDF_ProgressiveReflowPageRender : public IPDF_ProgressiveReflowPageRender, public CFX_Object
+{
+public:
+    CPDF_ProgressiveReflowPageRender();
+    ~CPDF_ProgressiveReflowPageRender() ;
+
+    RenderStatus			GetStatus()
+    {
+        return m_Status;
+    };
+
+
+    void		SetDisplayColor(FX_COLORREF color);
+    void		Start(IPDF_ReflowedPage* pReflowPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pMatrix, IFX_Pause* pPause, int DitherBits);
+    void		Continue(IFX_Pause* pPause);
+    int			GetPosition();
+
+
+    void				Clear();
+protected:
+    void				Display(IFX_Pause* pPause);
+    RenderStatus m_Status;
+    CPDF_ReflowedPage*	m_pReflowPage;
+    CFX_AffineMatrix*	m_pDisplayMatrix;
+    int					m_CurrNum;
+    IFX_FontEncoding*	m_pFontEncoding;
+    CFX_RenderDevice*	m_pFXDevice;
+    int					m_DitherBits;
+    FX_COLORREF			m_DisplayColor;
+    typedef struct CRF_TextDataAtt {
+        CRF_TextDataAtt()
+        {
+            pFont = NULL;
+            fFontSize = 0.0f;
+            Color = 0;
+        }
+        CRF_TextDataAtt(CPDF_Font* font, FX_FLOAT fontSize, FX_ARGB color)
+        {
+            pFont = font;
+            fFontSize = fontSize;
+            Color = color;
+        }
+        CPDF_Font*  pFont;
+        FX_FLOAT    fFontSize;
+        FX_ARGB		Color;
+    } CRF_TEXTDATAATT;
+    inline bool isTextDataAttSame(CRF_TEXTDATAATT data1, CRF_TEXTDATAATT data2)
+    {
+        if (data1.pFont != data2.pFont) {
+            return false;
+        }
+        if (data1.Color != data2.Color) {
+            return false;
+        }
+        if (fabs(data1.fFontSize - data2.fFontSize) > 0.0f) {
+            return false;
+        }
+        return true;
+    };
+};
+#define TYPE_UNKNOW		0
+#define TYPE_TEXT		1
+#define TYPE_PATH		2
+#define TYPE_IMAGE		3
+#define TYPE_LINE		4
+class CRF_Data : public CFX_Object
+{
+public:
+    typedef enum {Unknow, Text, Image, Path, Line, paragraph} RF_DataType;
+    CRF_Data()
+    {
+        m_Type = Unknow;
+        m_Width = 0;
+        m_PosY = 0;
+        m_PosX = 0;
+        m_Height = 0;
+    }
+    RF_DataType	GetType()
+    {
+        return m_Type;
+    }
+    virtual		~CRF_Data() {}
+    RF_DataType 	m_Type;
+    FX_FLOAT	m_PosX;
+    FX_FLOAT	m_PosY;
+    FX_FLOAT	m_Width;
+    FX_FLOAT	m_Height;
+};
+class CRF_LineData : public CRF_Data
+{
+public:
+    CRF_LineData()
+    {
+        m_Type = Line;
+    }
+};
+class CRF_CharData : public CRF_Data
+{
+public:
+    CRF_CharData()
+    {
+        m_Type = Text;
+        m_CharCode = -1;
+    }
+    CRF_CharState*	m_pCharState;
+    FX_DWORD		m_CharCode;
+};
+class CRF_ImageData : public CRF_Data
+{
+public:
+    CRF_ImageData()
+    {
+        m_Type = Image;
+        m_pBitmap = NULL;
+    }
+    ~CRF_ImageData()
+    {
+        if(m_pBitmap) {
+            delete m_pBitmap;
+        }
+        m_pBitmap = NULL;
+    }
+    CFX_AffineMatrix m_Matrix;
+    CFX_DIBitmap*	m_pBitmap;
+};
+class CRF_PathData : public CRF_Data
+{
+public:
+    CRF_PathData()
+    {
+        m_Type = Path;
+        m_bDecoration = FALSE;
+    }
+    ~CRF_PathData() {};
+    FX_BOOL			m_bDecoration;
+    CPDF_Path			m_pPathData;
+    CFX_AffineMatrix	m_pPath2Device;
+    CPDF_GraphState		m_pGraphState;
+    FX_ARGB		m_fill_argb;
+    FX_ARGB		m_stroke_argb;
+    int			m_fill_mode;
+};
+#endif
diff --git a/core/src/reflow/reflowedtextpage.cpp b/core/src/reflow/reflowedtextpage.cpp
new file mode 100644
index 0000000000..a5ad0be948
--- /dev/null
+++ b/core/src/reflow/reflowedtextpage.cpp
@@ -0,0 +1,402 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "reflowedtextpage.h"
+IPDF_TextPage*	IPDF_TextPage::CreateReflowTextPage(IPDF_ReflowedPage* pRefPage)
+{
+    return FX_NEW CRF_TextPage(pRefPage);
+}
+CRF_TextPage::CRF_TextPage(IPDF_ReflowedPage* pRefPage)
+{
+    m_pRefPage = (CPDF_ReflowedPage*)(pRefPage);
+    m_pDataList = NULL;
+    m_CountBSArray = NULL;
+}
+CRF_TextPage::~CRF_TextPage()
+{
+    if(m_pDataList) {
+        delete m_pDataList;
+        m_pDataList = NULL;
+    }
+    if(m_CountBSArray) {
+        delete m_CountBSArray;
+        m_CountBSArray = NULL;
+    }
+}
+FX_BOOL CRF_TextPage::ParseTextPage()
+{
+    if(!m_pRefPage) {
+        return FALSE;
+    }
+    int count = m_pRefPage->m_pReflowed->GetSize();
+    if(count < 500) {
+        m_pDataList = FX_NEW CRF_CharDataPtrArray(count);
+    } else {
+        m_pDataList = FX_NEW CRF_CharDataPtrArray(500);
+    }
+    if (NULL == m_pDataList) {
+        return FALSE;
+    }
+    for(int i = 0; i < count; i++) {
+        CRF_Data* pData = (*(m_pRefPage->m_pReflowed))[i];
+        if(pData->GetType() == CRF_Data::Text) {
+            m_pDataList->Add((CRF_CharData*)pData);
+        }
+    }
+    m_CountBSArray = FX_NEW CFX_CountBSINT32Array(20);
+    if(NULL == m_CountBSArray) {
+        return FALSE;
+    }
+    return TRUE;
+}
+FX_BOOL	CRF_TextPage::IsParsered() const
+{
+    if(m_pDataList) {
+        return TRUE;
+    }
+    return FALSE;
+}
+int CRF_TextPage::CharIndexFromTextIndex(int TextIndex) const
+{
+    return TextIndex;
+}
+int CRF_TextPage::TextIndexFromCharIndex(int CharIndex) const
+{
+    return CharIndex;
+}
+
+int	CRF_TextPage::CountChars() const
+{
+    if (NULL == m_pDataList) {
+        return -1;
+    }
+    return m_pDataList->GetSize();
+}
+void CRF_TextPage::GetCharInfo(int index, FPDF_CHAR_INFO & info) const
+{
+    if(index >= CountChars() || index < 0 || !m_pDataList) {
+        return;
+    }
+    CRF_CharData* pData = (*m_pDataList)[index];
+    FX_FLOAT ReltiveCorddDs = pData->m_pCharState->m_fDescent;
+    FX_FLOAT ReltiveCorddAs = pData->m_pCharState->m_fAscent;
+    info.m_Flag		= CHAR_NORMAL;
+    info.m_pTextObj	= pData->m_pCharState->m_pTextObj;
+    info.m_OriginX	= pData->m_PosX;
+    info.m_OriginY	= pData->m_PosY - ReltiveCorddDs;
+    info.m_FontSize	= pData->m_pCharState->m_fFontSize;
+    CFX_FloatRect FloatRectTmp(pData->m_PosX, pData->m_PosY, pData->m_PosX + pData->m_Width, pData->m_PosY + ReltiveCorddAs - ReltiveCorddDs);
+    info.m_CharBox	= FloatRectTmp;
+    CFX_WideString str = pData->m_pCharState->m_pFont->UnicodeFromCharCode(pData->m_CharCode);
+    if(!str.IsEmpty()) {
+        info.m_Unicode	= str.GetAt(0);
+    } else {
+        info.m_Unicode = -1;
+    }
+    info.m_Charcode = (FX_WCHAR)pData->m_CharCode;
+    info.m_Matrix = CFX_Matrix(1, 0, 0, 1, 0, 0);
+}
+extern FX_BOOL GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2, FX_FLOAT& interlow, FX_FLOAT& interhigh);
+inline FX_BOOL _IsInsameline(const CFX_FloatRect& rectA, const CFX_FloatRect& rectB)
+{
+    if((rectA.top >= rectB.bottom && rectB.top >= rectA.bottom)) {
+        return TRUE;
+    } else {
+        return FALSE;
+    }
+}
+inline FX_BOOL _IsIntersect(const CFX_FloatRect& rectA, const CFX_FloatRect& rectB)
+{
+    FX_FLOAT interlow = .0f, interhigh = .0f;
+    if(GetIntersection(rectA.bottom, rectA.top, rectB.bottom, rectB.top, interlow, interhigh)) {
+        if(GetIntersection(rectA.left, rectA.right, rectB.left, rectB.right, interlow, interhigh)) {
+            return TRUE;
+        } else {
+            return FALSE;
+        }
+    }
+    return FALSE;
+}
+void CRF_TextPage::GetRectArray(int start, int nCount, CFX_RectArray& rectArray) const
+{
+    int indexlen = start + nCount;
+    FPDF_CHAR_INFO info;
+    FX_BOOL bstart = TRUE;
+    CFX_FloatRect recttmp;
+    int i;
+    for(i = start; i < indexlen; i++) {
+        GetCharInfo(i, info);
+        if(bstart) {
+            recttmp = info.m_CharBox;
+            bstart = FALSE;
+        } else if(_IsInsameline(recttmp, info.m_CharBox)) {
+            recttmp.right = info.m_CharBox.right;
+            if(info.m_CharBox.top > recttmp.top) {
+                recttmp.top = info.m_CharBox.top;
+            }
+            if(info.m_CharBox.bottom < recttmp.bottom) {
+                recttmp.bottom = info.m_CharBox.bottom;
+            }
+        } else {
+            rectArray.Add(recttmp);
+            recttmp = info.m_CharBox;
+        }
+    }
+    rectArray.Add(recttmp);
+}
+inline FX_FLOAT _GetDistance(CFX_FloatRect floatRect, CPDF_Point point)
+{
+    if(floatRect.right < point.x && floatRect.bottom > point.y) {
+        return FXSYS_sqrt(FXSYS_pow(point.x - floatRect.right, 2) + FXSYS_pow(floatRect.bottom - point.y, 2));
+    }
+    if (floatRect.right < point.x && floatRect.top < point.y) {
+        return FXSYS_sqrt(FXSYS_pow(point.x - floatRect.right, 2) + FXSYS_pow(point.y - floatRect.top, 2));
+    }
+    if(floatRect.left > point.x && floatRect.bottom > point.y) {
+        return FXSYS_sqrt(FXSYS_pow(floatRect.bottom - point.y, 2) + FXSYS_pow(floatRect.left - point.x, 2));
+    }
+    if((floatRect.right > point.x || FXSYS_fabs(floatRect.right - point.x) <= 0.0001f) &&
+            (floatRect.left < point.x || FXSYS_fabs(floatRect.left - point.x) <= 0.0001f) && floatRect.bottom > point.y) {
+        return FXSYS_fabs(floatRect.bottom - point.y);
+    }
+    if(floatRect.left > point.x && (floatRect.bottom < point.y || FXSYS_fabs(floatRect.bottom - point.y) <= 0.0001f) &&
+            (floatRect.top > point.y || FXSYS_fabs(floatRect.top - point.y) <= 0.0001f)) {
+        return FXSYS_fabs(floatRect.left - point.x);
+    }
+    if(floatRect.left > point.x && floatRect.top < point.y) {
+        return FXSYS_sqrt(FXSYS_pow(floatRect.left - point.x, 2) + FXSYS_pow(point.y - floatRect.top, 2));
+    }
+    if ((floatRect.left < point.x || FXSYS_fabs(floatRect.left - point.x) <= 0.0001f) &&
+            (floatRect.right > point.x || FXSYS_fabs(floatRect.right - point.x) <= 0.0001f) && floatRect.top < point.y) {
+        return FXSYS_fabs(point.y - floatRect.top);
+    }
+    if(floatRect.right < point.x && (floatRect.top > point.y || FXSYS_fabs(floatRect.top - point.y) <= 0.0001f) &&
+            (floatRect.bottom < point.y || FXSYS_fabs(floatRect.bottom - point.y) <= 0.0001f)) {
+        return point.x - floatRect.right;
+    }
+    return .0f;
+}
+int CRF_TextPage::GetIndexAtPos(CPDF_Point point, FX_FLOAT xTorelance, FX_FLOAT yTorelance) const
+{
+    int index = -1, i = 0, j = 0;
+    FPDF_CHAR_INFO info;
+    CFX_FloatRect rectTmp;
+    FX_FLOAT MinDistance = 1000, DistanceTmp = 0;
+    FX_FLOAT rect_bottom = point.x - xTorelance;
+    CFX_FloatRect TorelanceRect(rect_bottom <= 0 ? 0 : rect_bottom, point.y - yTorelance, point.x + xTorelance, point.y + yTorelance);
+    int count = CountChars();
+    for(i = 0; i < count; i++) {
+        GetCharInfo(i, info);
+        rectTmp = info.m_CharBox;
+        if(rectTmp.Contains(point.x, point.y)) {
+            index = i;
+            break;
+        } else if(_IsIntersect(rectTmp, TorelanceRect)) {
+            DistanceTmp = _GetDistance(rectTmp, point);
+            if(DistanceTmp < MinDistance) {
+                MinDistance = DistanceTmp;
+                index = i;
+            }
+        }
+    }
+    return index;
+}
+int CRF_TextPage::GetIndexAtPos(FX_FLOAT x, FX_FLOAT y, FX_FLOAT xTorelance, FX_FLOAT yTorelance) const
+{
+    int index = 0;
+    CPDF_Point point(x, y);
+    if((index = GetIndexAtPos(point, xTorelance, yTorelance)) < 0) {
+        return -1;
+    } else {
+        return index;
+    }
+}
+int CRF_TextPage::GetOrderByDirection(int index, int direction) const
+{
+    return -1;
+}
+CFX_WideString CRF_TextPage::GetTextByRect(CFX_FloatRect rect) const
+{
+    int count;
+    FPDF_CHAR_INFO info;
+    CFX_WideString str;
+    CFX_FloatRect  Recttmp;
+    FX_BOOL bstart = TRUE;
+    count = CountChars();
+    if(rect.IsEmpty()) {
+        return L"";
+    }
+    for(int i = 0; i < count; i++) {
+        GetCharInfo(i, info);
+        if(_IsIntersect(rect, info.m_CharBox)) {
+            if(bstart) {
+                Recttmp = info.m_CharBox;
+                str += info.m_Unicode;
+                bstart = FALSE;
+            } else if(_IsInsameline(Recttmp, info.m_CharBox)) {
+                str += info.m_Unicode;
+            } else {
+                str += L"\r\n";
+                Recttmp = info.m_CharBox;
+                str += info.m_Unicode;
+            }
+        }
+    }
+    if(str.IsEmpty()) {
+        return L"";
+    } else {
+        return str;
+    }
+}
+void CRF_TextPage::GetRectsArrayByRect(CFX_FloatRect rect, CFX_RectArray& resRectArray) const
+{
+    int count, i;
+    FX_BOOL bstart = TRUE;
+    FPDF_CHAR_INFO info;
+    CFX_FloatRect recttmp;
+    count = CountChars();
+    for(i = 0; i < count; i++) {
+        GetCharInfo(i, info);
+        if(_IsIntersect(rect, info.m_CharBox)) {
+            if(bstart) {
+                recttmp = info.m_CharBox;
+                bstart = FALSE;
+            } else if(_IsInsameline(recttmp, info.m_CharBox)) {
+                recttmp.right = info.m_CharBox.right;
+                if(info.m_CharBox.top > recttmp.top) {
+                    recttmp.top = info.m_CharBox.top;
+                }
+                if(info.m_CharBox.bottom < recttmp.bottom) {
+                    recttmp.bottom = info.m_CharBox.bottom;
+                }
+            } else {
+                resRectArray.Add(recttmp);
+                recttmp = info.m_CharBox;
+            }
+        }
+    }
+    resRectArray.Add(recttmp);
+}
+int CRF_TextPage::CountRects(int start, int nCount)
+{
+    m_rectArray.RemoveAll();
+    GetRectArray(start, nCount, m_rectArray);
+    return m_rectArray.GetSize();
+}
+void CRF_TextPage::GetRect(int rectIndex, FX_FLOAT& left, FX_FLOAT& top, FX_FLOAT& right, FX_FLOAT &bottom) const
+{
+    if(m_rectArray.GetSize() <= rectIndex) {
+        return;
+    }
+    left   = m_rectArray[rectIndex].left;
+    top    = m_rectArray[rectIndex].top;
+    right  = m_rectArray[rectIndex].right;
+    bottom = m_rectArray[rectIndex].bottom;
+}
+FX_BOOL CRF_TextPage::GetBaselineRotate(int rectIndex, int& Rotate)
+{
+    Rotate = 0;
+    return TRUE;
+}
+FX_BOOL CRF_TextPage::GetBaselineRotate(CFX_FloatRect rect, int& Rotate)
+{
+    Rotate = 0;
+    return TRUE;
+}
+int CRF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT right, FX_FLOAT bottom, FX_BOOL bContains)
+{
+    if (!m_CountBSArray) {
+        return -1;
+    }
+    m_CountBSArray->RemoveAll();
+    CFX_FloatRect floatrect(left, bottom, right, top);
+    int totalcount, i, j = 0, counttmp = 0;
+    FX_BOOL bstart = TRUE;
+    FPDF_CHAR_INFO info;
+    CFX_FloatRect recttmp;
+    totalcount = CountChars();
+    for(i = 0; i < totalcount; i++) {
+        GetCharInfo(i, info);
+        if(_IsIntersect(floatrect, info.m_CharBox)) {
+            if(bstart) {
+                m_CountBSArray->Add(i);
+                counttmp = 1;
+                recttmp = info.m_CharBox;
+                bstart = FALSE;
+            } else if(_IsInsameline(recttmp, info.m_CharBox)) {
+                recttmp.right = info.m_CharBox.right;
+                if(info.m_CharBox.top > recttmp.top) {
+                    recttmp.top = info.m_CharBox.top;
+                }
+                if(info.m_CharBox.bottom < recttmp.bottom) {
+                    recttmp.bottom = info.m_CharBox.bottom;
+                }
+                counttmp ++;
+            } else {
+                m_CountBSArray->Add(counttmp);
+                m_CountBSArray->Add(i);
+                counttmp = 1;
+                j++;
+                recttmp = info.m_CharBox;
+            }
+        }
+    }
+    m_CountBSArray->Add(counttmp);
+    j++;
+    return j;
+}
+void CRF_TextPage::GetBoundedSegment(int index, int& start, int& count) const
+{
+    if (!m_CountBSArray) {
+        return;
+    }
+    if(m_CountBSArray->GetSize() <= index * 2) {
+        start = 0;
+        count = 0;
+        return;
+    }
+    start = *(int *)m_CountBSArray->GetAt(index * 2);
+    count = *(int *)m_CountBSArray->GetAt(index * 2 + 1);
+}
+
+int CRF_TextPage::GetWordBreak(int index, int direction) const
+{
+    return -1;
+}
+CFX_WideString CRF_TextPage::GetPageText(int start, int nCount ) const
+{
+    if(nCount == -1) {
+        nCount = CountChars();
+        start = 0;
+    } else if(nCount < 1) {
+        return L"";
+    } else if(start >= CountChars()) {
+        return L"";
+    }
+    int i, index = start + nCount;
+    FPDF_CHAR_INFO info;
+    CFX_WideString str;
+    CFX_FloatRect recttmp;
+    FX_BOOL bstart = TRUE;
+    for(i = start; i < index; i++) {
+        GetCharInfo(i, info);
+        if(bstart) {
+            recttmp = info.m_CharBox;
+            str += info.m_Unicode;
+            bstart = FALSE;
+        } else if (_IsInsameline(recttmp, info.m_CharBox)) {
+            str += info.m_Unicode;
+        } else {
+            str += L"\r\n";
+            recttmp = info.m_CharBox;
+            str += info.m_Unicode;
+        }
+    }
+    if(str.IsEmpty()) {
+        return L"";
+    }
+    return str;
+}
diff --git a/core/src/reflow/reflowedtextpage.h b/core/src/reflow/reflowedtextpage.h
new file mode 100644
index 0000000000..397428d178
--- /dev/null
+++ b/core/src/reflow/reflowedtextpage.h
@@ -0,0 +1,71 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#ifndef _REFLOWED_TEXT_PAGE_H
+#define _REFLOWED_TEXT_PAGE_H
+#include "../../include/reflow/reflowengine.h"
+#include "../../src/reflow/reflowedpage.h"
+typedef CFX_SegmentedArray<CRF_CharData*> CRF_CharDataPtrArray;
+typedef CFX_SegmentedArray<FX_INT32> CFX_CountBSINT32Array;
+class CRF_TextPage : public IPDF_TextPage
+{
+public:
+    CRF_TextPage(IPDF_ReflowedPage* pRefPage);
+
+    virtual ~CRF_TextPage() ;
+    FX_BOOL			ParseTextPage();
+    void			NormalizeObjects(FX_BOOL bNormalize)
+    {
+        return;
+    };
+
+    FX_BOOL			IsParsered() const;
+public:
+
+    int CharIndexFromTextIndex(int TextIndex) const;
+
+    int TextIndexFromCharIndex(int CharIndex) const;
+
+
+    int				CountChars() const;
+
+    virtual	void	GetCharInfo(int index, FPDF_CHAR_INFO & info) const;
+
+    void			GetRectArray(int start, int nCount, CFX_RectArray& rectArray) const;
+
+
+    int				GetIndexAtPos(CPDF_Point point, FX_FLOAT xTorelance, FX_FLOAT yTorelance) const;
+
+    int				GetIndexAtPos(FX_FLOAT x, FX_FLOAT y, FX_FLOAT xTorelance, FX_FLOAT yTorelance) const;
+
+    virtual	int				GetOrderByDirection(int index, int direction) const;
+
+    CFX_WideString	GetTextByRect(CFX_FloatRect rect) const;
+
+    void			GetRectsArrayByRect(CFX_FloatRect rect, CFX_RectArray& resRectArray) const;
+
+
+    int				CountRects(int start, int nCount);
+
+    virtual	void			GetRect(int rectIndex, FX_FLOAT& left, FX_FLOAT& top, FX_FLOAT& right, FX_FLOAT &bottom) const;
+    virtual	FX_BOOL			GetBaselineRotate(int rectIndex, int& Rotate);
+    virtual FX_BOOL			GetBaselineRotate(CFX_FloatRect rect, int& Rotate);
+
+    virtual	int				CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT right, FX_FLOAT bottom, FX_BOOL bContains = FALSE);
+
+    virtual	void			GetBoundedSegment(int index, int& start, int& count) const;
+
+
+    int				GetWordBreak(int index, int direction) const;
+
+    CFX_WideString	GetPageText(int start, int nCount = -1 ) const;
+private:
+    CPDF_ReflowedPage*		m_pRefPage;
+    CRF_CharDataPtrArray*	m_pDataList;
+    CFX_RectArray			m_rectArray;
+    CFX_CountBSINT32Array*	m_CountBSArray;
+};
+#endif
diff --git a/core/src/reflow/reflowengine.cpp b/core/src/reflow/reflowengine.cpp
new file mode 100644
index 0000000000..11007c904b
--- /dev/null
+++ b/core/src/reflow/reflowengine.cpp
@@ -0,0 +1,38 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+ 
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "../../include/reflow/reflowengine.h"
+#include "reflowedpage.h"
+IPDF_ReflowedPage* IPDF_ReflowedPage::Create()
+{
+    CPDF_ReflowedPage* pRefPage = FX_NEW CPDF_ReflowedPage(NULL);
+    return pRefPage;
+}
+IPDF_ReflowedPage* Create_ReflowPage()
+{
+    return IPDF_ReflowedPage::Create();
+}
+IPDF_ProgressiveReflowPageParser* Create_ReflowPageParser()
+{
+    return IPDF_ProgressiveReflowPageParser::Create();
+}
+IPDF_ProgressiveReflowPageParser* IPDF_ProgressiveReflowPageParser::Create()
+{
+    CPDF_ProgressiveReflowPageParser* pParser = FX_NEW CPDF_ProgressiveReflowPageParser;
+    if (NULL == pParser) {
+        return NULL;
+    }
+    pParser->Init();
+    return pParser;
+}
+IPDF_ProgressiveReflowPageRender* Create_ReflowPageRender()
+{
+    return IPDF_ProgressiveReflowPageRender::Create();
+}
+IPDF_ProgressiveReflowPageRender* IPDF_ProgressiveReflowPageRender::Create()
+{
+    return FX_NEW CPDF_ProgressiveReflowPageRender;
+}