diff options
Diffstat (limited to 'core/src/reflow/reflowedpage.cpp')
| -rw-r--r-- | core/src/reflow/reflowedpage.cpp | 622 |
1 files changed, 622 insertions, 0 deletions
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; +} |