From 8d0cc67cdf3ef45ee7268d3e00a21c0a99843a84 Mon Sep 17 00:00:00 2001 From: dsinclair Date: Wed, 3 Aug 2016 12:58:53 -0700 Subject: Rename xfa_layout_pagemgr_new.h This renames the file to match the class name. Review-Url: https://codereview.chromium.org/2209823002 --- xfa/fxfa/parser/cxfa_containerlayoutitem.cpp | 2 +- xfa/fxfa/parser/cxfa_layoutpagemgr.cpp | 2000 ++++++++++++++++++++++++++ xfa/fxfa/parser/cxfa_layoutpagemgr.h | 144 ++ xfa/fxfa/parser/cxfa_layoutprocessor.cpp | 2 +- xfa/fxfa/parser/xfa_layout_itemlayout.cpp | 2 +- xfa/fxfa/parser/xfa_layout_pagemgr_new.cpp | 1954 ------------------------- xfa/fxfa/parser/xfa_layout_pagemgr_new.h | 156 -- 7 files changed, 2147 insertions(+), 2113 deletions(-) create mode 100644 xfa/fxfa/parser/cxfa_layoutpagemgr.cpp create mode 100644 xfa/fxfa/parser/cxfa_layoutpagemgr.h delete mode 100644 xfa/fxfa/parser/xfa_layout_pagemgr_new.cpp delete mode 100644 xfa/fxfa/parser/xfa_layout_pagemgr_new.h (limited to 'xfa') diff --git a/xfa/fxfa/parser/cxfa_containerlayoutitem.cpp b/xfa/fxfa/parser/cxfa_containerlayoutitem.cpp index 0db7fb20b4..646f8a45e5 100644 --- a/xfa/fxfa/parser/cxfa_containerlayoutitem.cpp +++ b/xfa/fxfa/parser/cxfa_containerlayoutitem.cpp @@ -6,9 +6,9 @@ #include "xfa/fxfa/parser/cxfa_containerlayoutitem.h" +#include "xfa/fxfa/parser/cxfa_layoutpagemgr.h" #include "xfa/fxfa/parser/cxfa_layoutprocessor.h" #include "xfa/fxfa/parser/cxfa_measurement.h" -#include "xfa/fxfa/parser/xfa_layout_pagemgr_new.h" CXFA_ContainerLayoutItem::CXFA_ContainerLayoutItem(CXFA_Node* pNode) : CXFA_LayoutItem(pNode, FALSE), m_pOldSubform(nullptr) {} diff --git a/xfa/fxfa/parser/cxfa_layoutpagemgr.cpp b/xfa/fxfa/parser/cxfa_layoutpagemgr.cpp new file mode 100644 index 0000000000..48a9c78ffe --- /dev/null +++ b/xfa/fxfa/parser/cxfa_layoutpagemgr.cpp @@ -0,0 +1,2000 @@ +// 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 "xfa/fxfa/parser/cxfa_layoutpagemgr.h" + +#include "xfa/fxfa/app/xfa_ffnotify.h" +#include "xfa/fxfa/parser/cxfa_containerlayoutitem.h" +#include "xfa/fxfa/parser/cxfa_contentlayoutitem.h" +#include "xfa/fxfa/parser/cxfa_document.h" +#include "xfa/fxfa/parser/cxfa_layoutprocessor.h" +#include "xfa/fxfa/parser/cxfa_measurement.h" +#include "xfa/fxfa/parser/cxfa_scriptcontext.h" +#include "xfa/fxfa/parser/cxfa_traversestrategy_contentareacontainerlayoutitem.h" +#include "xfa/fxfa/parser/cxfa_traversestrategy_layoutitem.h" +#include "xfa/fxfa/parser/xfa_document_datamerger_imp.h" +#include "xfa/fxfa/parser/xfa_layout_itemlayout.h" +#include "xfa/fxfa/parser/xfa_localemgr.h" +#include "xfa/fxfa/parser/xfa_object.h" +#include "xfa/fxfa/parser/xfa_resolvenode_rs.h" +#include "xfa/fxfa/parser/xfa_utils.h" + +namespace { + +class PageSetContainerLayoutItem { + public: + static CXFA_ContainerLayoutItem* GetFirstChild( + CXFA_ContainerLayoutItem* pLayoutItem) { + if (pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) + return nullptr; + + CXFA_ContainerLayoutItem* pChildItem = + static_cast(pLayoutItem->m_pFirstChild); + while (pChildItem && + pChildItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) { + pChildItem = + static_cast(pChildItem->m_pNextSibling); + } + return pChildItem; + } + + static CXFA_ContainerLayoutItem* GetNextSibling( + CXFA_ContainerLayoutItem* pLayoutItem) { + CXFA_ContainerLayoutItem* pChildItem = + static_cast(pLayoutItem->m_pNextSibling); + while (pChildItem && + pChildItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) { + pChildItem = + static_cast(pChildItem->m_pNextSibling); + } + return pChildItem; + } + + static CXFA_ContainerLayoutItem* GetParent( + CXFA_ContainerLayoutItem* pLayoutItem) { + return static_cast(pLayoutItem->m_pParent); + } +}; + +uint32_t GetRelevant(CXFA_Node* pFormItem, uint32_t dwParentRelvant) { + uint32_t dwRelevant = XFA_WidgetStatus_Viewable | XFA_WidgetStatus_Printable; + CFX_WideStringC wsRelevant; + if (pFormItem->TryCData(XFA_ATTRIBUTE_Relevant, wsRelevant)) { + if (wsRelevant == FX_WSTRC(L"+print") || wsRelevant == FX_WSTRC(L"print")) + dwRelevant &= ~XFA_WidgetStatus_Viewable; + else if (wsRelevant == FX_WSTRC(L"-print")) + dwRelevant &= ~XFA_WidgetStatus_Printable; + } + + if (!(dwParentRelvant & XFA_WidgetStatus_Viewable) && + (dwRelevant != XFA_WidgetStatus_Viewable)) { + dwRelevant &= ~XFA_WidgetStatus_Viewable; + } + + if (!(dwParentRelvant & XFA_WidgetStatus_Printable) && + (dwRelevant != XFA_WidgetStatus_Printable)) { + dwRelevant &= ~XFA_WidgetStatus_Printable; + } + return dwRelevant; +} + +void SyncContainer(CXFA_FFNotify* pNotify, + CXFA_LayoutProcessor* pDocLayout, + CXFA_LayoutItem* pContainerItem, + uint32_t dwRelevant, + FX_BOOL bVisible, + int32_t nPageIndex) { + FX_BOOL bVisibleItem = FALSE; + uint32_t dwStatus = 0; + uint32_t dwRelevantContainer = 0; + if (bVisible) { + XFA_ATTRIBUTEENUM eAttributeValue = + pContainerItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence); + if (eAttributeValue == XFA_ATTRIBUTEENUM_Visible || + eAttributeValue == XFA_ATTRIBUTEENUM_Unknown) { + bVisibleItem = TRUE; + } + dwRelevantContainer = GetRelevant(pContainerItem->m_pFormNode, dwRelevant); + dwStatus = + (bVisibleItem ? XFA_WidgetStatus_Visible : 0) | dwRelevantContainer; + } + pNotify->OnLayoutItemAdded(pDocLayout, pContainerItem, nPageIndex, dwStatus); + for (CXFA_LayoutItem* pChild = pContainerItem->m_pFirstChild; pChild; + pChild = pChild->m_pNextSibling) { + if (pChild->IsContentLayoutItem()) { + SyncContainer(pNotify, pDocLayout, pChild, dwRelevantContainer, + bVisibleItem, nPageIndex); + } + } +} + +void ReorderLayoutItemToTail(CXFA_ContainerLayoutItem* pLayoutItem) { + CXFA_ContainerLayoutItem* pParentLayoutItem = + static_cast(pLayoutItem->m_pParent); + if (!pParentLayoutItem) + return; + + pParentLayoutItem->RemoveChild(pLayoutItem); + pParentLayoutItem->AddChild(pLayoutItem); +} + +void RemoveLayoutItem(CXFA_ContainerLayoutItem* pLayoutItem) { + CXFA_ContainerLayoutItem* pParentLayoutItem = + static_cast(pLayoutItem->m_pParent); + if (!pParentLayoutItem) + return; + + pParentLayoutItem->RemoveChild(pLayoutItem); +} + +CXFA_Node* ResolveBreakTarget(CXFA_Node* pPageSetRoot, + FX_BOOL bNewExprStyle, + CFX_WideStringC& wsTargetExpr) { + CXFA_Document* pDocument = pPageSetRoot->GetDocument(); + if (wsTargetExpr.IsEmpty()) + return nullptr; + + CFX_WideString wsTargetAll(wsTargetExpr); + wsTargetAll.TrimLeft(); + wsTargetAll.TrimRight(); + int32_t iSpliteIndex = 0; + FX_BOOL bTargetAllFind = TRUE; + while (iSpliteIndex != -1) { + CFX_WideString wsExpr; + int32_t iSpliteNextIndex = 0; + if (!bTargetAllFind) { + iSpliteNextIndex = wsTargetAll.Find(' ', iSpliteIndex); + wsExpr = wsTargetAll.Mid(iSpliteIndex, iSpliteNextIndex - iSpliteIndex); + } else { + wsExpr = wsTargetAll; + } + if (wsExpr.IsEmpty()) + return nullptr; + + bTargetAllFind = FALSE; + if (wsExpr.GetAt(0) == '#') { + CXFA_Node* pNode = pDocument->GetNodeByID( + ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Template)), + wsExpr.Mid(1).AsStringC()); + if (pNode) + return pNode; + } else if (bNewExprStyle) { + CFX_WideString wsProcessedTarget = wsExpr; + if (wsExpr.Left(4) == FX_WSTRC(L"som(") && + wsExpr.Right(1) == FX_WSTRC(L")")) { + wsProcessedTarget = wsExpr.Mid(4, wsExpr.GetLength() - 5); + } + XFA_RESOLVENODE_RS rs; + int32_t iCount = pDocument->GetScriptContext()->ResolveObjects( + pPageSetRoot, wsProcessedTarget.AsStringC(), rs, + XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties | + XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Siblings | + XFA_RESOLVENODE_Parent); + if (iCount > 0 && rs.nodes[0]->IsNode()) + return rs.nodes[0]->AsNode(); + } + iSpliteIndex = iSpliteNextIndex; + } + return nullptr; +} + +void SetLayoutGeneratedNodeFlag(CXFA_Node* pNode) { + pNode->SetFlag(XFA_NodeFlag_LayoutGeneratedNode, false); + pNode->ClearFlag(XFA_NodeFlag_UnusedNode); +} + +FX_BOOL CheckContentAreaNotUsed( + CXFA_ContainerLayoutItem* pPageAreaLayoutItem, + CXFA_Node* pContentArea, + CXFA_ContainerLayoutItem*& pContentAreaLayoutItem) { + for (CXFA_ContainerLayoutItem* pLayoutItem = + static_cast( + pPageAreaLayoutItem->m_pFirstChild); + pLayoutItem; pLayoutItem = static_cast( + pLayoutItem->m_pNextSibling)) { + if (pLayoutItem->m_pFormNode == pContentArea) { + if (!pLayoutItem->m_pFirstChild) { + pContentAreaLayoutItem = pLayoutItem; + return TRUE; + } + return FALSE; + } + } + return TRUE; +} + +void SyncRemoveLayoutItem(CXFA_LayoutItem* pParentLayoutItem, + CXFA_FFNotify* pNotify, + CXFA_LayoutProcessor* pDocLayout) { + CXFA_LayoutItem* pNextLayoutItem; + CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild; + while (pCurLayoutItem) { + pNextLayoutItem = pCurLayoutItem->m_pNextSibling; + if (pCurLayoutItem->m_pFirstChild) + SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout); + + pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem); + delete pCurLayoutItem; + pCurLayoutItem = pNextLayoutItem; + } +} + +} // namespace + +class CXFA_ContainerRecord { + public: + CXFA_ContainerRecord(CXFA_ContainerLayoutItem* pPageSet = nullptr, + CXFA_ContainerLayoutItem* pPageArea = nullptr, + CXFA_ContainerLayoutItem* pContentArea = nullptr) + : pCurPageSet(pPageSet), + pCurPageArea(pPageArea), + pCurContentArea(pContentArea) {} + + CXFA_ContainerLayoutItem* pCurPageSet; + CXFA_ContainerLayoutItem* pCurPageArea; + CXFA_ContainerLayoutItem* pCurContentArea; +}; + +CXFA_LayoutPageMgr::CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor) + : m_pLayoutProcessor(pLayoutProcessor), + m_pTemplatePageSetRoot(nullptr), + m_pPageSetLayoutItemRoot(nullptr), + m_pPageSetCurRoot(nullptr), + m_pCurrentContainerRecord(nullptr), + m_pCurPageArea(nullptr), + m_nAvailPages(0), + m_nCurPageCount(0), + m_ePageSetMode(XFA_ATTRIBUTEENUM_OrderedOccurrence), + m_bCreateOverFlowPage(FALSE) {} + +CXFA_LayoutPageMgr::~CXFA_LayoutPageMgr() { + ClearData(); + CXFA_LayoutItem* pLayoutItem = GetRootLayoutItem(); + CXFA_LayoutItem* pNextLayout = nullptr; + for (; pLayoutItem; pLayoutItem = pNextLayout) { + pNextLayout = pLayoutItem->m_pNextSibling; + XFA_ReleaseLayoutItem(pLayoutItem); + } +} + +FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) { + PrepareLayout(); + CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode(); + if (!pTemplateNode) + return FALSE; + + m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_Element::PageSet); + ASSERT(m_pTemplatePageSetRoot); + if (m_pPageSetLayoutItemRoot) { + m_pPageSetLayoutItemRoot->m_pParent = nullptr; + m_pPageSetLayoutItemRoot->m_pFirstChild = nullptr; + m_pPageSetLayoutItemRoot->m_pNextSibling = nullptr; + m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot; + } else { + m_pPageSetLayoutItemRoot = + new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot); + } + m_pPageSetCurRoot = m_pPageSetLayoutItemRoot; + m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY, + (void*)m_pPageSetLayoutItemRoot); + XFA_ATTRIBUTEENUM eRelation = + m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation); + if (eRelation != XFA_ATTRIBUTEENUM_Unknown) + m_ePageSetMode = eRelation; + + InitPageSetMap(); + CXFA_Node* pPageArea = nullptr; + int32_t iCount = 0; + for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild); + pPageArea; + pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pPageArea->GetElementType() == XFA_Element::PageArea) { + iCount++; + if (pPageArea->GetFirstChildByClass(XFA_Element::ContentArea)) + return TRUE; + } + } + if (iCount > 0) + return FALSE; + + CXFA_Document* pDocument = pTemplateNode->GetDocument(); + pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_Element::PageArea); + if (!pPageArea) { + pPageArea = pDocument->CreateNode(m_pTemplatePageSetRoot->GetPacketID(), + XFA_Element::PageArea); + if (!pPageArea) + return FALSE; + + m_pTemplatePageSetRoot->InsertChild(pPageArea, nullptr); + pPageArea->SetFlag(XFA_NodeFlag_Initialized, true); + } + CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_Element::ContentArea); + if (!pContentArea) { + pContentArea = pDocument->CreateNode(pPageArea->GetPacketID(), + XFA_Element::ContentArea); + if (!pContentArea) + return FALSE; + + pPageArea->InsertChild(pContentArea, nullptr); + pContentArea->SetFlag(XFA_NodeFlag_Initialized, true); + pContentArea->SetMeasure(XFA_ATTRIBUTE_X, + CXFA_Measurement(0.25f, XFA_UNIT_In)); + pContentArea->SetMeasure(XFA_ATTRIBUTE_Y, + CXFA_Measurement(0.25f, XFA_UNIT_In)); + pContentArea->SetMeasure(XFA_ATTRIBUTE_W, + CXFA_Measurement(8.0f, XFA_UNIT_In)); + pContentArea->SetMeasure(XFA_ATTRIBUTE_H, + CXFA_Measurement(10.5f, XFA_UNIT_In)); + } + CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_Element::Medium); + if (!pMedium) { + pMedium = + pDocument->CreateNode(pPageArea->GetPacketID(), XFA_Element::Medium); + if (!pContentArea) + return FALSE; + + pPageArea->InsertChild(pMedium, nullptr); + pMedium->SetFlag(XFA_NodeFlag_Initialized, true); + pMedium->SetMeasure(XFA_ATTRIBUTE_Short, + CXFA_Measurement(8.5f, XFA_UNIT_In)); + pMedium->SetMeasure(XFA_ATTRIBUTE_Long, + CXFA_Measurement(11.0f, XFA_UNIT_In)); + } + return TRUE; +} + +FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) { + FX_BOOL bProBreakBefore = FALSE; + CXFA_Node* pBreakBeforeNode = nullptr; + while (pRootSubform) { + for (CXFA_Node* pBreakNode = + pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild); + pBreakNode; + pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + XFA_Element eType = pBreakNode->GetElementType(); + if (eType == XFA_Element::BreakBefore || + (eType == XFA_Element::Break && + pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) != + XFA_ATTRIBUTEENUM_Auto)) { + bProBreakBefore = TRUE; + pBreakBeforeNode = pBreakNode; + break; + } + } + if (bProBreakBefore) + break; + + bProBreakBefore = TRUE; + pRootSubform = pRootSubform->GetFirstChildByClass(XFA_Element::Subform); + while (pRootSubform && + !XFA_ItemLayoutProcessor_IsTakingSpace(pRootSubform)) { + pRootSubform = + pRootSubform->GetNextSameClassSibling(XFA_Element::Subform); + } + } + CXFA_Node *pLeader, *pTrailer; + if (pBreakBeforeNode && + ExecuteBreakBeforeOrAfter(pBreakBeforeNode, TRUE, pLeader, pTrailer)) { + m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition(); + return TRUE; + } + return AppendNewPage(TRUE); +} + +FX_BOOL CXFA_LayoutPageMgr::AppendNewPage(FX_BOOL bFirstTemPage) { + if (m_pCurrentContainerRecord != + m_rgProposedContainerRecord.GetTailPosition()) { + return TRUE; + } + CXFA_Node* pPageNode = GetNextAvailPageArea(nullptr); + if (!pPageNode) + return FALSE; + if (bFirstTemPage && !m_pCurrentContainerRecord) + m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition(); + return !bFirstTemPage || m_pCurrentContainerRecord; +} + +void CXFA_LayoutPageMgr::RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord, + CXFA_ContainerRecord* pPrevRecord) { + if (!pNewRecord || !pPrevRecord) + return; + if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) { + RemoveLayoutItem(pNewRecord->pCurPageSet); + return; + } + if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) { + RemoveLayoutItem(pNewRecord->pCurPageArea); + return; + } + if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) { + RemoveLayoutItem(pNewRecord->pCurContentArea); + return; + } +} + +void CXFA_LayoutPageMgr::ReorderPendingLayoutRecordToTail( + CXFA_ContainerRecord* pNewRecord, + CXFA_ContainerRecord* pPrevRecord) { + if (!pNewRecord || !pPrevRecord) + return; + if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) { + ReorderLayoutItemToTail(pNewRecord->pCurPageSet); + return; + } + if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) { + ReorderLayoutItemToTail(pNewRecord->pCurPageArea); + return; + } + if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) { + ReorderLayoutItemToTail(pNewRecord->pCurContentArea); + return; + } +} + +void CXFA_LayoutPageMgr::SubmitContentItem( + CXFA_ContentLayoutItem* pContentLayoutItem, + XFA_ItemLayoutProcessorResult eStatus) { + if (pContentLayoutItem) { + GetCurrentContainerRecord()->pCurContentArea->AddChild(pContentLayoutItem); + m_bCreateOverFlowPage = FALSE; + } + + if (eStatus != XFA_ItemLayoutProcessorResult_Done) { + if (eStatus == XFA_ItemLayoutProcessorResult_PageFullBreak && + m_pCurrentContainerRecord == + m_rgProposedContainerRecord.GetTailPosition()) { + AppendNewPage(); + } + m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetTailPosition(); + m_pCurPageArea = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode; + } +} + +FX_FLOAT CXFA_LayoutPageMgr::GetAvailHeight() { + CXFA_ContainerLayoutItem* pLayoutItem = + GetCurrentContainerRecord()->pCurContentArea; + if (!pLayoutItem || !pLayoutItem->m_pFormNode) + return 0.0f; + + FX_FLOAT fAvailHeight = + pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); + if (fAvailHeight >= XFA_LAYOUT_FLOAT_PERCISION) + return fAvailHeight; + if (m_pCurrentContainerRecord == + m_rgProposedContainerRecord.GetHeadPosition()) { + return 0.0f; + } + return XFA_LAYOUT_FLOAT_MAX; +} + +FX_BOOL XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) { + CFX_WideString wsExpression; + pTestScript->TryContent(wsExpression); + if (wsExpression.IsEmpty()) + return TRUE; + return pTestScript->GetDocument()->GetNotify()->RunScript( + pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent, + XFA_ObjectType::ContainerNode)); +} + +CXFA_ContainerRecord* CXFA_LayoutPageMgr::CreateContainerRecord( + CXFA_Node* pPageNode, + FX_BOOL bCreateNew) { + CXFA_ContainerRecord* pNewRecord = new CXFA_ContainerRecord(); + if (m_pCurrentContainerRecord) { + if (!IsPageSetRootOrderedOccurrence() || !pPageNode) { + *pNewRecord = *GetCurrentContainerRecord(); + m_rgProposedContainerRecord.AddTail(pNewRecord); + return pNewRecord; + } + CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent); + if (!bCreateNew) { + if (pPageSet == m_pTemplatePageSetRoot) { + pNewRecord->pCurPageSet = m_pPageSetCurRoot; + } else { + CXFA_ContainerLayoutItem* pParentLayoutItem = + static_cast( + pPageSet->GetUserData(XFA_LAYOUTITEMKEY)); + if (!pParentLayoutItem) + pParentLayoutItem = m_pPageSetCurRoot; + + pNewRecord->pCurPageSet = pParentLayoutItem; + } + } else { + CXFA_ContainerLayoutItem* pParentPageSetLayout = nullptr; + if (pPageSet == GetCurrentContainerRecord()->pCurPageSet->m_pFormNode) { + pParentPageSetLayout = static_cast( + GetCurrentContainerRecord()->pCurPageSet->m_pParent); + } else { + pParentPageSetLayout = static_cast( + pPageSet->GetNodeItem(XFA_NODEITEM_Parent) + ->GetUserData(XFA_LAYOUTITEMKEY)); + } + CXFA_ContainerLayoutItem* pPageSetLayoutItem = + new CXFA_ContainerLayoutItem(pPageSet); + pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem); + if (!pParentPageSetLayout) { + CXFA_ContainerLayoutItem* pPrePageSet = m_pPageSetLayoutItemRoot; + while (pPrePageSet->m_pNextSibling) { + pPrePageSet = static_cast( + pPrePageSet->m_pNextSibling); + } + + pPrePageSet->m_pNextSibling = pPageSetLayoutItem; + m_pPageSetCurRoot = pPageSetLayoutItem; + } else { + pParentPageSetLayout->AddChild(pPageSetLayoutItem); + } + pNewRecord->pCurPageSet = pPageSetLayoutItem; + } + } else { + if (pPageNode) { + CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pPageSet == m_pTemplatePageSetRoot) { + pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot; + } else { + CXFA_ContainerLayoutItem* pPageSetLayoutItem = + new CXFA_ContainerLayoutItem(pPageSet); + pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem); + m_pPageSetLayoutItemRoot->AddChild(pPageSetLayoutItem); + pNewRecord->pCurPageSet = pPageSetLayoutItem; + } + } else { + pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot; + } + } + m_rgProposedContainerRecord.AddTail(pNewRecord); + return pNewRecord; +} + +void CXFA_LayoutPageMgr::AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, + CXFA_Node* pNewPageArea) { + CXFA_ContainerLayoutItem* pNewPageAreaLayoutItem = nullptr; + if (m_PageArray.GetSize() > m_nAvailPages) { + CXFA_ContainerLayoutItem* pContainerItem = m_PageArray[m_nAvailPages]; + pContainerItem->m_pFormNode = pNewPageArea; + m_nAvailPages++; + pNewPageAreaLayoutItem = pContainerItem; + } else { + CXFA_FFNotify* pNotify = pNewPageArea->GetDocument()->GetNotify(); + CXFA_ContainerLayoutItem* pContainerItem = + static_cast( + pNotify->OnCreateLayoutItem(pNewPageArea)); + m_PageArray.Add(pContainerItem); + m_nAvailPages++; + pNotify->OnPageEvent(pContainerItem, XFA_PAGEVIEWEVENT_PostRemoved); + pNewPageAreaLayoutItem = pContainerItem; + } + pNewRecord->pCurPageSet->AddChild(pNewPageAreaLayoutItem); + pNewRecord->pCurPageArea = pNewPageAreaLayoutItem; + pNewRecord->pCurContentArea = nullptr; +} + +void CXFA_LayoutPageMgr::AddContentAreaLayoutItem( + CXFA_ContainerRecord* pNewRecord, + CXFA_Node* pContentArea) { + if (!pContentArea) { + pNewRecord->pCurContentArea = nullptr; + return; + } + CXFA_ContainerLayoutItem* pNewContentAreaLayoutItem = + new CXFA_ContainerLayoutItem(pContentArea); + ASSERT(pNewRecord->pCurPageArea); + pNewRecord->pCurPageArea->AddChild(pNewContentAreaLayoutItem); + pNewRecord->pCurContentArea = pNewContentAreaLayoutItem; +} + +void CXFA_LayoutPageMgr::FinishPaginatedPageSets() { + CXFA_ContainerLayoutItem* pRootPageSetLayoutItem = m_pPageSetLayoutItemRoot; + for (; pRootPageSetLayoutItem; + pRootPageSetLayoutItem = static_cast( + pRootPageSetLayoutItem->m_pNextSibling)) { + CXFA_NodeIteratorTemplate + sIterator(pRootPageSetLayoutItem); + for (CXFA_ContainerLayoutItem* pPageSetLayoutItem = sIterator.GetCurrent(); + pPageSetLayoutItem; pPageSetLayoutItem = sIterator.MoveToNext()) { + XFA_ATTRIBUTEENUM ePageRelation = + pPageSetLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Relation); + switch (ePageRelation) { + case XFA_ATTRIBUTEENUM_OrderedOccurrence: + default: { ProcessLastPageSet(); } break; + case XFA_ATTRIBUTEENUM_SimplexPaginated: + case XFA_ATTRIBUTEENUM_DuplexPaginated: { + CXFA_LayoutItem* pLastPageAreaLayoutItem = nullptr; + int32_t nPageAreaCount = 0; + for (CXFA_LayoutItem* pPageAreaLayoutItem = + pPageSetLayoutItem->m_pFirstChild; + pPageAreaLayoutItem; + pPageAreaLayoutItem = pPageAreaLayoutItem->m_pNextSibling) { + if (pPageAreaLayoutItem->m_pFormNode->GetElementType() != + XFA_Element::PageArea) { + continue; + } + nPageAreaCount++; + pLastPageAreaLayoutItem = pPageAreaLayoutItem; + } + if (!pLastPageAreaLayoutItem) + break; + + if (!FindPageAreaFromPageSet_SimplexDuplex( + pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr, + TRUE, TRUE, nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only + : XFA_ATTRIBUTEENUM_Last) && + (nPageAreaCount == 1 && + !FindPageAreaFromPageSet_SimplexDuplex( + pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr, + TRUE, TRUE, XFA_ATTRIBUTEENUM_Last))) { + break; + } + CXFA_Node* pNode = m_pCurPageArea; + XFA_ATTRIBUTEENUM eCurChoice = + pNode->GetEnum(XFA_ATTRIBUTE_PagePosition); + if (eCurChoice == XFA_ATTRIBUTEENUM_Last) { + XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any; + pNode->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven); + XFA_ATTRIBUTEENUM eLastChoice = + pLastPageAreaLayoutItem->m_pFormNode->GetEnum( + XFA_ATTRIBUTE_PagePosition); + if (eLastChoice == XFA_ATTRIBUTEENUM_First && + (ePageRelation == XFA_ATTRIBUTEENUM_SimplexPaginated || + eOddOrEven != XFA_ATTRIBUTEENUM_Odd)) { + CXFA_ContainerRecord* pRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pRecord, pNode); + break; + } + } + FX_BOOL bUsable = TRUE; + CFX_ArrayTemplate rgUsedHeights; + for (CXFA_LayoutItem* pChildLayoutItem = + pLastPageAreaLayoutItem->m_pFirstChild; + pChildLayoutItem; + pChildLayoutItem = pChildLayoutItem->m_pNextSibling) { + if (pChildLayoutItem->m_pFormNode->GetElementType() != + XFA_Element::ContentArea) { + continue; + } + FX_FLOAT fUsedHeight = 0; + for (CXFA_LayoutItem* pContentChildLayoutItem = + pChildLayoutItem->m_pFirstChild; + pContentChildLayoutItem; + pContentChildLayoutItem = + pContentChildLayoutItem->m_pNextSibling) { + if (CXFA_ContentLayoutItem* pContent = + pContentChildLayoutItem->AsContentLayoutItem()) { + fUsedHeight += pContent->m_sSize.y; + } + } + rgUsedHeights.Add(fUsedHeight); + } + int32_t iCurContentAreaIndex = -1; + for (CXFA_Node* pContentAreaNode = + pNode->GetNodeItem(XFA_NODEITEM_FirstChild); + pContentAreaNode; + pContentAreaNode = + pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pContentAreaNode->GetElementType() != + XFA_Element::ContentArea) { + continue; + } + iCurContentAreaIndex++; + if (rgUsedHeights[iCurContentAreaIndex] > + pContentAreaNode->GetMeasure(XFA_ATTRIBUTE_H) + .ToUnit(XFA_UNIT_Pt) + + XFA_LAYOUT_FLOAT_PERCISION) { + bUsable = FALSE; + break; + } + } + if (bUsable) { + CXFA_LayoutItem* pChildLayoutItem = + pLastPageAreaLayoutItem->m_pFirstChild; + CXFA_Node* pContentAreaNode = + pNode->GetNodeItem(XFA_NODEITEM_FirstChild); + pLastPageAreaLayoutItem->m_pFormNode = pNode; + while (pChildLayoutItem && pContentAreaNode) { + if (pChildLayoutItem->m_pFormNode->GetElementType() != + XFA_Element::ContentArea) { + pChildLayoutItem = pChildLayoutItem->m_pNextSibling; + continue; + } + if (pContentAreaNode->GetElementType() != + XFA_Element::ContentArea) { + pContentAreaNode = + pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling); + continue; + } + pChildLayoutItem->m_pFormNode = pContentAreaNode; + pChildLayoutItem = pChildLayoutItem->m_pNextSibling; + pContentAreaNode = + pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling); + } + } else if (pNode->GetEnum(XFA_ATTRIBUTE_PagePosition) == + XFA_ATTRIBUTEENUM_Last) { + CXFA_ContainerRecord* pRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pRecord, pNode); + } + } break; + } + } + } +} + +int32_t CXFA_LayoutPageMgr::GetPageCount() const { + return m_PageArray.GetSize(); +} + +CXFA_ContainerLayoutItem* CXFA_LayoutPageMgr::GetPage(int32_t index) const { + if (index < 0 || index >= m_PageArray.GetSize()) + return nullptr; + return m_PageArray[index]; +} + +int32_t CXFA_LayoutPageMgr::GetPageIndex( + const CXFA_ContainerLayoutItem* pPage) const { + // FIXME: Find() method should take const. + return m_PageArray.Find(const_cast(pPage)); +} + +FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_Element eBreakType, + XFA_ATTRIBUTEENUM eTargetType, + CXFA_Node* pTarget, + FX_BOOL bStartNew) { + FX_BOOL bRet = FALSE; + switch (eTargetType) { + case XFA_ATTRIBUTEENUM_ContentArea: + if (pTarget && pTarget->GetElementType() != XFA_Element::ContentArea) + pTarget = nullptr; + if (!pTarget || !m_pCurrentContainerRecord || + pTarget != + GetCurrentContainerRecord()->pCurContentArea->m_pFormNode || + bStartNew) { + CXFA_Node* pPageArea = nullptr; + if (pTarget) + pPageArea = pTarget->GetNodeItem(XFA_NODEITEM_Parent); + + pPageArea = GetNextAvailPageArea(pPageArea, pTarget); + bRet = !!pPageArea; + } + break; + case XFA_ATTRIBUTEENUM_PageArea: + if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) + pTarget = nullptr; + if (!pTarget || !m_pCurrentContainerRecord || + pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode || + bStartNew) { + CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, nullptr, TRUE); + bRet = !!pPageArea; + } + break; + case XFA_ATTRIBUTEENUM_PageOdd: + if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) + pTarget = nullptr; + break; + case XFA_ATTRIBUTEENUM_PageEven: + if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) + pTarget = nullptr; + break; + case XFA_ATTRIBUTEENUM_Auto: + default: + break; + } + return bRet; +} + +FX_BOOL CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter( + CXFA_Node* pCurNode, + FX_BOOL bBefore, + CXFA_Node*& pBreakLeaderTemplate, + CXFA_Node*& pBreakTrailerTemplate) { + XFA_Element eType = pCurNode->GetElementType(); + switch (eType) { + case XFA_Element::BreakBefore: + case XFA_Element::BreakAfter: { + CFX_WideStringC wsBreakLeader, wsBreakTrailer; + CXFA_Node* pFormNode = pCurNode->GetNodeItem( + XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); + CXFA_Node* pContainer = pFormNode->GetTemplateNode(); + FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0; + CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_Element::Script); + if (pScript && !XFA_LayoutPageMgr_RunBreakTestScript(pScript)) + return FALSE; + + CFX_WideStringC wsTarget = pCurNode->GetCData(XFA_ATTRIBUTE_Target); + CXFA_Node* pTarget = + ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget); + wsBreakTrailer = pCurNode->GetCData(XFA_ATTRIBUTE_Trailer); + wsBreakLeader = pCurNode->GetCData(XFA_ATTRIBUTE_Leader); + pBreakLeaderTemplate = + ResolveBreakTarget(pContainer, TRUE, wsBreakLeader); + pBreakTrailerTemplate = + ResolveBreakTarget(pContainer, TRUE, wsBreakTrailer); + if (RunBreak(eType, pCurNode->GetEnum(XFA_ATTRIBUTE_TargetType), pTarget, + bStartNew)) { + return TRUE; + } + if (m_rgProposedContainerRecord.GetCount() > 0 && + m_pCurrentContainerRecord == + m_rgProposedContainerRecord.GetHeadPosition() && + eType == XFA_Element::BreakBefore) { + CXFA_Node* pParentNode = pFormNode->GetNodeItem( + XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); + if (!pParentNode || + pFormNode != + pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild, + XFA_ObjectType::ContainerNode)) { + break; + } + pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent); + if (!pParentNode || + pParentNode->GetElementType() != XFA_Element::Form) { + break; + } + return TRUE; + } + break; + } + case XFA_Element::Break: { + FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0; + CFX_WideStringC wsTarget = pCurNode->GetCData( + bBefore ? XFA_ATTRIBUTE_BeforeTarget : XFA_ATTRIBUTE_AfterTarget); + CXFA_Node* pTarget = + ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget); + if (RunBreak(bBefore ? XFA_Element::BreakBefore : XFA_Element::BreakAfter, + pCurNode->GetEnum(bBefore ? XFA_ATTRIBUTE_Before + : XFA_ATTRIBUTE_After), + pTarget, bStartNew)) { + return TRUE; + } + break; + } + default: + break; + } + return FALSE; +} + +FX_BOOL CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter( + CXFA_Node* pBreakNode, + FX_BOOL bBefore, + CXFA_Node*& pBreakLeaderNode, + CXFA_Node*& pBreakTrailerNode, + FX_BOOL& bCreatePage) { + CXFA_Node* pLeaderTemplate = nullptr; + CXFA_Node* pTrailerTemplate = nullptr; + CXFA_Node* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent, + XFA_ObjectType::ContainerNode); + if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) { + bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore, + pLeaderTemplate, pTrailerTemplate); + CXFA_Document* pDocument = pBreakNode->GetDocument(); + CXFA_Node* pDataScope = nullptr; + pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent, + XFA_ObjectType::ContainerNode); + if (pLeaderTemplate) { + if (!pDataScope) + pDataScope = XFA_DataMerge_FindDataScope(pFormNode); + + pBreakLeaderNode = pDocument->DataMerge_CopyContainer( + pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); + pDocument->DataMerge_UpdateBindingRelations(pBreakLeaderNode); + SetLayoutGeneratedNodeFlag(pBreakLeaderNode); + } + if (pTrailerTemplate) { + if (!pDataScope) + pDataScope = XFA_DataMerge_FindDataScope(pFormNode); + + pBreakTrailerNode = pDocument->DataMerge_CopyContainer( + pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); + pDocument->DataMerge_UpdateBindingRelations(pBreakTrailerNode); + SetLayoutGeneratedNodeFlag(pBreakTrailerNode); + } + return TRUE; + } + return FALSE; +} + +FX_BOOL CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer( + CXFA_Node* pBookendNode, + FX_BOOL bLeader, + CXFA_Node*& pBookendAppendNode) { + CXFA_Node* pLeaderTemplate = nullptr; + CXFA_Node* pFormNode = pBookendNode->GetNodeItem( + XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); + if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) { + CXFA_Document* pDocument = pBookendNode->GetDocument(); + CXFA_Node* pDataScope = nullptr; + if (pLeaderTemplate) { + if (!pDataScope) + pDataScope = XFA_DataMerge_FindDataScope(pFormNode); + + pBookendAppendNode = pDocument->DataMerge_CopyContainer( + pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); + pDocument->DataMerge_UpdateBindingRelations(pBookendAppendNode); + SetLayoutGeneratedNodeFlag(pBookendAppendNode); + return TRUE; + } + } + return FALSE; +} + +CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode, + CXFA_Node*& pLeaderTemplate, + CXFA_Node*& pTrailerTemplate, + FX_BOOL bCreatePage) { + CXFA_Node* pContainer = + pOverflowNode + ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode) + ->GetTemplateNode(); + if (pOverflowNode->GetElementType() == XFA_Element::Break) { + CFX_WideStringC wsOverflowLeader; + CFX_WideStringC wsOverflowTarget; + CFX_WideStringC wsOverflowTrailer; + pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader); + pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer); + pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget); + if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() || + !wsOverflowTarget.IsEmpty()) { + if (!wsOverflowTarget.IsEmpty() && bCreatePage && + !m_bCreateOverFlowPage) { + CXFA_Node* pTarget = + ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget); + if (pTarget) { + m_bCreateOverFlowPage = TRUE; + switch (pTarget->GetElementType()) { + case XFA_Element::PageArea: + RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, + pTarget, TRUE); + break; + case XFA_Element::ContentArea: + RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea, + pTarget, TRUE); + break; + default: + break; + } + } + } + if (!bCreatePage) { + pLeaderTemplate = + ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader); + pTrailerTemplate = + ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer); + } + return pOverflowNode; + } + return nullptr; + } + + if (pOverflowNode->GetElementType() != XFA_Element::Overflow) + return nullptr; + + CFX_WideStringC wsOverflowLeader; + CFX_WideStringC wsOverflowTrailer; + CFX_WideStringC wsOverflowTarget; + pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader); + pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer); + pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget); + if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) { + CXFA_Node* pTarget = + ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget); + if (pTarget) { + m_bCreateOverFlowPage = TRUE; + switch (pTarget->GetElementType()) { + case XFA_Element::PageArea: + RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget, + TRUE); + break; + case XFA_Element::ContentArea: + RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea, + pTarget, TRUE); + break; + default: + break; + } + } + } + if (!bCreatePage) { + pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader); + pTrailerTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer); + } + return pOverflowNode; +} + +FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode, + CXFA_Node*& pLeaderNode, + CXFA_Node*& pTrailerNode, + FX_BOOL bDataMerge, + FX_BOOL bCreatePage) { + if (!pFormNode) + return FALSE; + + CXFA_Node* pLeaderTemplate = nullptr; + CXFA_Node* pTrailerTemplate = nullptr; + FX_BOOL bIsOverflowNode = FALSE; + if (pFormNode->GetElementType() == XFA_Element::Overflow || + pFormNode->GetElementType() == XFA_Element::Break) { + bIsOverflowNode = TRUE; + } + for (CXFA_Node* pCurNode = + bIsOverflowNode ? pFormNode + : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); + pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) { + if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate, + bCreatePage)) { + if (bIsOverflowNode) + pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent); + + CXFA_Document* pDocument = pCurNode->GetDocument(); + CXFA_Node* pDataScope = nullptr; + if (pLeaderTemplate) { + if (!pDataScope) + pDataScope = XFA_DataMerge_FindDataScope(pFormNode); + + pLeaderNode = pDocument->DataMerge_CopyContainer( + pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); + pDocument->DataMerge_UpdateBindingRelations(pLeaderNode); + SetLayoutGeneratedNodeFlag(pLeaderNode); + } + if (pTrailerTemplate) { + if (!pDataScope) + pDataScope = XFA_DataMerge_FindDataScope(pFormNode); + + pTrailerNode = pDocument->DataMerge_CopyContainer( + pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); + pDocument->DataMerge_UpdateBindingRelations(pTrailerNode); + SetLayoutGeneratedNodeFlag(pTrailerNode); + } + return TRUE; + } + if (bIsOverflowNode) { + break; + } + } + return FALSE; +} + +FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer( + CXFA_Node* pBookendNode, + FX_BOOL bLeader, + CXFA_Node*& pBookendAppendTemplate) { + CFX_WideStringC wsBookendLeader; + CXFA_Node* pContainer = + pBookendNode + ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode) + ->GetTemplateNode(); + if (pBookendNode->GetElementType() == XFA_Element::Break) { + pBookendNode->TryCData( + bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer, + wsBookendLeader); + if (!wsBookendLeader.IsEmpty()) { + pBookendAppendTemplate = + ResolveBreakTarget(pContainer, FALSE, wsBookendLeader); + return TRUE; + } + return FALSE; + } else if (pBookendNode->GetElementType() == XFA_Element::Bookend) { + pBookendNode->TryCData( + bLeader ? XFA_ATTRIBUTE_Leader : XFA_ATTRIBUTE_Trailer, + wsBookendLeader); + pBookendAppendTemplate = + ResolveBreakTarget(pContainer, TRUE, wsBookendLeader); + return TRUE; + } + return FALSE; +} + +FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet( + CXFA_Node* pPageSet, + CXFA_Node* pStartChild, + CXFA_Node* pTargetPageArea, + CXFA_Node* pTargetContentArea, + FX_BOOL bNewPage, + FX_BOOL bQuery) { + if (!pPageSet && !pStartChild) + return FALSE; + + if (IsPageSetRootOrderedOccurrence()) { + return FindPageAreaFromPageSet_Ordered(pPageSet, pStartChild, + pTargetPageArea, pTargetContentArea, + bNewPage, bQuery); + } + XFA_ATTRIBUTEENUM ePreferredPosition = m_pCurrentContainerRecord + ? XFA_ATTRIBUTEENUM_Rest + : XFA_ATTRIBUTEENUM_First; + return FindPageAreaFromPageSet_SimplexDuplex( + pPageSet, pStartChild, pTargetPageArea, pTargetContentArea, bNewPage, + bQuery, ePreferredPosition); +} + +FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_Ordered( + CXFA_Node* pPageSet, + CXFA_Node* pStartChild, + CXFA_Node* pTargetPageArea, + CXFA_Node* pTargetContentArea, + FX_BOOL bNewPage, + FX_BOOL bQuery) { + int32_t iPageSetCount = 0; + if (!pStartChild && !bQuery) { + m_pPageSetMap.Lookup(pPageSet, iPageSetCount); + int32_t iMax = -1; + CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur); + if (pOccurNode) + pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE); + if (iMax >= 0 && iMax <= iPageSetCount) + return FALSE; + } + + FX_BOOL bRes = FALSE; + CXFA_Node* pCurrentNode = + pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling) + : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); + for (; pCurrentNode; + pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { + if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) { + if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) { + if (pTargetPageArea == pCurrentNode) { + CreateMinPageRecord(pCurrentNode, TRUE); + pTargetPageArea = nullptr; + } + continue; + } + if (!bQuery) { + CXFA_ContainerRecord* pNewRecord = + CreateContainerRecord(pCurrentNode, !pStartChild); + AddPageAreaLayoutItem(pNewRecord, pCurrentNode); + if (!pTargetContentArea) { + pTargetContentArea = + pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea); + } + AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); + } + m_pCurPageArea = pCurrentNode; + m_nCurPageCount = 1; + bRes = TRUE; + break; + } + if (!bQuery) + CreateMinPageRecord(pCurrentNode, FALSE); + } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { + if (FindPageAreaFromPageSet_Ordered(pCurrentNode, nullptr, + pTargetPageArea, pTargetContentArea, + bNewPage, bQuery)) { + bRes = TRUE; + break; + } + if (!bQuery) + CreateMinPageSetRecord(pCurrentNode, TRUE); + } + } + if (!pStartChild && bRes && !bQuery) + m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount); + return bRes; +} + +FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex( + CXFA_Node* pPageSet, + CXFA_Node* pStartChild, + CXFA_Node* pTargetPageArea, + CXFA_Node* pTargetContentArea, + FX_BOOL bNewPage, + FX_BOOL bQuery, + XFA_ATTRIBUTEENUM ePreferredPosition) { + const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any; + CXFA_Node* pPreferredPageArea = nullptr; + CXFA_Node* pFallbackPageArea = nullptr; + CXFA_Node* pCurrentNode = nullptr; + if (!pStartChild || pStartChild->GetElementType() == XFA_Element::PageArea) + pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); + else + pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling); + + for (; pCurrentNode; + pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { + if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE)) + continue; + + XFA_ATTRIBUTEENUM eCurPagePosition = + pCurrentNode->GetEnum(XFA_ATTRIBUTE_PagePosition); + if (ePreferredPosition == XFA_ATTRIBUTEENUM_Last) { + if (eCurPagePosition != ePreferredPosition) + continue; + if (m_ePageSetMode == XFA_ATTRIBUTEENUM_SimplexPaginated || + pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) == + XFA_ATTRIBUTEENUM_Any) { + pPreferredPageArea = pCurrentNode; + break; + } + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pNewRecord, pCurrentNode); + AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass( + XFA_Element::ContentArea)); + pPreferredPageArea = pCurrentNode; + return FALSE; + } + if (ePreferredPosition == XFA_ATTRIBUTEENUM_Only) { + if (eCurPagePosition != ePreferredPosition) + continue; + if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated || + pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) == + XFA_ATTRIBUTEENUM_Any) { + pPreferredPageArea = pCurrentNode; + break; + } + return FALSE; + } + if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) { + if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) { + if (pTargetPageArea == pCurrentNode) { + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pNewRecord, pCurrentNode); + pTargetPageArea = nullptr; + } + continue; + } + if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest && + eCurPagePosition == XFA_ATTRIBUTEENUM_Any) || + eCurPagePosition == ePreferredPosition) { + pPreferredPageArea = pCurrentNode; + break; + } else if (eCurPagePosition == eFallbackPosition && + !pFallbackPageArea) { + pFallbackPageArea = pCurrentNode; + } + } else if (pTargetPageArea && + !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) { + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pNewRecord, pCurrentNode); + AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass( + XFA_Element::ContentArea)); + } + } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { + if (FindPageAreaFromPageSet_SimplexDuplex( + pCurrentNode, nullptr, pTargetPageArea, pTargetContentArea, + bNewPage, bQuery, ePreferredPosition)) { + break; + } + } + } + + CXFA_Node* pCurPageArea = nullptr; + if (pPreferredPageArea) + pCurPageArea = pPreferredPageArea; + else if (pFallbackPageArea) + pCurPageArea = pFallbackPageArea; + + if (!pCurPageArea) + return FALSE; + + if (!bQuery) { + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pNewRecord, pCurPageArea); + if (!pTargetContentArea) { + pTargetContentArea = + pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea); + } + AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); + } + m_pCurPageArea = pCurPageArea; + return TRUE; +} + +FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea, + FX_BOOL bLastMatch) { + if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated) + return TRUE; + + XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any; + pPageArea->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven); + if (eOddOrEven != XFA_ATTRIBUTEENUM_Any) { + int32_t iPageCount = GetPageCount(); + if (bLastMatch) { + return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 1 + : iPageCount % 2 == 0; + } + return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 0 + : iPageCount % 2 == 1; + } + return TRUE; +} + +CXFA_Node* CXFA_LayoutPageMgr::GetNextAvailPageArea( + CXFA_Node* pTargetPageArea, + CXFA_Node* pTargetContentArea, + FX_BOOL bNewPage, + FX_BOOL bQuery) { + if (!m_pCurPageArea) { + FindPageAreaFromPageSet(m_pTemplatePageSetRoot, nullptr, pTargetPageArea, + pTargetContentArea, bNewPage, bQuery); + ASSERT(m_pCurPageArea); + return m_pCurPageArea; + } + + if (!pTargetPageArea || pTargetPageArea == m_pCurPageArea) { + if (!bNewPage && GetNextContentArea(pTargetContentArea)) + return m_pCurPageArea; + + if (IsPageSetRootOrderedOccurrence()) { + int32_t iMax = -1; + CXFA_Node* pOccurNode = + m_pCurPageArea->GetFirstChildByClass(XFA_Element::Occur); + if (pOccurNode) + pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE); + if ((iMax < 0 || m_nCurPageCount < iMax)) { + if (!bQuery) { + CXFA_ContainerRecord* pNewRecord = + CreateContainerRecord(m_pCurPageArea); + AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea); + if (!pTargetContentArea) { + pTargetContentArea = + m_pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea); + } + AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); + } + m_nCurPageCount++; + return m_pCurPageArea; + } + } + } + + if (!bQuery && IsPageSetRootOrderedOccurrence()) + CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE); + if (FindPageAreaFromPageSet(m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent), + m_pCurPageArea, pTargetPageArea, + pTargetContentArea, bNewPage, bQuery)) { + return m_pCurPageArea; + } + + CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent); + while (TRUE) { + if (FindPageAreaFromPageSet(pPageSet, nullptr, pTargetPageArea, + pTargetContentArea, bNewPage, bQuery)) { + return m_pCurPageArea; + } + if (!bQuery && IsPageSetRootOrderedOccurrence()) + CreateMinPageSetRecord(pPageSet); + if (FindPageAreaFromPageSet(nullptr, pPageSet, pTargetPageArea, + pTargetContentArea, bNewPage, bQuery)) { + return m_pCurPageArea; + } + if (pPageSet == m_pTemplatePageSetRoot) + break; + + pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent); + } + return nullptr; +} + +FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) { + CXFA_Node* pCurContentNode = + GetCurrentContainerRecord()->pCurContentArea->m_pFormNode; + if (!pContentArea) { + pContentArea = + pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea); + if (!pContentArea) + return FALSE; + } else { + if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea) + return FALSE; + + CXFA_ContainerLayoutItem* pContentAreaLayout = nullptr; + if (!CheckContentAreaNotUsed(GetCurrentContainerRecord()->pCurPageArea, + pContentArea, pContentAreaLayout)) { + return FALSE; + } + if (pContentAreaLayout) { + if (pContentAreaLayout->m_pFormNode != pCurContentNode) { + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + pNewRecord->pCurContentArea = pContentAreaLayout; + return TRUE; + } + return FALSE; + } + } + + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + AddContentAreaLayoutItem(pNewRecord, pContentArea); + return TRUE; +} + +void CXFA_LayoutPageMgr::InitPageSetMap() { + if (!IsPageSetRootOrderedOccurrence()) + return; + + CXFA_NodeIterator sIterator(m_pTemplatePageSetRoot); + for (CXFA_Node* pPageSetNode = sIterator.GetCurrent(); pPageSetNode; + pPageSetNode = sIterator.MoveToNext()) { + if (pPageSetNode->GetElementType() == XFA_Element::PageSet) { + XFA_ATTRIBUTEENUM eRelation = + pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation); + if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence) + m_pPageSetMap.SetAt(pPageSetNode, 0); + } + } +} + +int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea, + FX_BOOL bTargetPageArea, + FX_BOOL bCreateLast) { + if (!pPageArea) + return 0; + + CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_Element::Occur); + int32_t iMin = 0; + if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) || + bTargetPageArea) { + CXFA_Node* pContentArea = + pPageArea->GetFirstChildByClass(XFA_Element::ContentArea); + if (iMin < 1 && bTargetPageArea && !pContentArea) + iMin = 1; + + int32_t i = 0; + if (bCreateLast) + i = m_nCurPageCount; + + for (; i < iMin; i++) { + CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); + AddPageAreaLayoutItem(pNewRecord, pPageArea); + AddContentAreaLayoutItem(pNewRecord, pContentArea); + } + } + return iMin; +} + +void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet, + FX_BOOL bCreateAll) { + if (!pPageSet) + return; + + int32_t iCurSetCount = 0; + if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount)) + return; + if (bCreateAll) + iCurSetCount = 0; + + CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur); + int32_t iMin = 0; + if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) { + if (iCurSetCount < iMin) { + for (int32_t i = 0; i < iMin - iCurSetCount; i++) { + for (CXFA_Node* pCurrentPageNode = + pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); + pCurrentPageNode; pCurrentPageNode = pCurrentPageNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + if (pCurrentPageNode->GetElementType() == XFA_Element::PageArea) { + CreateMinPageRecord(pCurrentPageNode, FALSE); + } else if (pCurrentPageNode->GetElementType() == + XFA_Element::PageSet) { + CreateMinPageSetRecord(pCurrentPageNode, TRUE); + } + } + } + m_pPageSetMap.SetAt(pPageSet, iMin); + } + } +} + +void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) { + if (!pRecordNode) + return; + + for (CXFA_Node* pCurrentNode = + pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling); + pCurrentNode; + pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pCurrentNode->GetElementType() == XFA_Element::PageArea) + CreateMinPageRecord(pCurrentNode, FALSE); + else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) + CreateMinPageSetRecord(pCurrentNode, TRUE); + } +} + +void CXFA_LayoutPageMgr::ProcessLastPageSet() { + CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE); + CreateNextMinRecord(m_pCurPageArea); + CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent); + while (TRUE) { + CreateMinPageSetRecord(pPageSet); + if (pPageSet == m_pTemplatePageSetRoot) + break; + + CreateNextMinRecord(pPageSet); + pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent); + } +} + +FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) { + CXFA_Node* pCurContentNode = + GetCurrentContainerRecord()->pCurContentArea->m_pFormNode; + if (!pCurContentNode) + return FALSE; + + pCurContentNode = + pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea); + if (pCurContentNode) { + FX_FLOAT fNextContentHeight = + pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); + return fNextContentHeight > fChildHeight; + } + + CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode; + CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_Element::Occur); + int32_t iMax = 0; + if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) { + if (m_nCurPageCount == iMax) { + CXFA_Node* pSrcPage = m_pCurPageArea; + int32_t nSrcPageCount = m_nCurPageCount; + FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition(); + CXFA_Node* pNextPage = + GetNextAvailPageArea(nullptr, nullptr, FALSE, TRUE); + m_pCurPageArea = pSrcPage; + m_nCurPageCount = nSrcPageCount; + CXFA_ContainerRecord* pPrevRecord = static_cast( + m_rgProposedContainerRecord.GetNext(psSrcRecord)); + while (psSrcRecord) { + FX_POSITION psSaveRecord = psSrcRecord; + CXFA_ContainerRecord* pInsertRecord = + static_cast( + m_rgProposedContainerRecord.GetNext(psSrcRecord)); + RemoveLayoutRecord(pInsertRecord, pPrevRecord); + delete pInsertRecord; + m_rgProposedContainerRecord.RemoveAt(psSaveRecord); + } + if (pNextPage) { + CXFA_Node* pContentArea = + pNextPage->GetFirstChildByClass(XFA_Element::ContentArea); + if (pContentArea) { + FX_FLOAT fNextContentHeight = + pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); + if (fNextContentHeight > fChildHeight) + return TRUE; + } + } + return FALSE; + } + } + + CXFA_Node* pContentArea = + pPageNode->GetFirstChildByClass(XFA_Element::ContentArea); + FX_FLOAT fNextContentHeight = + pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); + if (fNextContentHeight < XFA_LAYOUT_FLOAT_PERCISION) + return TRUE; + if (fNextContentHeight > fChildHeight) + return TRUE; + return FALSE; +} + +void CXFA_LayoutPageMgr::ClearData() { + ClearRecordList(); +} + +void CXFA_LayoutPageMgr::ClearRecordList() { + if (!m_pTemplatePageSetRoot) + return; + if (m_rgProposedContainerRecord.GetCount() > 0) { + FX_POSITION sPos; + sPos = m_rgProposedContainerRecord.GetHeadPosition(); + while (sPos) { + CXFA_ContainerRecord* pRecord = static_cast( + m_rgProposedContainerRecord.GetNext(sPos)); + delete pRecord; + } + m_rgProposedContainerRecord.RemoveAll(); + } + m_pCurrentContainerRecord = nullptr; + m_pCurPageArea = nullptr; + m_nCurPageCount = 0; + m_bCreateOverFlowPage = FALSE; + m_pPageSetMap.RemoveAll(); +} + +CXFA_LayoutItem* CXFA_LayoutPageMgr::FindOrCreateLayoutItem( + CXFA_Node* pFormNode) { + return pFormNode->GetDocument()->GetNotify()->OnCreateLayoutItem(pFormNode); +} + +void CXFA_LayoutPageMgr::SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem) { + CXFA_LayoutItem* pNextLayoutItem; + CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild; + while (pCurLayoutItem) { + pNextLayoutItem = pCurLayoutItem->m_pNextSibling; + if (pCurLayoutItem->IsContentLayoutItem()) { + if (pCurLayoutItem->m_pFormNode->HasRemovedChildren()) { + CXFA_FFNotify* pNotify = + m_pTemplatePageSetRoot->GetDocument()->GetNotify(); + CXFA_LayoutProcessor* pDocLayout = + m_pTemplatePageSetRoot->GetDocument()->GetDocLayout(); + if (pCurLayoutItem->m_pFirstChild) + SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout); + + pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem); + delete pCurLayoutItem; + pCurLayoutItem = pNextLayoutItem; + continue; + } + + if (pCurLayoutItem->m_pFormNode->IsLayoutGeneratedNode()) { + CXFA_NodeIteratorTemplate + sIterator(pCurLayoutItem->m_pFormNode); + for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode; + pNode = sIterator.MoveToNext()) { + pNode->SetFlag(XFA_NodeFlag_UnusedNode, false); + } + } + } + + if (pCurLayoutItem->m_pFirstChild) + SaveLayoutItem(pCurLayoutItem); + + pCurLayoutItem->m_pParent = nullptr; + pCurLayoutItem->m_pNextSibling = nullptr; + pCurLayoutItem->m_pFirstChild = nullptr; + if (!pCurLayoutItem->IsContentLayoutItem() && + pCurLayoutItem->m_pFormNode->GetElementType() != + XFA_Element::PageArea) { + delete pCurLayoutItem; + } + pCurLayoutItem = pNextLayoutItem; + } +} + +CXFA_Node* CXFA_LayoutPageMgr::QueryOverflow( + CXFA_Node* pFormNode, + CXFA_LayoutContext* pLayoutContext) { + for (CXFA_Node* pCurNode = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); + pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) { + if (pCurNode->GetElementType() == XFA_Element::Break) { + CFX_WideStringC wsOverflowLeader; + CFX_WideStringC wsOverflowTarget; + CFX_WideStringC wsOverflowTrailer; + pCurNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader); + pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer); + pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget); + if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() || + !wsOverflowTarget.IsEmpty()) { + return pCurNode; + } + return nullptr; + } + if (pCurNode->GetElementType() == XFA_Element::Overflow) + return pCurNode; + } + return nullptr; +} + +void CXFA_LayoutPageMgr::MergePageSetContents() { + CXFA_Document* pDocument = m_pTemplatePageSetRoot->GetDocument(); + CXFA_FFNotify* pNotify = pDocument->GetNotify(); + CXFA_LayoutProcessor* pDocLayout = pDocument->GetDocLayout(); + CXFA_ContainerLayoutItem* pRootLayout = GetRootLayoutItem(); + { + for (int32_t iIndex = 0; iIndex < pDocument->m_pPendingPageSet.GetSize(); + iIndex++) { + CXFA_NodeIteratorTemplate + sIterator(pDocument->m_pPendingPageSet.GetAt(iIndex)); + for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode; + pNode = sIterator.MoveToNext()) { + if (pNode->IsContainerNode()) { + CXFA_Node* pBindNode = pNode->GetBindData(); + if (pBindNode) { + pBindNode->RemoveBindItem(pNode); + pNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); + } + } + pNode->SetFlag(XFA_NodeFlag_UnusedNode, true); + } + } + } + + int32_t iIndex = 0; + for (; pRootLayout; pRootLayout = static_cast( + pRootLayout->m_pNextSibling)) { + CXFA_Node* pPendingPageSet = nullptr; + CXFA_NodeIteratorTemplate< + CXFA_ContainerLayoutItem, + CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> + iterator(pRootLayout); + CXFA_ContainerLayoutItem* pRootPageSetContainerItem = iterator.GetCurrent(); + ASSERT(pRootPageSetContainerItem->m_pFormNode->GetElementType() == + XFA_Element::PageSet); + if (iIndex < pDocument->m_pPendingPageSet.GetSize()) { + pPendingPageSet = pDocument->m_pPendingPageSet.GetAt(iIndex); + iIndex++; + } + if (!pPendingPageSet) { + if (pRootPageSetContainerItem->m_pFormNode->GetPacketID() == + XFA_XDPPACKET_Template) { + pPendingPageSet = + pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE); + } else { + pPendingPageSet = pRootPageSetContainerItem->m_pFormNode; + } + } + if (pRootPageSetContainerItem->m_pFormNode->GetUserData( + XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) { + pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY, + nullptr); + } + pRootPageSetContainerItem->m_pFormNode = pPendingPageSet; + pPendingPageSet->ClearFlag(XFA_NodeFlag_UnusedNode); + for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext(); + pContainerItem; pContainerItem = iterator.MoveToNext()) { + CXFA_Node* pNode = pContainerItem->m_pFormNode; + if (pNode->GetPacketID() != XFA_XDPPACKET_Template) + continue; + + switch (pNode->GetElementType()) { + case XFA_Element::PageSet: { + CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; + pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer( + pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE, + nullptr); + break; + } + case XFA_Element::PageArea: { + CXFA_ContainerLayoutItem* pFormLayout = pContainerItem; + CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; + FX_BOOL bIsExistForm = TRUE; + for (int32_t iLevel = 0; iLevel < 3; iLevel++) { + pFormLayout = static_cast( + pFormLayout->m_pFirstChild); + if (iLevel == 2) { + while (pFormLayout && + !XFA_ItemLayoutProcessor_IsTakingSpace( + pFormLayout->m_pFormNode)) { + pFormLayout = static_cast( + pFormLayout->m_pNextSibling); + } + } + if (!pFormLayout) { + bIsExistForm = FALSE; + break; + } + } + if (bIsExistForm) { + CXFA_Node* pNewSubform = pFormLayout->m_pFormNode; + if (pContainerItem->m_pOldSubform && + pContainerItem->m_pOldSubform != pNewSubform) { + CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance( + pDocument, pContainerItem->m_pFormNode->GetElementType(), + pContainerItem->m_pFormNode->GetNameHash(), pParentNode); + CXFA_ContainerIterator sIterator(pExistingNode); + for (CXFA_Node* pIter = sIterator.GetCurrent(); pIter; + pIter = sIterator.MoveToNext()) { + if (pIter->GetElementType() != XFA_Element::ContentArea) { + CXFA_LayoutItem* pLayoutItem = static_cast( + pIter->GetUserData(XFA_LAYOUTITEMKEY)); + if (pLayoutItem) { + pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); + delete pLayoutItem; + } + } + } + if (pExistingNode) { + pParentNode->RemoveChild(pExistingNode); + } + } + pContainerItem->m_pOldSubform = pNewSubform; + } + pContainerItem->m_pFormNode = pDocument->DataMerge_CopyContainer( + pContainerItem->m_pFormNode, pParentNode, + ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)), TRUE, TRUE, + TRUE); + break; + } + case XFA_Element::ContentArea: { + CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; + for (CXFA_Node* pChildNode = + pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild); + pChildNode; + pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pChildNode->GetTemplateNode() != pContainerItem->m_pFormNode) { + continue; + } + pContainerItem->m_pFormNode = pChildNode; + break; + } + break; + } + default: + break; + } + } + if (!pPendingPageSet->GetNodeItem(XFA_NODEITEM_Parent)) { + CXFA_Node* pFormToplevelSubform = + pDocument->GetXFAObject(XFA_HASHCODE_Form) + ->AsNode() + ->GetFirstChildByClass(XFA_Element::Subform); + pFormToplevelSubform->InsertChild(pPendingPageSet); + } + pDocument->DataMerge_UpdateBindingRelations(pPendingPageSet); + pPendingPageSet->SetFlag(XFA_NodeFlag_Initialized, true); + } + + CXFA_Node* pPageSet = GetRootLayoutItem()->m_pFormNode; + while (pPageSet) { + CXFA_Node* pNextPageSet = + pPageSet->GetNextSameClassSibling(XFA_Element::PageSet); + CXFA_NodeIteratorTemplate + sIterator(pPageSet); + CXFA_Node* pNode = sIterator.GetCurrent(); + while (pNode) { + if (pNode->IsUnusedNode()) { + if (pNode->IsContainerNode()) { + XFA_Element eType = pNode->GetElementType(); + if (eType == XFA_Element::PageArea || eType == XFA_Element::PageSet) { + CXFA_ContainerIterator iteChild(pNode); + CXFA_Node* pChildNode = iteChild.MoveToNext(); + for (; pChildNode; pChildNode = iteChild.MoveToNext()) { + CXFA_LayoutItem* pLayoutItem = static_cast( + pChildNode->GetUserData(XFA_LAYOUTITEMKEY)); + if (pLayoutItem) { + pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); + delete pLayoutItem; + } + } + } else if (eType != XFA_Element::ContentArea) { + CXFA_LayoutItem* pLayoutItem = static_cast( + pNode->GetUserData(XFA_LAYOUTITEMKEY)); + if (pLayoutItem) { + pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); + delete pLayoutItem; + } + } + CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext(); + pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode); + pNode = pNext; + } else { + pNode->ClearFlag(XFA_NodeFlag_UnusedNode); + pNode->SetFlag(XFA_NodeFlag_Initialized, true); + pNode = sIterator.MoveToNext(); + } + } else { + pNode->SetFlag(XFA_NodeFlag_Initialized, true); + pNode = sIterator.MoveToNext(); + } + } + pPageSet = pNextPageSet; + } +} + +void CXFA_LayoutPageMgr::LayoutPageSetContents() { + CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem(); + for (; pRootLayoutItem; + pRootLayoutItem = static_cast( + pRootLayoutItem->m_pNextSibling)) { + CXFA_NodeIteratorTemplate< + CXFA_ContainerLayoutItem, + CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> + iterator(pRootLayoutItem); + for (CXFA_ContainerLayoutItem* pContainerItem = iterator.GetCurrent(); + pContainerItem; pContainerItem = iterator.MoveToNext()) { + CXFA_Node* pNode = pContainerItem->m_pFormNode; + switch (pNode->GetElementType()) { + case XFA_Element::PageArea: + m_pLayoutProcessor->GetRootRootItemLayoutProcessor() + ->DoLayoutPageArea(pContainerItem); + break; + default: + break; + } + } + } +} + +void CXFA_LayoutPageMgr::SyncLayoutData() { + MergePageSetContents(); + LayoutPageSetContents(); + CXFA_FFNotify* pNotify = m_pTemplatePageSetRoot->GetDocument()->GetNotify(); + int32_t nPageIdx = -1; + CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem(); + for (; pRootLayoutItem; + pRootLayoutItem = static_cast( + pRootLayoutItem->m_pNextSibling)) { + CXFA_NodeIteratorTemplate< + CXFA_ContainerLayoutItem, + CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> + iteratorParent(pRootLayoutItem); + for (CXFA_ContainerLayoutItem* pContainerItem = iteratorParent.GetCurrent(); + pContainerItem; pContainerItem = iteratorParent.MoveToNext()) { + switch (pContainerItem->m_pFormNode->GetElementType()) { + case XFA_Element::PageArea: { + nPageIdx++; + uint32_t dwRelevant = + XFA_WidgetStatus_Viewable | XFA_WidgetStatus_Printable; + CXFA_NodeIteratorTemplate + iterator(pContainerItem); + CXFA_LayoutItem* pChildLayoutItem = iterator.GetCurrent(); + while (pChildLayoutItem) { + CXFA_ContentLayoutItem* pContentItem = + pChildLayoutItem->AsContentLayoutItem(); + if (!pContentItem) { + pChildLayoutItem = iterator.MoveToNext(); + continue; + } + FX_BOOL bVisible = + (pContentItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence) == + XFA_ATTRIBUTEENUM_Visible); + uint32_t dwRelevantChild = + GetRelevant(pContentItem->m_pFormNode, dwRelevant); + SyncContainer(pNotify, m_pLayoutProcessor, pContentItem, + dwRelevantChild, bVisible, nPageIdx); + pChildLayoutItem = iterator.SkipChildrenAndMoveToNext(); + } + break; + } + default: + break; + } + } + } + + int32_t nPage = m_PageArray.GetSize(); + for (int32_t i = nPage - 1; i >= m_nAvailPages; i--) { + CXFA_ContainerLayoutItem* pPage = m_PageArray[i]; + m_PageArray.RemoveAt(i); + pNotify->OnPageEvent(pPage, XFA_PAGEVIEWEVENT_PostRemoved); + delete pPage; + } + ClearRecordList(); +} + +void XFA_ReleaseLayoutItem_NoPageArea(CXFA_LayoutItem* pLayoutItem) { + CXFA_LayoutItem *pNext, *pNode = pLayoutItem->m_pFirstChild; + while (pNode) { + pNext = pNode->m_pNextSibling; + pNode->m_pParent = nullptr; + XFA_ReleaseLayoutItem_NoPageArea(pNode); + pNode = pNext; + } + if (pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::PageArea) + delete pLayoutItem; +} + +void CXFA_LayoutPageMgr::PrepareLayout() { + m_pPageSetCurRoot = nullptr; + m_ePageSetMode = XFA_ATTRIBUTEENUM_OrderedOccurrence; + m_nAvailPages = 0; + ClearRecordList(); + if (!m_pPageSetLayoutItemRoot) + return; + + CXFA_ContainerLayoutItem* pRootLayoutItem = m_pPageSetLayoutItemRoot; + if (pRootLayoutItem && + pRootLayoutItem->m_pFormNode->GetPacketID() == XFA_XDPPACKET_Form) { + CXFA_Node* pPageSetFormNode = pRootLayoutItem->m_pFormNode; + pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.RemoveAll(); + if (pPageSetFormNode->HasRemovedChildren()) { + XFA_ReleaseLayoutItem(pRootLayoutItem); + m_pPageSetLayoutItemRoot = nullptr; + pRootLayoutItem = nullptr; + pPageSetFormNode = nullptr; + m_PageArray.RemoveAll(); + } + while (pPageSetFormNode) { + CXFA_Node* pNextPageSet = + pPageSetFormNode->GetNextSameClassSibling(XFA_Element::PageSet); + pPageSetFormNode->GetNodeItem(XFA_NODEITEM_Parent) + ->RemoveChild(pPageSetFormNode, FALSE); + pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.Add( + pPageSetFormNode); + pPageSetFormNode = pNextPageSet; + } + } + pRootLayoutItem = m_pPageSetLayoutItemRoot; + CXFA_ContainerLayoutItem* pNextLayout = nullptr; + for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) { + pNextLayout = + static_cast(pRootLayoutItem->m_pNextSibling); + SaveLayoutItem(pRootLayoutItem); + delete pRootLayoutItem; + } + m_pPageSetLayoutItemRoot = nullptr; +} diff --git a/xfa/fxfa/parser/cxfa_layoutpagemgr.h b/xfa/fxfa/parser/cxfa_layoutpagemgr.h new file mode 100644 index 0000000000..0184602de7 --- /dev/null +++ b/xfa/fxfa/parser/cxfa_layoutpagemgr.h @@ -0,0 +1,144 @@ +// 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 XFA_FXFA_PARSER_CXFA_LAYOUTPAGEMGR_H_ +#define XFA_FXFA_PARSER_CXFA_LAYOUTPAGEMGR_H_ + +#include "xfa/fxfa/parser/xfa_layout_itemlayout.h" + +class CXFA_ContainerRecord; +class CXFA_LayoutItem; + +class CXFA_LayoutPageMgr { + public: + CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor); + ~CXFA_LayoutPageMgr(); + + FX_BOOL InitLayoutPage(CXFA_Node* pFormNode); + FX_BOOL PrepareFirstPage(CXFA_Node* pRootSubform); + FX_FLOAT GetAvailHeight(); + FX_BOOL GetNextAvailContentHeight(FX_FLOAT fChildHeight); + void SubmitContentItem(CXFA_ContentLayoutItem* pContentLayoutItem, + XFA_ItemLayoutProcessorResult eStatus); + void FinishPaginatedPageSets(); + void SyncLayoutData(); + int32_t GetPageCount() const; + CXFA_ContainerLayoutItem* GetPage(int32_t index) const; + int32_t GetPageIndex(const CXFA_ContainerLayoutItem* pPage) const; + inline CXFA_ContainerLayoutItem* GetRootLayoutItem() const { + return m_pPageSetLayoutItemRoot; + } + FX_BOOL ProcessBreakBeforeOrAfter(CXFA_Node* pBreakNode, + FX_BOOL bBefore, + CXFA_Node*& pBreakLeaderNode, + CXFA_Node*& pBreakTrailerNode, + FX_BOOL& bCreatePage); + FX_BOOL ProcessOverflow(CXFA_Node* pFormNode, + CXFA_Node*& pLeaderNode, + CXFA_Node*& pTrailerNode, + FX_BOOL bDataMerge = FALSE, + FX_BOOL bCreatePage = TRUE); + CXFA_Node* QueryOverflow(CXFA_Node* pFormNode, + CXFA_LayoutContext* pLayoutContext = nullptr); + FX_BOOL ProcessBookendLeaderOrTrailer(CXFA_Node* pBookendNode, + FX_BOOL bLeader, + CXFA_Node*& pBookendAppendNode); + CXFA_LayoutItem* FindOrCreateLayoutItem(CXFA_Node* pFormNode); + + protected: + FX_BOOL AppendNewPage(FX_BOOL bFirstTemPage = FALSE); + void ReorderPendingLayoutRecordToTail(CXFA_ContainerRecord* pNewRecord, + CXFA_ContainerRecord* pPrevRecord); + void RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord, + CXFA_ContainerRecord* pPrevRecord); + inline CXFA_ContainerRecord* GetCurrentContainerRecord() { + CXFA_ContainerRecord* result = + ((CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetAt( + m_pCurrentContainerRecord)); + ASSERT(result); + return result; + } + CXFA_ContainerRecord* CreateContainerRecord(CXFA_Node* pPageNode = nullptr, + FX_BOOL bCreateNew = FALSE); + void AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, + CXFA_Node* pNewPageArea); + void AddContentAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, + CXFA_Node* pContentArea); + FX_BOOL RunBreak(XFA_Element eBreakType, + XFA_ATTRIBUTEENUM eTargetType, + CXFA_Node* pTarget, + FX_BOOL bStartNew); + CXFA_Node* BreakOverflow(CXFA_Node* pOverflowNode, + CXFA_Node*& pLeaderTemplate, + CXFA_Node*& pTrailerTemplate, + FX_BOOL bCreatePage = TRUE); + FX_BOOL ResolveBookendLeaderOrTrailer(CXFA_Node* pBookendNode, + FX_BOOL bLeader, + CXFA_Node*& pBookendAppendTemplate); + FX_BOOL ExecuteBreakBeforeOrAfter(CXFA_Node* pCurNode, + FX_BOOL bBefore, + CXFA_Node*& pBreakLeaderTemplate, + CXFA_Node*& pBreakTrailerTemplate); + + int32_t CreateMinPageRecord(CXFA_Node* pPageArea, + FX_BOOL bTargetPageArea, + FX_BOOL bCreateLast = FALSE); + void CreateMinPageSetRecord(CXFA_Node* pPageSet, FX_BOOL bCreateAll = FALSE); + void CreateNextMinRecord(CXFA_Node* pRecordNode); + FX_BOOL FindPageAreaFromPageSet(CXFA_Node* pPageSet, + CXFA_Node* pStartChild, + CXFA_Node* pTargetPageArea = nullptr, + CXFA_Node* pTargetContentArea = nullptr, + FX_BOOL bNewPage = FALSE, + FX_BOOL bQuery = FALSE); + FX_BOOL FindPageAreaFromPageSet_Ordered( + CXFA_Node* pPageSet, + CXFA_Node* pStartChild, + CXFA_Node* pTargetPageArea = nullptr, + CXFA_Node* pTargetContentArea = nullptr, + FX_BOOL bNewPage = FALSE, + FX_BOOL bQuery = FALSE); + FX_BOOL FindPageAreaFromPageSet_SimplexDuplex( + CXFA_Node* pPageSet, + CXFA_Node* pStartChild, + CXFA_Node* pTargetPageArea = nullptr, + CXFA_Node* pTargetContentArea = nullptr, + FX_BOOL bNewPage = FALSE, + FX_BOOL bQuery = FALSE, + XFA_ATTRIBUTEENUM ePreferredPosition = XFA_ATTRIBUTEENUM_First); + FX_BOOL MatchPageAreaOddOrEven(CXFA_Node* pPageArea, FX_BOOL bLastMatch); + CXFA_Node* GetNextAvailPageArea(CXFA_Node* pTargetPageArea, + CXFA_Node* pTargetContentArea = nullptr, + FX_BOOL bNewPage = FALSE, + FX_BOOL bQuery = FALSE); + FX_BOOL GetNextContentArea(CXFA_Node* pTargetContentArea); + void InitPageSetMap(); + void ProcessLastPageSet(); + inline FX_BOOL IsPageSetRootOrderedOccurrence() { + return m_ePageSetMode == XFA_ATTRIBUTEENUM_OrderedOccurrence; + } + void ClearData(); + void ClearRecordList(); + void MergePageSetContents(); + void LayoutPageSetContents(); + void PrepareLayout(); + void SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem); + CXFA_LayoutProcessor* m_pLayoutProcessor; + CXFA_Node* m_pTemplatePageSetRoot; + CXFA_ContainerLayoutItem* m_pPageSetLayoutItemRoot; + CXFA_ContainerLayoutItem* m_pPageSetCurRoot; + FX_POSITION m_pCurrentContainerRecord; + CFX_PtrList m_rgProposedContainerRecord; + CXFA_Node* m_pCurPageArea; + int32_t m_nAvailPages; + int32_t m_nCurPageCount; + XFA_ATTRIBUTEENUM m_ePageSetMode; + FX_BOOL m_bCreateOverFlowPage; + CFX_MapPtrTemplate m_pPageSetMap; + CFX_ArrayTemplate m_PageArray; +}; + +#endif // XFA_FXFA_PARSER_CXFA_LAYOUTPAGEMGR_H_ diff --git a/xfa/fxfa/parser/cxfa_layoutprocessor.cpp b/xfa/fxfa/parser/cxfa_layoutprocessor.cpp index 875bcc6542..1f3bc880eb 100644 --- a/xfa/fxfa/parser/cxfa_layoutprocessor.cpp +++ b/xfa/fxfa/parser/cxfa_layoutprocessor.cpp @@ -8,10 +8,10 @@ #include "xfa/fxfa/parser/cxfa_contentlayoutitem.h" #include "xfa/fxfa/parser/cxfa_document.h" +#include "xfa/fxfa/parser/cxfa_layoutpagemgr.h" #include "xfa/fxfa/parser/cxfa_measurement.h" #include "xfa/fxfa/parser/xfa_document_datamerger_imp.h" #include "xfa/fxfa/parser/xfa_layout_itemlayout.h" -#include "xfa/fxfa/parser/xfa_layout_pagemgr_new.h" #include "xfa/fxfa/parser/xfa_localemgr.h" #include "xfa/fxfa/parser/xfa_object.h" #include "xfa/fxfa/parser/xfa_utils.h" diff --git a/xfa/fxfa/parser/xfa_layout_itemlayout.cpp b/xfa/fxfa/parser/xfa_layout_itemlayout.cpp index 72a3ff4f18..1f2e1ea089 100644 --- a/xfa/fxfa/parser/xfa_layout_itemlayout.cpp +++ b/xfa/fxfa/parser/xfa_layout_itemlayout.cpp @@ -13,9 +13,9 @@ #include "xfa/fxfa/parser/cxfa_containerlayoutitem.h" #include "xfa/fxfa/parser/cxfa_contentlayoutitem.h" #include "xfa/fxfa/parser/cxfa_document.h" +#include "xfa/fxfa/parser/cxfa_layoutpagemgr.h" #include "xfa/fxfa/parser/cxfa_measurement.h" #include "xfa/fxfa/parser/cxfa_occur.h" -#include "xfa/fxfa/parser/xfa_layout_pagemgr_new.h" #include "xfa/fxfa/parser/xfa_localemgr.h" #include "xfa/fxfa/parser/xfa_object.h" #include "xfa/fxfa/parser/xfa_utils.h" diff --git a/xfa/fxfa/parser/xfa_layout_pagemgr_new.cpp b/xfa/fxfa/parser/xfa_layout_pagemgr_new.cpp deleted file mode 100644 index a88ccce330..0000000000 --- a/xfa/fxfa/parser/xfa_layout_pagemgr_new.cpp +++ /dev/null @@ -1,1954 +0,0 @@ -// 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 "xfa/fxfa/parser/xfa_layout_pagemgr_new.h" - -#include "xfa/fxfa/app/xfa_ffnotify.h" -#include "xfa/fxfa/parser/cxfa_containerlayoutitem.h" -#include "xfa/fxfa/parser/cxfa_contentlayoutitem.h" -#include "xfa/fxfa/parser/cxfa_document.h" -#include "xfa/fxfa/parser/cxfa_layoutprocessor.h" -#include "xfa/fxfa/parser/cxfa_measurement.h" -#include "xfa/fxfa/parser/cxfa_scriptcontext.h" -#include "xfa/fxfa/parser/cxfa_traversestrategy_contentareacontainerlayoutitem.h" -#include "xfa/fxfa/parser/cxfa_traversestrategy_layoutitem.h" -#include "xfa/fxfa/parser/xfa_document_datamerger_imp.h" -#include "xfa/fxfa/parser/xfa_layout_itemlayout.h" -#include "xfa/fxfa/parser/xfa_localemgr.h" -#include "xfa/fxfa/parser/xfa_object.h" -#include "xfa/fxfa/parser/xfa_resolvenode_rs.h" -#include "xfa/fxfa/parser/xfa_utils.h" - -namespace { - -class PageSetContainerLayoutItem { - public: - static inline CXFA_ContainerLayoutItem* GetFirstChild( - CXFA_ContainerLayoutItem* pLayoutItem) { - if (pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) - return nullptr; - - CXFA_ContainerLayoutItem* pChildItem = - static_cast(pLayoutItem->m_pFirstChild); - while (pChildItem && - pChildItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) { - pChildItem = - static_cast(pChildItem->m_pNextSibling); - } - return pChildItem; - } - - static inline CXFA_ContainerLayoutItem* GetNextSibling( - CXFA_ContainerLayoutItem* pLayoutItem) { - CXFA_ContainerLayoutItem* pChildItem = - static_cast(pLayoutItem->m_pNextSibling); - while (pChildItem && - pChildItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) { - pChildItem = - static_cast(pChildItem->m_pNextSibling); - } - return pChildItem; - } - - static inline CXFA_ContainerLayoutItem* GetParent( - CXFA_ContainerLayoutItem* pLayoutItem) { - return static_cast(pLayoutItem->m_pParent); - } -}; - -uint32_t GetRelevant(CXFA_Node* pFormItem, uint32_t dwParentRelvant) { - uint32_t dwRelevant = XFA_WidgetStatus_Viewable | XFA_WidgetStatus_Printable; - CFX_WideStringC wsRelevant; - if (pFormItem->TryCData(XFA_ATTRIBUTE_Relevant, wsRelevant)) { - if (wsRelevant == FX_WSTRC(L"+print") || wsRelevant == FX_WSTRC(L"print")) - dwRelevant &= ~XFA_WidgetStatus_Viewable; - else if (wsRelevant == FX_WSTRC(L"-print")) - dwRelevant &= ~XFA_WidgetStatus_Printable; - } - if (!(dwParentRelvant & XFA_WidgetStatus_Viewable) && - (dwRelevant != XFA_WidgetStatus_Viewable)) { - dwRelevant &= ~XFA_WidgetStatus_Viewable; - } - if (!(dwParentRelvant & XFA_WidgetStatus_Printable) && - (dwRelevant != XFA_WidgetStatus_Printable)) { - dwRelevant &= ~XFA_WidgetStatus_Printable; - } - return dwRelevant; -} - -void SyncContainer(CXFA_FFNotify* pNotify, - CXFA_LayoutProcessor* pDocLayout, - CXFA_LayoutItem* pContainerItem, - uint32_t dwRelevant, - FX_BOOL bVisible, - int32_t nPageIndex) { - FX_BOOL bVisibleItem = FALSE; - uint32_t dwStatus = 0; - uint32_t dwRelevantContainer = 0; - if (bVisible) { - XFA_ATTRIBUTEENUM eAttributeValue = - pContainerItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence); - if (eAttributeValue == XFA_ATTRIBUTEENUM_Visible || - eAttributeValue == XFA_ATTRIBUTEENUM_Unknown) { - bVisibleItem = TRUE; - } - dwRelevantContainer = GetRelevant(pContainerItem->m_pFormNode, dwRelevant); - dwStatus = - (bVisibleItem ? XFA_WidgetStatus_Visible : 0) | dwRelevantContainer; - } - pNotify->OnLayoutItemAdded(pDocLayout, pContainerItem, nPageIndex, dwStatus); - for (CXFA_LayoutItem* pChild = pContainerItem->m_pFirstChild; pChild; - pChild = pChild->m_pNextSibling) { - if (pChild->IsContentLayoutItem()) { - SyncContainer(pNotify, pDocLayout, pChild, dwRelevantContainer, - bVisibleItem, nPageIndex); - } - } -} - -void ReorderLayoutItemToTail(CXFA_ContainerLayoutItem* pLayoutItem) { - CXFA_ContainerLayoutItem* pParentLayoutItem = - (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent; - if (!pParentLayoutItem) - return; - - pParentLayoutItem->RemoveChild(pLayoutItem); - pParentLayoutItem->AddChild(pLayoutItem); -} - -void RemoveLayoutItem(CXFA_ContainerLayoutItem* pLayoutItem) { - CXFA_ContainerLayoutItem* pParentLayoutItem = - (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent; - if (!pParentLayoutItem) - return; - - pParentLayoutItem->RemoveChild(pLayoutItem); -} - -CXFA_Node* ResolveBreakTarget(CXFA_Node* pPageSetRoot, - FX_BOOL bNewExprStyle, - CFX_WideStringC& wsTargetExpr) { - CXFA_Document* pDocument = pPageSetRoot->GetDocument(); - if (wsTargetExpr.IsEmpty()) - return nullptr; - - CFX_WideString wsTargetAll(wsTargetExpr); - wsTargetAll.TrimLeft(); - wsTargetAll.TrimRight(); - int32_t iSpliteIndex = 0; - FX_BOOL bTargetAllFind = TRUE; - while (iSpliteIndex != -1) { - CFX_WideString wsExpr; - int32_t iSpliteNextIndex = 0; - if (!bTargetAllFind) { - iSpliteNextIndex = wsTargetAll.Find(' ', iSpliteIndex); - wsExpr = wsTargetAll.Mid(iSpliteIndex, iSpliteNextIndex - iSpliteIndex); - } else { - wsExpr = wsTargetAll; - } - if (wsExpr.IsEmpty()) - return nullptr; - - bTargetAllFind = FALSE; - if (wsExpr.GetAt(0) == '#') { - CXFA_Node* pNode = pDocument->GetNodeByID( - ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Template)), - wsExpr.Mid(1).AsStringC()); - if (pNode) - return pNode; - } else if (bNewExprStyle) { - CFX_WideString wsProcessedTarget = wsExpr; - if (wsExpr.Left(4) == FX_WSTRC(L"som(") && - wsExpr.Right(1) == FX_WSTRC(L")")) { - wsProcessedTarget = wsExpr.Mid(4, wsExpr.GetLength() - 5); - } - XFA_RESOLVENODE_RS rs; - int32_t iCount = pDocument->GetScriptContext()->ResolveObjects( - pPageSetRoot, wsProcessedTarget.AsStringC(), rs, - XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties | - XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Siblings | - XFA_RESOLVENODE_Parent); - if (iCount > 0 && rs.nodes[0]->IsNode()) - return rs.nodes[0]->AsNode(); - } - iSpliteIndex = iSpliteNextIndex; - } - return nullptr; -} - -void SetLayoutGeneratedNodeFlag(CXFA_Node* pNode) { - pNode->SetFlag(XFA_NodeFlag_LayoutGeneratedNode, false); - pNode->ClearFlag(XFA_NodeFlag_UnusedNode); -} - -FX_BOOL CheckContentAreaNotUsed( - CXFA_ContainerLayoutItem* pPageAreaLayoutItem, - CXFA_Node* pContentArea, - CXFA_ContainerLayoutItem*& pContentAreaLayoutItem) { - for (CXFA_ContainerLayoutItem* pLayoutItem = - (CXFA_ContainerLayoutItem*)pPageAreaLayoutItem->m_pFirstChild; - pLayoutItem; - pLayoutItem = (CXFA_ContainerLayoutItem*)pLayoutItem->m_pNextSibling) { - if (pLayoutItem->m_pFormNode == pContentArea) { - if (!pLayoutItem->m_pFirstChild) { - pContentAreaLayoutItem = pLayoutItem; - return TRUE; - } - return FALSE; - } - } - return TRUE; -} - -void SyncRemoveLayoutItem(CXFA_LayoutItem* pParentLayoutItem, - CXFA_FFNotify* pNotify, - CXFA_LayoutProcessor* pDocLayout) { - CXFA_LayoutItem* pNextLayoutItem; - CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild; - while (pCurLayoutItem) { - pNextLayoutItem = pCurLayoutItem->m_pNextSibling; - if (pCurLayoutItem->m_pFirstChild) - SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout); - - pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem); - delete pCurLayoutItem; - pCurLayoutItem = pNextLayoutItem; - } -} - -} // namespace - -CXFA_LayoutPageMgr::CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor) - : m_pLayoutProcessor(pLayoutProcessor), - m_pTemplatePageSetRoot(nullptr), - m_pPageSetLayoutItemRoot(nullptr), - m_pPageSetCurRoot(nullptr), - m_pCurrentContainerRecord(nullptr), - m_pCurPageArea(nullptr), - m_nAvailPages(0), - m_nCurPageCount(0), - m_ePageSetMode(XFA_ATTRIBUTEENUM_OrderedOccurrence), - m_bCreateOverFlowPage(FALSE) {} -CXFA_LayoutPageMgr::~CXFA_LayoutPageMgr() { - ClearData(); - CXFA_LayoutItem* pLayoutItem = GetRootLayoutItem(); - CXFA_LayoutItem* pNextLayout = nullptr; - for (; pLayoutItem; pLayoutItem = pNextLayout) { - pNextLayout = pLayoutItem->m_pNextSibling; - XFA_ReleaseLayoutItem(pLayoutItem); - } -} -FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) { - PrepareLayout(); - CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode(); - if (!pTemplateNode) { - return FALSE; - } - m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_Element::PageSet); - ASSERT(m_pTemplatePageSetRoot); - if (m_pPageSetLayoutItemRoot) { - m_pPageSetLayoutItemRoot->m_pParent = nullptr; - m_pPageSetLayoutItemRoot->m_pFirstChild = nullptr; - m_pPageSetLayoutItemRoot->m_pNextSibling = nullptr; - m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot; - } else { - m_pPageSetLayoutItemRoot = - new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot); - } - m_pPageSetCurRoot = m_pPageSetLayoutItemRoot; - m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY, - (void*)m_pPageSetLayoutItemRoot); - XFA_ATTRIBUTEENUM eRelation = - m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation); - if (eRelation != XFA_ATTRIBUTEENUM_Unknown) { - m_ePageSetMode = eRelation; - } - InitPageSetMap(); - CXFA_Node* pPageArea = nullptr; - int32_t iCount = 0; - for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild); - pPageArea; - pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pPageArea->GetElementType() == XFA_Element::PageArea) { - iCount++; - if (pPageArea->GetFirstChildByClass(XFA_Element::ContentArea)) { - return TRUE; - } - } - } - if (iCount > 0) { - return FALSE; - } - CXFA_Document* pDocument = pTemplateNode->GetDocument(); - pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_Element::PageArea); - if (!pPageArea) { - pPageArea = pDocument->CreateNode(m_pTemplatePageSetRoot->GetPacketID(), - XFA_Element::PageArea); - if (!pPageArea) { - return FALSE; - } - m_pTemplatePageSetRoot->InsertChild(pPageArea, nullptr); - pPageArea->SetFlag(XFA_NodeFlag_Initialized, true); - } - CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_Element::ContentArea); - if (!pContentArea) { - pContentArea = pDocument->CreateNode(pPageArea->GetPacketID(), - XFA_Element::ContentArea); - if (!pContentArea) { - return FALSE; - } - pPageArea->InsertChild(pContentArea, nullptr); - pContentArea->SetFlag(XFA_NodeFlag_Initialized, true); - pContentArea->SetMeasure(XFA_ATTRIBUTE_X, - CXFA_Measurement(0.25f, XFA_UNIT_In)); - pContentArea->SetMeasure(XFA_ATTRIBUTE_Y, - CXFA_Measurement(0.25f, XFA_UNIT_In)); - pContentArea->SetMeasure(XFA_ATTRIBUTE_W, - CXFA_Measurement(8.0f, XFA_UNIT_In)); - pContentArea->SetMeasure(XFA_ATTRIBUTE_H, - CXFA_Measurement(10.5f, XFA_UNIT_In)); - } - CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_Element::Medium); - if (!pMedium) { - pMedium = - pDocument->CreateNode(pPageArea->GetPacketID(), XFA_Element::Medium); - if (!pContentArea) { - return FALSE; - } - pPageArea->InsertChild(pMedium, nullptr); - pMedium->SetFlag(XFA_NodeFlag_Initialized, true); - pMedium->SetMeasure(XFA_ATTRIBUTE_Short, - CXFA_Measurement(8.5f, XFA_UNIT_In)); - pMedium->SetMeasure(XFA_ATTRIBUTE_Long, - CXFA_Measurement(11.0f, XFA_UNIT_In)); - } - return TRUE; -} -FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) { - FX_BOOL bProBreakBefore = FALSE; - CXFA_Node* pBreakBeforeNode = nullptr; - while (pRootSubform) { - for (CXFA_Node* pBreakNode = - pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild); - pBreakNode; - pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - XFA_Element eType = pBreakNode->GetElementType(); - if (eType == XFA_Element::BreakBefore || - (eType == XFA_Element::Break && - pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) != - XFA_ATTRIBUTEENUM_Auto)) { - bProBreakBefore = TRUE; - pBreakBeforeNode = pBreakNode; - break; - } - } - if (bProBreakBefore) { - break; - } - bProBreakBefore = TRUE; - pRootSubform = pRootSubform->GetFirstChildByClass(XFA_Element::Subform); - while (pRootSubform && - !XFA_ItemLayoutProcessor_IsTakingSpace(pRootSubform)) { - pRootSubform = - pRootSubform->GetNextSameClassSibling(XFA_Element::Subform); - } - } - CXFA_Node *pLeader, *pTrailer; - if (pBreakBeforeNode && - ExecuteBreakBeforeOrAfter(pBreakBeforeNode, TRUE, pLeader, pTrailer)) { - m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition(); - return TRUE; - } - return AppendNewPage(TRUE); -} -FX_BOOL CXFA_LayoutPageMgr::AppendNewPage(FX_BOOL bFirstTemPage) { - if (m_pCurrentContainerRecord != - m_rgProposedContainerRecord.GetTailPosition()) { - return TRUE; - } - CXFA_Node* pPageNode = GetNextAvailPageArea(nullptr); - if (!pPageNode) { - return FALSE; - } - if (bFirstTemPage && !m_pCurrentContainerRecord) { - m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition(); - } - return !bFirstTemPage || m_pCurrentContainerRecord; -} - -void CXFA_LayoutPageMgr::RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord, - CXFA_ContainerRecord* pPrevRecord) { - if (!pNewRecord || !pPrevRecord) { - return; - } - if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) { - RemoveLayoutItem(pNewRecord->pCurPageSet); - return; - } - if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) { - RemoveLayoutItem(pNewRecord->pCurPageArea); - return; - } - if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) { - RemoveLayoutItem(pNewRecord->pCurContentArea); - return; - } -} -void CXFA_LayoutPageMgr::ReorderPendingLayoutRecordToTail( - CXFA_ContainerRecord* pNewRecord, - CXFA_ContainerRecord* pPrevRecord) { - if (!pNewRecord || !pPrevRecord) { - return; - } - if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) { - ReorderLayoutItemToTail(pNewRecord->pCurPageSet); - return; - } - if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) { - ReorderLayoutItemToTail(pNewRecord->pCurPageArea); - return; - } - if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) { - ReorderLayoutItemToTail(pNewRecord->pCurContentArea); - return; - } -} -void CXFA_LayoutPageMgr::SubmitContentItem( - CXFA_ContentLayoutItem* pContentLayoutItem, - XFA_ItemLayoutProcessorResult eStatus) { - if (pContentLayoutItem) { - GetCurrentContainerRecord()->pCurContentArea->AddChild(pContentLayoutItem); - m_bCreateOverFlowPage = FALSE; - } - if (eStatus != XFA_ItemLayoutProcessorResult_Done) { - if (eStatus == XFA_ItemLayoutProcessorResult_PageFullBreak && - m_pCurrentContainerRecord == - m_rgProposedContainerRecord.GetTailPosition()) { - AppendNewPage(); - } - m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetTailPosition(); - m_pCurPageArea = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode; - } -} -FX_FLOAT CXFA_LayoutPageMgr::GetAvailHeight() { - CXFA_ContainerLayoutItem* pLayoutItem = - GetCurrentContainerRecord()->pCurContentArea; - if (!pLayoutItem || !pLayoutItem->m_pFormNode) - return 0.0f; - FX_FLOAT fAvailHeight = - pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); - if (fAvailHeight >= XFA_LAYOUT_FLOAT_PERCISION) - return fAvailHeight; - if (m_pCurrentContainerRecord == - m_rgProposedContainerRecord.GetHeadPosition()) { - return 0.0f; - } - return XFA_LAYOUT_FLOAT_MAX; -} - -FX_BOOL XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) { - CFX_WideString wsExpression; - pTestScript->TryContent(wsExpression); - if (wsExpression.IsEmpty()) { - return TRUE; - } - return pTestScript->GetDocument()->GetNotify()->RunScript( - pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent, - XFA_ObjectType::ContainerNode)); -} -CXFA_ContainerRecord* CXFA_LayoutPageMgr::CreateContainerRecord( - CXFA_Node* pPageNode, - FX_BOOL bCreateNew) { - CXFA_ContainerRecord* pNewRecord = new CXFA_ContainerRecord(); - if (m_pCurrentContainerRecord) { - if (!IsPageSetRootOrderedOccurrence() || !pPageNode) { - *pNewRecord = *GetCurrentContainerRecord(); - m_rgProposedContainerRecord.AddTail(pNewRecord); - return pNewRecord; - } - CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent); - if (!bCreateNew) { - if (pPageSet == m_pTemplatePageSetRoot) { - pNewRecord->pCurPageSet = m_pPageSetCurRoot; - } else { - CXFA_ContainerLayoutItem* pParentLayoutItem = - (CXFA_ContainerLayoutItem*)pPageSet->GetUserData(XFA_LAYOUTITEMKEY); - if (!pParentLayoutItem) { - pParentLayoutItem = m_pPageSetCurRoot; - } - pNewRecord->pCurPageSet = pParentLayoutItem; - } - } else { - CXFA_ContainerLayoutItem* pParentPageSetLayout = nullptr; - if (pPageSet == GetCurrentContainerRecord()->pCurPageSet->m_pFormNode) { - pParentPageSetLayout = - (CXFA_ContainerLayoutItem*)GetCurrentContainerRecord() - ->pCurPageSet->m_pParent; - } else { - pParentPageSetLayout = - (CXFA_ContainerLayoutItem*)pPageSet->GetNodeItem( - XFA_NODEITEM_Parent) - ->GetUserData(XFA_LAYOUTITEMKEY); - } - CXFA_ContainerLayoutItem* pPageSetLayoutItem = - new CXFA_ContainerLayoutItem(pPageSet); - pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem); - if (!pParentPageSetLayout) { - CXFA_ContainerLayoutItem* pPrePageSet = m_pPageSetLayoutItemRoot; - while (pPrePageSet->m_pNextSibling) { - pPrePageSet = (CXFA_ContainerLayoutItem*)pPrePageSet->m_pNextSibling; - } - pPrePageSet->m_pNextSibling = pPageSetLayoutItem; - m_pPageSetCurRoot = pPageSetLayoutItem; - } else { - pParentPageSetLayout->AddChild(pPageSetLayoutItem); - } - pNewRecord->pCurPageSet = pPageSetLayoutItem; - } - } else { - if (pPageNode) { - CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pPageSet == m_pTemplatePageSetRoot) { - pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot; - } else { - CXFA_ContainerLayoutItem* pPageSetLayoutItem = - new CXFA_ContainerLayoutItem(pPageSet); - pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem); - m_pPageSetLayoutItemRoot->AddChild(pPageSetLayoutItem); - pNewRecord->pCurPageSet = pPageSetLayoutItem; - } - } else { - pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot; - } - } - m_rgProposedContainerRecord.AddTail(pNewRecord); - return pNewRecord; -} -void CXFA_LayoutPageMgr::AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, - CXFA_Node* pNewPageArea) { - CXFA_ContainerLayoutItem* pNewPageAreaLayoutItem = nullptr; - if (m_PageArray.GetSize() > m_nAvailPages) { - CXFA_ContainerLayoutItem* pContainerItem = m_PageArray[m_nAvailPages]; - pContainerItem->m_pFormNode = pNewPageArea; - m_nAvailPages++; - pNewPageAreaLayoutItem = pContainerItem; - } else { - CXFA_FFNotify* pNotify = pNewPageArea->GetDocument()->GetNotify(); - CXFA_ContainerLayoutItem* pContainerItem = - (CXFA_ContainerLayoutItem*)pNotify->OnCreateLayoutItem(pNewPageArea); - m_PageArray.Add(pContainerItem); - m_nAvailPages++; - pNotify->OnPageEvent(pContainerItem, XFA_PAGEVIEWEVENT_PostRemoved); - pNewPageAreaLayoutItem = pContainerItem; - } - pNewRecord->pCurPageSet->AddChild(pNewPageAreaLayoutItem); - pNewRecord->pCurPageArea = pNewPageAreaLayoutItem; - pNewRecord->pCurContentArea = nullptr; -} -void CXFA_LayoutPageMgr::AddContentAreaLayoutItem( - CXFA_ContainerRecord* pNewRecord, - CXFA_Node* pContentArea) { - if (!pContentArea) { - pNewRecord->pCurContentArea = nullptr; - return; - } - CXFA_ContainerLayoutItem* pNewContentAreaLayoutItem = - new CXFA_ContainerLayoutItem(pContentArea); - ASSERT(pNewRecord->pCurPageArea); - pNewRecord->pCurPageArea->AddChild(pNewContentAreaLayoutItem); - pNewRecord->pCurContentArea = pNewContentAreaLayoutItem; -} - -void CXFA_LayoutPageMgr::FinishPaginatedPageSets() { - CXFA_ContainerLayoutItem* pRootPageSetLayoutItem = m_pPageSetLayoutItemRoot; - for (; pRootPageSetLayoutItem; - pRootPageSetLayoutItem = - (CXFA_ContainerLayoutItem*)pRootPageSetLayoutItem->m_pNextSibling) { - CXFA_NodeIteratorTemplate - sIterator(pRootPageSetLayoutItem); - for (CXFA_ContainerLayoutItem* pPageSetLayoutItem = sIterator.GetCurrent(); - pPageSetLayoutItem; pPageSetLayoutItem = sIterator.MoveToNext()) { - XFA_ATTRIBUTEENUM ePageRelation = - pPageSetLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Relation); - switch (ePageRelation) { - case XFA_ATTRIBUTEENUM_OrderedOccurrence: - default: { ProcessLastPageSet(); } break; - case XFA_ATTRIBUTEENUM_SimplexPaginated: - case XFA_ATTRIBUTEENUM_DuplexPaginated: { - CXFA_LayoutItem* pLastPageAreaLayoutItem = nullptr; - int32_t nPageAreaCount = 0; - for (CXFA_LayoutItem* pPageAreaLayoutItem = - pPageSetLayoutItem->m_pFirstChild; - pPageAreaLayoutItem; - pPageAreaLayoutItem = pPageAreaLayoutItem->m_pNextSibling) { - if (pPageAreaLayoutItem->m_pFormNode->GetElementType() != - XFA_Element::PageArea) { - continue; - } - nPageAreaCount++; - pLastPageAreaLayoutItem = pPageAreaLayoutItem; - } - if (!pLastPageAreaLayoutItem) { - break; - } - if (!FindPageAreaFromPageSet_SimplexDuplex( - pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr, - TRUE, TRUE, nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only - : XFA_ATTRIBUTEENUM_Last) && - (nPageAreaCount == 1 && - !FindPageAreaFromPageSet_SimplexDuplex( - pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr, - TRUE, TRUE, XFA_ATTRIBUTEENUM_Last))) { - break; - } - CXFA_Node* pNode = m_pCurPageArea; - XFA_ATTRIBUTEENUM eCurChoice = - pNode->GetEnum(XFA_ATTRIBUTE_PagePosition); - if (eCurChoice == XFA_ATTRIBUTEENUM_Last) { - XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any; - pNode->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven); - XFA_ATTRIBUTEENUM eLastChoice = - pLastPageAreaLayoutItem->m_pFormNode->GetEnum( - XFA_ATTRIBUTE_PagePosition); - if (eLastChoice == XFA_ATTRIBUTEENUM_First && - (ePageRelation == XFA_ATTRIBUTEENUM_SimplexPaginated || - eOddOrEven != XFA_ATTRIBUTEENUM_Odd)) { - CXFA_ContainerRecord* pRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pRecord, pNode); - break; - } - } - FX_BOOL bUsable = TRUE; - CFX_ArrayTemplate rgUsedHeights; - for (CXFA_LayoutItem* pChildLayoutItem = - pLastPageAreaLayoutItem->m_pFirstChild; - pChildLayoutItem; - pChildLayoutItem = pChildLayoutItem->m_pNextSibling) { - if (pChildLayoutItem->m_pFormNode->GetElementType() != - XFA_Element::ContentArea) { - continue; - } - FX_FLOAT fUsedHeight = 0; - for (CXFA_LayoutItem* pContentChildLayoutItem = - pChildLayoutItem->m_pFirstChild; - pContentChildLayoutItem; - pContentChildLayoutItem = - pContentChildLayoutItem->m_pNextSibling) { - if (CXFA_ContentLayoutItem* pContent = - pContentChildLayoutItem->AsContentLayoutItem()) { - fUsedHeight += pContent->m_sSize.y; - } - } - rgUsedHeights.Add(fUsedHeight); - } - int32_t iCurContentAreaIndex = -1; - for (CXFA_Node* pContentAreaNode = - pNode->GetNodeItem(XFA_NODEITEM_FirstChild); - pContentAreaNode; - pContentAreaNode = - pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pContentAreaNode->GetElementType() != - XFA_Element::ContentArea) { - continue; - } - iCurContentAreaIndex++; - if (rgUsedHeights[iCurContentAreaIndex] > - pContentAreaNode->GetMeasure(XFA_ATTRIBUTE_H) - .ToUnit(XFA_UNIT_Pt) + - XFA_LAYOUT_FLOAT_PERCISION) { - bUsable = FALSE; - break; - } - } - if (bUsable) { - CXFA_LayoutItem* pChildLayoutItem = - pLastPageAreaLayoutItem->m_pFirstChild; - CXFA_Node* pContentAreaNode = - pNode->GetNodeItem(XFA_NODEITEM_FirstChild); - pLastPageAreaLayoutItem->m_pFormNode = pNode; - while (pChildLayoutItem && pContentAreaNode) { - if (pChildLayoutItem->m_pFormNode->GetElementType() != - XFA_Element::ContentArea) { - pChildLayoutItem = pChildLayoutItem->m_pNextSibling; - continue; - } - if (pContentAreaNode->GetElementType() != - XFA_Element::ContentArea) { - pContentAreaNode = - pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling); - continue; - } - pChildLayoutItem->m_pFormNode = pContentAreaNode; - pChildLayoutItem = pChildLayoutItem->m_pNextSibling; - pContentAreaNode = - pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling); - } - } else if (pNode->GetEnum(XFA_ATTRIBUTE_PagePosition) == - XFA_ATTRIBUTEENUM_Last) { - CXFA_ContainerRecord* pRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pRecord, pNode); - } - } break; - } - } - } -} -int32_t CXFA_LayoutPageMgr::GetPageCount() const { - return m_PageArray.GetSize(); -} -CXFA_ContainerLayoutItem* CXFA_LayoutPageMgr::GetPage(int32_t index) const { - if (index < 0 || index >= m_PageArray.GetSize()) - return nullptr; - return m_PageArray[index]; -} -int32_t CXFA_LayoutPageMgr::GetPageIndex( - const CXFA_ContainerLayoutItem* pPage) const { - // FIXME: Find() method should take const. - return m_PageArray.Find(const_cast(pPage)); -} -FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_Element eBreakType, - XFA_ATTRIBUTEENUM eTargetType, - CXFA_Node* pTarget, - FX_BOOL bStartNew) { - FX_BOOL bRet = FALSE; - switch (eTargetType) { - case XFA_ATTRIBUTEENUM_ContentArea: - if (pTarget && pTarget->GetElementType() != XFA_Element::ContentArea) { - pTarget = nullptr; - } - if (!pTarget || !m_pCurrentContainerRecord || - pTarget != - GetCurrentContainerRecord()->pCurContentArea->m_pFormNode || - bStartNew) { - CXFA_Node* pPageArea = nullptr; - if (pTarget) { - pPageArea = pTarget->GetNodeItem(XFA_NODEITEM_Parent); - } - pPageArea = GetNextAvailPageArea(pPageArea, pTarget); - bRet = !!pPageArea; - } - break; - case XFA_ATTRIBUTEENUM_PageArea: - if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) { - pTarget = nullptr; - } - if (!pTarget || !m_pCurrentContainerRecord || - pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode || - bStartNew) { - CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, nullptr, TRUE); - bRet = !!pPageArea; - } - break; - case XFA_ATTRIBUTEENUM_PageOdd: - if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) { - pTarget = nullptr; - } - break; - case XFA_ATTRIBUTEENUM_PageEven: - if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) { - pTarget = nullptr; - } - break; - case XFA_ATTRIBUTEENUM_Auto: - default: - break; - } - return bRet; -} -FX_BOOL CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter( - CXFA_Node* pCurNode, - FX_BOOL bBefore, - CXFA_Node*& pBreakLeaderTemplate, - CXFA_Node*& pBreakTrailerTemplate) { - XFA_Element eType = pCurNode->GetElementType(); - switch (eType) { - case XFA_Element::BreakBefore: - case XFA_Element::BreakAfter: { - CFX_WideStringC wsBreakLeader, wsBreakTrailer; - CXFA_Node* pFormNode = pCurNode->GetNodeItem( - XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); - CXFA_Node* pContainer = pFormNode->GetTemplateNode(); - FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0; - CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_Element::Script); - if (pScript && !XFA_LayoutPageMgr_RunBreakTestScript(pScript)) { - return FALSE; - } - CFX_WideStringC wsTarget = pCurNode->GetCData(XFA_ATTRIBUTE_Target); - CXFA_Node* pTarget = - ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget); - wsBreakTrailer = pCurNode->GetCData(XFA_ATTRIBUTE_Trailer); - wsBreakLeader = pCurNode->GetCData(XFA_ATTRIBUTE_Leader); - pBreakLeaderTemplate = - ResolveBreakTarget(pContainer, TRUE, wsBreakLeader); - pBreakTrailerTemplate = - ResolveBreakTarget(pContainer, TRUE, wsBreakTrailer); - if (RunBreak(eType, pCurNode->GetEnum(XFA_ATTRIBUTE_TargetType), pTarget, - bStartNew)) { - return TRUE; - } else { - if (m_rgProposedContainerRecord.GetCount() > 0 && - m_pCurrentContainerRecord == - m_rgProposedContainerRecord.GetHeadPosition() && - eType == XFA_Element::BreakBefore) { - CXFA_Node* pParentNode = pFormNode->GetNodeItem( - XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); - if (!pParentNode || - pFormNode != - pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild, - XFA_ObjectType::ContainerNode)) { - break; - } - pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent); - if (!pParentNode || - pParentNode->GetElementType() != XFA_Element::Form) { - break; - } - return TRUE; - } - } - } break; - case XFA_Element::Break: { - FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0; - CFX_WideStringC wsTarget = pCurNode->GetCData( - bBefore ? XFA_ATTRIBUTE_BeforeTarget : XFA_ATTRIBUTE_AfterTarget); - CXFA_Node* pTarget = - ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget); - if (RunBreak(bBefore ? XFA_Element::BreakBefore : XFA_Element::BreakAfter, - pCurNode->GetEnum(bBefore ? XFA_ATTRIBUTE_Before - : XFA_ATTRIBUTE_After), - pTarget, bStartNew)) { - return TRUE; - } - } break; - default: - break; - } - return FALSE; -} - -FX_BOOL CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter( - CXFA_Node* pBreakNode, - FX_BOOL bBefore, - CXFA_Node*& pBreakLeaderNode, - CXFA_Node*& pBreakTrailerNode, - FX_BOOL& bCreatePage) { - CXFA_Node* pLeaderTemplate = nullptr; - CXFA_Node* pTrailerTemplate = nullptr; - CXFA_Node* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent, - XFA_ObjectType::ContainerNode); - if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) { - bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore, - pLeaderTemplate, pTrailerTemplate); - CXFA_Document* pDocument = pBreakNode->GetDocument(); - CXFA_Node* pDataScope = nullptr; - pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent, - XFA_ObjectType::ContainerNode); - if (pLeaderTemplate) { - if (!pDataScope) { - pDataScope = XFA_DataMerge_FindDataScope(pFormNode); - } - pBreakLeaderNode = pDocument->DataMerge_CopyContainer( - pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); - pDocument->DataMerge_UpdateBindingRelations(pBreakLeaderNode); - SetLayoutGeneratedNodeFlag(pBreakLeaderNode); - } - if (pTrailerTemplate) { - if (!pDataScope) { - pDataScope = XFA_DataMerge_FindDataScope(pFormNode); - } - pBreakTrailerNode = pDocument->DataMerge_CopyContainer( - pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); - pDocument->DataMerge_UpdateBindingRelations(pBreakTrailerNode); - SetLayoutGeneratedNodeFlag(pBreakTrailerNode); - } - return TRUE; - } - return FALSE; -} -FX_BOOL CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer( - CXFA_Node* pBookendNode, - FX_BOOL bLeader, - CXFA_Node*& pBookendAppendNode) { - CXFA_Node* pLeaderTemplate = nullptr; - CXFA_Node* pFormNode = pBookendNode->GetNodeItem( - XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); - if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) { - CXFA_Document* pDocument = pBookendNode->GetDocument(); - CXFA_Node* pDataScope = nullptr; - if (pLeaderTemplate) { - if (!pDataScope) { - pDataScope = XFA_DataMerge_FindDataScope(pFormNode); - } - pBookendAppendNode = pDocument->DataMerge_CopyContainer( - pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); - pDocument->DataMerge_UpdateBindingRelations(pBookendAppendNode); - SetLayoutGeneratedNodeFlag(pBookendAppendNode); - return TRUE; - } - } - return FALSE; -} -CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode, - CXFA_Node*& pLeaderTemplate, - CXFA_Node*& pTrailerTemplate, - FX_BOOL bCreatePage) { - CXFA_Node* pContainer = - pOverflowNode - ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode) - ->GetTemplateNode(); - if (pOverflowNode->GetElementType() == XFA_Element::Break) { - CFX_WideStringC wsOverflowLeader; - CFX_WideStringC wsOverflowTarget; - CFX_WideStringC wsOverflowTrailer; - pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader); - pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer); - pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget); - if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() || - !wsOverflowTarget.IsEmpty()) { - if (!wsOverflowTarget.IsEmpty() && bCreatePage && - !m_bCreateOverFlowPage) { - CXFA_Node* pTarget = - ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget); - if (pTarget) { - m_bCreateOverFlowPage = TRUE; - switch (pTarget->GetElementType()) { - case XFA_Element::PageArea: - RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, - pTarget, TRUE); - break; - case XFA_Element::ContentArea: - RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea, - pTarget, TRUE); - break; - default: - break; - } - } - } - if (!bCreatePage) { - pLeaderTemplate = - ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader); - pTrailerTemplate = - ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer); - } - return pOverflowNode; - } - return nullptr; - } - - if (pOverflowNode->GetElementType() != XFA_Element::Overflow) - return nullptr; - - CFX_WideStringC wsOverflowLeader; - CFX_WideStringC wsOverflowTrailer; - CFX_WideStringC wsOverflowTarget; - pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader); - pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer); - pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget); - if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) { - CXFA_Node* pTarget = - ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget); - if (pTarget) { - m_bCreateOverFlowPage = TRUE; - switch (pTarget->GetElementType()) { - case XFA_Element::PageArea: - RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget, - TRUE); - break; - case XFA_Element::ContentArea: - RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea, - pTarget, TRUE); - break; - default: - break; - } - } - } - if (!bCreatePage) { - pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader); - pTrailerTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer); - } - return pOverflowNode; -} - -FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode, - CXFA_Node*& pLeaderNode, - CXFA_Node*& pTrailerNode, - FX_BOOL bDataMerge, - FX_BOOL bCreatePage) { - if (!pFormNode) { - return FALSE; - } - CXFA_Node* pLeaderTemplate = nullptr; - CXFA_Node* pTrailerTemplate = nullptr; - FX_BOOL bIsOverflowNode = FALSE; - if (pFormNode->GetElementType() == XFA_Element::Overflow || - pFormNode->GetElementType() == XFA_Element::Break) { - bIsOverflowNode = TRUE; - } - for (CXFA_Node* pCurNode = - bIsOverflowNode ? pFormNode - : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); - pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) { - if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate, - bCreatePage)) { - if (bIsOverflowNode) { - pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent); - } - CXFA_Document* pDocument = pCurNode->GetDocument(); - CXFA_Node* pDataScope = nullptr; - if (pLeaderTemplate) { - if (!pDataScope) { - pDataScope = XFA_DataMerge_FindDataScope(pFormNode); - } - pLeaderNode = pDocument->DataMerge_CopyContainer( - pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); - pDocument->DataMerge_UpdateBindingRelations(pLeaderNode); - SetLayoutGeneratedNodeFlag(pLeaderNode); - } - if (pTrailerTemplate) { - if (!pDataScope) { - pDataScope = XFA_DataMerge_FindDataScope(pFormNode); - } - pTrailerNode = pDocument->DataMerge_CopyContainer( - pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); - pDocument->DataMerge_UpdateBindingRelations(pTrailerNode); - SetLayoutGeneratedNodeFlag(pTrailerNode); - } - return TRUE; - } - if (bIsOverflowNode) { - break; - } - } - return FALSE; -} -FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer( - CXFA_Node* pBookendNode, - FX_BOOL bLeader, - CXFA_Node*& pBookendAppendTemplate) { - CFX_WideStringC wsBookendLeader; - CXFA_Node* pContainer = - pBookendNode - ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode) - ->GetTemplateNode(); - if (pBookendNode->GetElementType() == XFA_Element::Break) { - pBookendNode->TryCData( - bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer, - wsBookendLeader); - if (!wsBookendLeader.IsEmpty()) { - pBookendAppendTemplate = - ResolveBreakTarget(pContainer, FALSE, wsBookendLeader); - return TRUE; - } - return FALSE; - } else if (pBookendNode->GetElementType() == XFA_Element::Bookend) { - pBookendNode->TryCData( - bLeader ? XFA_ATTRIBUTE_Leader : XFA_ATTRIBUTE_Trailer, - wsBookendLeader); - pBookendAppendTemplate = - ResolveBreakTarget(pContainer, TRUE, wsBookendLeader); - return TRUE; - } - return FALSE; -} -FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet( - CXFA_Node* pPageSet, - CXFA_Node* pStartChild, - CXFA_Node* pTargetPageArea, - CXFA_Node* pTargetContentArea, - FX_BOOL bNewPage, - FX_BOOL bQuery) { - if (!pPageSet && !pStartChild) { - return FALSE; - } - if (IsPageSetRootOrderedOccurrence()) { - return FindPageAreaFromPageSet_Ordered(pPageSet, pStartChild, - pTargetPageArea, pTargetContentArea, - bNewPage, bQuery); - } - XFA_ATTRIBUTEENUM ePreferredPosition = m_pCurrentContainerRecord - ? XFA_ATTRIBUTEENUM_Rest - : XFA_ATTRIBUTEENUM_First; - return FindPageAreaFromPageSet_SimplexDuplex( - pPageSet, pStartChild, pTargetPageArea, pTargetContentArea, bNewPage, - bQuery, ePreferredPosition); -} -FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_Ordered( - CXFA_Node* pPageSet, - CXFA_Node* pStartChild, - CXFA_Node* pTargetPageArea, - CXFA_Node* pTargetContentArea, - FX_BOOL bNewPage, - FX_BOOL bQuery) { - int32_t iPageSetCount = 0; - if (!pStartChild && !bQuery) { - m_pPageSetMap.Lookup(pPageSet, iPageSetCount); - int32_t iMax = -1; - CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur); - if (pOccurNode) { - pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE); - } - if (iMax >= 0 && iMax <= iPageSetCount) { - return FALSE; - } - } - FX_BOOL bRes = FALSE; - CXFA_Node* pCurrentNode = - pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling) - : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); - for (; pCurrentNode; - pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { - if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) { - if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) { - if (pTargetPageArea == pCurrentNode) { - CreateMinPageRecord(pCurrentNode, TRUE); - pTargetPageArea = nullptr; - } - continue; - } - if (!bQuery) { - CXFA_ContainerRecord* pNewRecord = - CreateContainerRecord(pCurrentNode, !pStartChild); - AddPageAreaLayoutItem(pNewRecord, pCurrentNode); - if (!pTargetContentArea) { - pTargetContentArea = - pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea); - } - AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); - } - m_pCurPageArea = pCurrentNode; - m_nCurPageCount = 1; - bRes = TRUE; - break; - } - if (!bQuery) { - CreateMinPageRecord(pCurrentNode, FALSE); - } - } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { - if (FindPageAreaFromPageSet_Ordered(pCurrentNode, nullptr, - pTargetPageArea, pTargetContentArea, - bNewPage, bQuery)) { - bRes = TRUE; - break; - } - if (!bQuery) { - CreateMinPageSetRecord(pCurrentNode, TRUE); - } - } - } - if (!pStartChild && bRes && !bQuery) { - m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount); - } - return bRes; -} -FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex( - CXFA_Node* pPageSet, - CXFA_Node* pStartChild, - CXFA_Node* pTargetPageArea, - CXFA_Node* pTargetContentArea, - FX_BOOL bNewPage, - FX_BOOL bQuery, - XFA_ATTRIBUTEENUM ePreferredPosition) { - const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any; - CXFA_Node* pPreferredPageArea = nullptr; - CXFA_Node* pFallbackPageArea = nullptr; - CXFA_Node* pCurrentNode = nullptr; - if (!pStartChild || pStartChild->GetElementType() == XFA_Element::PageArea) { - pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); - } else { - pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling); - } - for (; pCurrentNode; - pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { - if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE)) { - continue; - } - XFA_ATTRIBUTEENUM eCurPagePosition = - pCurrentNode->GetEnum(XFA_ATTRIBUTE_PagePosition); - if (ePreferredPosition == XFA_ATTRIBUTEENUM_Last) { - if (eCurPagePosition != ePreferredPosition) { - continue; - } - if (m_ePageSetMode == XFA_ATTRIBUTEENUM_SimplexPaginated || - pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) == - XFA_ATTRIBUTEENUM_Any) { - pPreferredPageArea = pCurrentNode; - break; - } - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pNewRecord, pCurrentNode); - AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass( - XFA_Element::ContentArea)); - pPreferredPageArea = pCurrentNode; - return FALSE; - } else if (ePreferredPosition == XFA_ATTRIBUTEENUM_Only) { - if (eCurPagePosition != ePreferredPosition) { - continue; - } - if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated || - pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) == - XFA_ATTRIBUTEENUM_Any) { - pPreferredPageArea = pCurrentNode; - break; - } - return FALSE; - } - if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) { - if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) { - if (pTargetPageArea == pCurrentNode) { - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pNewRecord, pCurrentNode); - pTargetPageArea = nullptr; - } - continue; - } - if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest && - eCurPagePosition == XFA_ATTRIBUTEENUM_Any) || - eCurPagePosition == ePreferredPosition) { - pPreferredPageArea = pCurrentNode; - break; - } else if (eCurPagePosition == eFallbackPosition && - !pFallbackPageArea) { - pFallbackPageArea = pCurrentNode; - } - } else if (pTargetPageArea && - !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) { - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pNewRecord, pCurrentNode); - AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass( - XFA_Element::ContentArea)); - } - } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { - if (FindPageAreaFromPageSet_SimplexDuplex( - pCurrentNode, nullptr, pTargetPageArea, pTargetContentArea, - bNewPage, bQuery, ePreferredPosition)) { - break; - } - } - } - CXFA_Node* pCurPageArea = nullptr; - if (pPreferredPageArea) { - pCurPageArea = pPreferredPageArea; - } else if (pFallbackPageArea) { - pCurPageArea = pFallbackPageArea; - } - if (!pCurPageArea) { - return FALSE; - } - if (!bQuery) { - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pNewRecord, pCurPageArea); - if (!pTargetContentArea) { - pTargetContentArea = - pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea); - } - AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); - } - m_pCurPageArea = pCurPageArea; - return TRUE; -} -FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea, - FX_BOOL bLastMatch) { - if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated) { - return TRUE; - } - XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any; - pPageArea->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven); - if (eOddOrEven != XFA_ATTRIBUTEENUM_Any) { - int32_t iPageCount = GetPageCount(); - if (bLastMatch) { - return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 1 - : iPageCount % 2 == 0; - } - return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 0 - : iPageCount % 2 == 1; - } - return TRUE; -} -CXFA_Node* CXFA_LayoutPageMgr::GetNextAvailPageArea( - CXFA_Node* pTargetPageArea, - CXFA_Node* pTargetContentArea, - FX_BOOL bNewPage, - FX_BOOL bQuery) { - if (!m_pCurPageArea) { - FindPageAreaFromPageSet(m_pTemplatePageSetRoot, nullptr, pTargetPageArea, - pTargetContentArea, bNewPage, bQuery); - ASSERT(m_pCurPageArea); - return m_pCurPageArea; - } - if (!pTargetPageArea || pTargetPageArea == m_pCurPageArea) { - if (!bNewPage && GetNextContentArea(pTargetContentArea)) { - return m_pCurPageArea; - } - if (IsPageSetRootOrderedOccurrence()) { - int32_t iMax = -1; - CXFA_Node* pOccurNode = - m_pCurPageArea->GetFirstChildByClass(XFA_Element::Occur); - if (pOccurNode) { - pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE); - } - if ((iMax < 0 || m_nCurPageCount < iMax)) { - if (!bQuery) { - CXFA_ContainerRecord* pNewRecord = - CreateContainerRecord(m_pCurPageArea); - AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea); - if (!pTargetContentArea) { - pTargetContentArea = - m_pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea); - } - AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); - } - m_nCurPageCount++; - return m_pCurPageArea; - } - } - } - if (!bQuery && IsPageSetRootOrderedOccurrence()) { - CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE); - } - if (FindPageAreaFromPageSet(m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent), - m_pCurPageArea, pTargetPageArea, - pTargetContentArea, bNewPage, bQuery)) { - return m_pCurPageArea; - } - CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent); - while (TRUE) { - if (FindPageAreaFromPageSet(pPageSet, nullptr, pTargetPageArea, - pTargetContentArea, bNewPage, bQuery)) { - return m_pCurPageArea; - } - if (!bQuery && IsPageSetRootOrderedOccurrence()) { - CreateMinPageSetRecord(pPageSet); - } - if (FindPageAreaFromPageSet(nullptr, pPageSet, pTargetPageArea, - pTargetContentArea, bNewPage, bQuery)) { - return m_pCurPageArea; - } - if (pPageSet == m_pTemplatePageSetRoot) { - break; - } - pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent); - } - return nullptr; -} - -FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) { - CXFA_Node* pCurContentNode = - GetCurrentContainerRecord()->pCurContentArea->m_pFormNode; - if (!pContentArea) { - pContentArea = - pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea); - if (!pContentArea) { - return FALSE; - } - } else { - if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea) { - return FALSE; - } - CXFA_ContainerLayoutItem* pContentAreaLayout = nullptr; - if (!CheckContentAreaNotUsed(GetCurrentContainerRecord()->pCurPageArea, - pContentArea, pContentAreaLayout)) { - return FALSE; - } - if (pContentAreaLayout) { - if (pContentAreaLayout->m_pFormNode != pCurContentNode) { - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - pNewRecord->pCurContentArea = pContentAreaLayout; - return TRUE; - } else { - return FALSE; - } - } - } - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - AddContentAreaLayoutItem(pNewRecord, pContentArea); - return TRUE; -} -void CXFA_LayoutPageMgr::InitPageSetMap() { - if (!IsPageSetRootOrderedOccurrence()) { - return; - } - CXFA_NodeIterator sIterator(m_pTemplatePageSetRoot); - for (CXFA_Node* pPageSetNode = sIterator.GetCurrent(); pPageSetNode; - pPageSetNode = sIterator.MoveToNext()) { - if (pPageSetNode->GetElementType() == XFA_Element::PageSet) { - XFA_ATTRIBUTEENUM eRelation = - pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation); - if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence) { - m_pPageSetMap.SetAt(pPageSetNode, 0); - } - } - } -} -int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea, - FX_BOOL bTargetPageArea, - FX_BOOL bCreateLast) { - if (!pPageArea) { - return 0; - } - CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_Element::Occur); - int32_t iMin = 0; - if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) || - bTargetPageArea) { - CXFA_Node* pContentArea = - pPageArea->GetFirstChildByClass(XFA_Element::ContentArea); - if (iMin < 1 && bTargetPageArea && !pContentArea) { - iMin = 1; - } - int32_t i = 0; - if (bCreateLast) { - i = m_nCurPageCount; - } - for (; i < iMin; i++) { - CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); - AddPageAreaLayoutItem(pNewRecord, pPageArea); - AddContentAreaLayoutItem(pNewRecord, pContentArea); - } - } - return iMin; -} -void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet, - FX_BOOL bCreateAll) { - if (!pPageSet) { - return; - } - int32_t iCurSetCount = 0; - if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount)) { - return; - } - if (bCreateAll) { - iCurSetCount = 0; - } - CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur); - int32_t iMin = 0; - if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) { - if (iCurSetCount < iMin) { - for (int32_t i = 0; i < iMin - iCurSetCount; i++) { - for (CXFA_Node* pCurrentPageNode = - pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); - pCurrentPageNode; pCurrentPageNode = pCurrentPageNode->GetNodeItem( - XFA_NODEITEM_NextSibling)) { - if (pCurrentPageNode->GetElementType() == XFA_Element::PageArea) { - CreateMinPageRecord(pCurrentPageNode, FALSE); - } else if (pCurrentPageNode->GetElementType() == - XFA_Element::PageSet) { - CreateMinPageSetRecord(pCurrentPageNode, TRUE); - } - } - } - m_pPageSetMap.SetAt(pPageSet, iMin); - } - } -} -void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) { - if (!pRecordNode) { - return; - } - for (CXFA_Node* pCurrentNode = - pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling); - pCurrentNode; - pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { - CreateMinPageRecord(pCurrentNode, FALSE); - } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { - CreateMinPageSetRecord(pCurrentNode, TRUE); - } - } -} -void CXFA_LayoutPageMgr::ProcessLastPageSet() { - CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE); - CreateNextMinRecord(m_pCurPageArea); - CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent); - while (TRUE) { - CreateMinPageSetRecord(pPageSet); - if (pPageSet == m_pTemplatePageSetRoot) { - break; - } - CreateNextMinRecord(pPageSet); - pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent); - } -} -FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) { - CXFA_Node* pCurContentNode = - GetCurrentContainerRecord()->pCurContentArea->m_pFormNode; - if (!pCurContentNode) { - return FALSE; - } - pCurContentNode = - pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea); - if (pCurContentNode) { - FX_FLOAT fNextContentHeight = - pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); - return fNextContentHeight > fChildHeight; - } - CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode; - CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_Element::Occur); - int32_t iMax = 0; - if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) { - if (m_nCurPageCount == iMax) { - CXFA_Node* pSrcPage = m_pCurPageArea; - int32_t nSrcPageCount = m_nCurPageCount; - FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition(); - CXFA_Node* pNextPage = - GetNextAvailPageArea(nullptr, nullptr, FALSE, TRUE); - m_pCurPageArea = pSrcPage; - m_nCurPageCount = nSrcPageCount; - CXFA_ContainerRecord* pPrevRecord = - (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext( - psSrcRecord); - while (psSrcRecord) { - FX_POSITION psSaveRecord = psSrcRecord; - CXFA_ContainerRecord* pInsertRecord = - (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext( - psSrcRecord); - RemoveLayoutRecord(pInsertRecord, pPrevRecord); - delete pInsertRecord; - m_rgProposedContainerRecord.RemoveAt(psSaveRecord); - } - if (pNextPage) { - CXFA_Node* pContentArea = - pNextPage->GetFirstChildByClass(XFA_Element::ContentArea); - if (pContentArea) { - FX_FLOAT fNextContentHeight = - pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); - if (fNextContentHeight > fChildHeight) { - return TRUE; - } - } - } - return FALSE; - } - } - CXFA_Node* pContentArea = - pPageNode->GetFirstChildByClass(XFA_Element::ContentArea); - FX_FLOAT fNextContentHeight = - pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); - if (fNextContentHeight < XFA_LAYOUT_FLOAT_PERCISION) { - return TRUE; - } - if (fNextContentHeight > fChildHeight) { - return TRUE; - } - return FALSE; -} -void CXFA_LayoutPageMgr::ClearData() { - ClearRecordList(); -} -void CXFA_LayoutPageMgr::ClearRecordList() { - if (!m_pTemplatePageSetRoot) { - return; - } - if (m_rgProposedContainerRecord.GetCount() > 0) { - FX_POSITION sPos; - sPos = m_rgProposedContainerRecord.GetHeadPosition(); - while (sPos) { - CXFA_ContainerRecord* pRecord = - (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(sPos); - delete pRecord; - } - m_rgProposedContainerRecord.RemoveAll(); - } - m_pCurrentContainerRecord = nullptr; - m_pCurPageArea = nullptr; - m_nCurPageCount = 0; - m_bCreateOverFlowPage = FALSE; - m_pPageSetMap.RemoveAll(); -} -CXFA_LayoutItem* CXFA_LayoutPageMgr::FindOrCreateLayoutItem( - CXFA_Node* pFormNode) { - return pFormNode->GetDocument()->GetNotify()->OnCreateLayoutItem(pFormNode); -} - -void CXFA_LayoutPageMgr::SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem) { - CXFA_LayoutItem* pNextLayoutItem; - CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild; - while (pCurLayoutItem) { - pNextLayoutItem = pCurLayoutItem->m_pNextSibling; - if (pCurLayoutItem->IsContentLayoutItem()) { - if (pCurLayoutItem->m_pFormNode->HasRemovedChildren()) { - CXFA_FFNotify* pNotify = - m_pTemplatePageSetRoot->GetDocument()->GetNotify(); - CXFA_LayoutProcessor* pDocLayout = - m_pTemplatePageSetRoot->GetDocument()->GetDocLayout(); - if (pCurLayoutItem->m_pFirstChild) { - SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout); - } - pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem); - delete pCurLayoutItem; - pCurLayoutItem = pNextLayoutItem; - continue; - } - if (pCurLayoutItem->m_pFormNode->IsLayoutGeneratedNode()) { - CXFA_NodeIteratorTemplate - sIterator(pCurLayoutItem->m_pFormNode); - for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode; - pNode = sIterator.MoveToNext()) { - pNode->SetFlag(XFA_NodeFlag_UnusedNode, false); - } - } - } - if (pCurLayoutItem->m_pFirstChild) { - SaveLayoutItem(pCurLayoutItem); - } - pCurLayoutItem->m_pParent = nullptr; - pCurLayoutItem->m_pNextSibling = nullptr; - pCurLayoutItem->m_pFirstChild = nullptr; - if (!pCurLayoutItem->IsContentLayoutItem() && - pCurLayoutItem->m_pFormNode->GetElementType() != - XFA_Element::PageArea) { - delete pCurLayoutItem; - } - pCurLayoutItem = pNextLayoutItem; - } -} -CXFA_Node* CXFA_LayoutPageMgr::QueryOverflow( - CXFA_Node* pFormNode, - CXFA_LayoutContext* pLayoutContext) { - for (CXFA_Node* pCurNode = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); - pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) { - if (pCurNode->GetElementType() == XFA_Element::Break) { - CFX_WideStringC wsOverflowLeader; - CFX_WideStringC wsOverflowTarget; - CFX_WideStringC wsOverflowTrailer; - pCurNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader); - pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer); - pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget); - if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() || - !wsOverflowTarget.IsEmpty()) { - return pCurNode; - } - return nullptr; - } else if (pCurNode->GetElementType() == XFA_Element::Overflow) { - return pCurNode; - } - } - return nullptr; -} - -void CXFA_LayoutPageMgr::MergePageSetContents() { - CXFA_Document* pDocument = m_pTemplatePageSetRoot->GetDocument(); - CXFA_FFNotify* pNotify = pDocument->GetNotify(); - CXFA_LayoutProcessor* pDocLayout = pDocument->GetDocLayout(); - CXFA_ContainerLayoutItem* pRootLayout = GetRootLayoutItem(); - { - for (int32_t iIndex = 0; iIndex < pDocument->m_pPendingPageSet.GetSize(); - iIndex++) { - CXFA_NodeIteratorTemplate - sIterator(pDocument->m_pPendingPageSet.GetAt(iIndex)); - for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode; - pNode = sIterator.MoveToNext()) { - if (pNode->IsContainerNode()) { - CXFA_Node* pBindNode = pNode->GetBindData(); - if (pBindNode) { - pBindNode->RemoveBindItem(pNode); - pNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); - } - } - pNode->SetFlag(XFA_NodeFlag_UnusedNode, true); - } - } - } - int32_t iIndex = 0; - for (; pRootLayout; - pRootLayout = (CXFA_ContainerLayoutItem*)pRootLayout->m_pNextSibling) { - CXFA_Node* pPendingPageSet = nullptr; - CXFA_NodeIteratorTemplate< - CXFA_ContainerLayoutItem, - CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> - iterator(pRootLayout); - CXFA_ContainerLayoutItem* pRootPageSetContainerItem = iterator.GetCurrent(); - ASSERT(pRootPageSetContainerItem->m_pFormNode->GetElementType() == - XFA_Element::PageSet); - if (iIndex < pDocument->m_pPendingPageSet.GetSize()) { - pPendingPageSet = pDocument->m_pPendingPageSet.GetAt(iIndex); - iIndex++; - } - if (!pPendingPageSet) { - if (pRootPageSetContainerItem->m_pFormNode->GetPacketID() == - XFA_XDPPACKET_Template) { - pPendingPageSet = - pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE); - } else { - pPendingPageSet = pRootPageSetContainerItem->m_pFormNode; - } - } - if (pRootPageSetContainerItem->m_pFormNode->GetUserData( - XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) { - pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY, - nullptr); - } - pRootPageSetContainerItem->m_pFormNode = pPendingPageSet; - pPendingPageSet->ClearFlag(XFA_NodeFlag_UnusedNode); - for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext(); - pContainerItem; pContainerItem = iterator.MoveToNext()) { - CXFA_Node* pNode = pContainerItem->m_pFormNode; - if (pNode->GetPacketID() != XFA_XDPPACKET_Template) { - continue; - } - switch (pNode->GetElementType()) { - case XFA_Element::PageSet: { - CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; - pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer( - pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE, - nullptr); - } break; - case XFA_Element::PageArea: { - CXFA_ContainerLayoutItem* pFormLayout = pContainerItem; - CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; - FX_BOOL bIsExistForm = TRUE; - for (int32_t iLevel = 0; iLevel < 3; iLevel++) { - pFormLayout = (CXFA_ContainerLayoutItem*)pFormLayout->m_pFirstChild; - if (iLevel == 2) { - while (pFormLayout && - !XFA_ItemLayoutProcessor_IsTakingSpace( - pFormLayout->m_pFormNode)) { - pFormLayout = - (CXFA_ContainerLayoutItem*)pFormLayout->m_pNextSibling; - } - } - if (!pFormLayout) { - bIsExistForm = FALSE; - break; - } - } - if (bIsExistForm) { - CXFA_Node* pNewSubform = pFormLayout->m_pFormNode; - if (pContainerItem->m_pOldSubform && - pContainerItem->m_pOldSubform != pNewSubform) { - CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance( - pDocument, pContainerItem->m_pFormNode->GetElementType(), - pContainerItem->m_pFormNode->GetNameHash(), pParentNode); - CXFA_ContainerIterator sIterator(pExistingNode); - for (CXFA_Node* pIter = sIterator.GetCurrent(); pIter; - pIter = sIterator.MoveToNext()) { - if (pIter->GetElementType() != XFA_Element::ContentArea) { - CXFA_LayoutItem* pLayoutItem = static_cast( - pIter->GetUserData(XFA_LAYOUTITEMKEY)); - if (pLayoutItem) { - pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); - delete pLayoutItem; - } - } - } - if (pExistingNode) { - pParentNode->RemoveChild(pExistingNode); - } - } - pContainerItem->m_pOldSubform = pNewSubform; - } - pContainerItem->m_pFormNode = pDocument->DataMerge_CopyContainer( - pContainerItem->m_pFormNode, pParentNode, - ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)), TRUE, TRUE, - TRUE); - } break; - case XFA_Element::ContentArea: { - CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; - for (CXFA_Node* pChildNode = - pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild); - pChildNode; - pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pChildNode->GetTemplateNode() != pContainerItem->m_pFormNode) { - continue; - } - pContainerItem->m_pFormNode = pChildNode; - break; - } - } break; - default: - break; - } - } - if (!pPendingPageSet->GetNodeItem(XFA_NODEITEM_Parent)) { - CXFA_Node* pFormToplevelSubform = - pDocument->GetXFAObject(XFA_HASHCODE_Form) - ->AsNode() - ->GetFirstChildByClass(XFA_Element::Subform); - pFormToplevelSubform->InsertChild(pPendingPageSet); - } - pDocument->DataMerge_UpdateBindingRelations(pPendingPageSet); - pPendingPageSet->SetFlag(XFA_NodeFlag_Initialized, true); - } - CXFA_Node* pPageSet = GetRootLayoutItem()->m_pFormNode; - while (pPageSet) { - CXFA_Node* pNextPageSet = - pPageSet->GetNextSameClassSibling(XFA_Element::PageSet); - CXFA_NodeIteratorTemplate - sIterator(pPageSet); - CXFA_Node* pNode = sIterator.GetCurrent(); - while (pNode) { - if (pNode->IsUnusedNode()) { - if (pNode->IsContainerNode()) { - XFA_Element eType = pNode->GetElementType(); - if (eType == XFA_Element::PageArea || eType == XFA_Element::PageSet) { - CXFA_ContainerIterator iteChild(pNode); - CXFA_Node* pChildNode = iteChild.MoveToNext(); - for (; pChildNode; pChildNode = iteChild.MoveToNext()) { - CXFA_LayoutItem* pLayoutItem = static_cast( - pChildNode->GetUserData(XFA_LAYOUTITEMKEY)); - if (pLayoutItem) { - pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); - delete pLayoutItem; - } - } - } else if (eType != XFA_Element::ContentArea) { - CXFA_LayoutItem* pLayoutItem = static_cast( - pNode->GetUserData(XFA_LAYOUTITEMKEY)); - if (pLayoutItem) { - pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); - delete pLayoutItem; - } - } - CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext(); - pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode); - pNode = pNext; - } else { - pNode->ClearFlag(XFA_NodeFlag_UnusedNode); - pNode->SetFlag(XFA_NodeFlag_Initialized, true); - pNode = sIterator.MoveToNext(); - } - } else { - pNode->SetFlag(XFA_NodeFlag_Initialized, true); - pNode = sIterator.MoveToNext(); - } - } - pPageSet = pNextPageSet; - } -} - -void CXFA_LayoutPageMgr::LayoutPageSetContents() { - CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem(); - for (; pRootLayoutItem; - pRootLayoutItem = - (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) { - CXFA_NodeIteratorTemplate< - CXFA_ContainerLayoutItem, - CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> - iterator(pRootLayoutItem); - for (CXFA_ContainerLayoutItem* pContainerItem = iterator.GetCurrent(); - pContainerItem; pContainerItem = iterator.MoveToNext()) { - CXFA_Node* pNode = pContainerItem->m_pFormNode; - switch (pNode->GetElementType()) { - case XFA_Element::PageArea: - m_pLayoutProcessor->GetRootRootItemLayoutProcessor() - ->DoLayoutPageArea(pContainerItem); - break; - default: - break; - } - } - } -} - -void CXFA_LayoutPageMgr::SyncLayoutData() { - MergePageSetContents(); - LayoutPageSetContents(); - CXFA_FFNotify* pNotify = m_pTemplatePageSetRoot->GetDocument()->GetNotify(); - int32_t nPageIdx = -1; - CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem(); - for (; pRootLayoutItem; - pRootLayoutItem = - (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) { - CXFA_NodeIteratorTemplate< - CXFA_ContainerLayoutItem, - CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> - iteratorParent(pRootLayoutItem); - for (CXFA_ContainerLayoutItem* pContainerItem = iteratorParent.GetCurrent(); - pContainerItem; pContainerItem = iteratorParent.MoveToNext()) { - switch (pContainerItem->m_pFormNode->GetElementType()) { - case XFA_Element::PageArea: { - nPageIdx++; - uint32_t dwRelevant = - XFA_WidgetStatus_Viewable | XFA_WidgetStatus_Printable; - CXFA_NodeIteratorTemplate - iterator(pContainerItem); - CXFA_LayoutItem* pChildLayoutItem = iterator.GetCurrent(); - while (pChildLayoutItem) { - CXFA_ContentLayoutItem* pContentItem = - pChildLayoutItem->AsContentLayoutItem(); - if (!pContentItem) { - pChildLayoutItem = iterator.MoveToNext(); - continue; - } - FX_BOOL bVisible = - (pContentItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence) == - XFA_ATTRIBUTEENUM_Visible); - uint32_t dwRelevantChild = - GetRelevant(pContentItem->m_pFormNode, dwRelevant); - SyncContainer(pNotify, m_pLayoutProcessor, pContentItem, - dwRelevantChild, bVisible, nPageIdx); - pChildLayoutItem = iterator.SkipChildrenAndMoveToNext(); - } - } break; - default: - break; - } - } - } - int32_t nPage = m_PageArray.GetSize(); - for (int32_t i = nPage - 1; i >= m_nAvailPages; i--) { - CXFA_ContainerLayoutItem* pPage = m_PageArray[i]; - m_PageArray.RemoveAt(i); - pNotify->OnPageEvent(pPage, XFA_PAGEVIEWEVENT_PostRemoved); - delete pPage; - } - ClearRecordList(); -} -void XFA_ReleaseLayoutItem_NoPageArea(CXFA_LayoutItem* pLayoutItem) { - CXFA_LayoutItem *pNext, *pNode = pLayoutItem->m_pFirstChild; - while (pNode) { - pNext = pNode->m_pNextSibling; - pNode->m_pParent = nullptr; - XFA_ReleaseLayoutItem_NoPageArea(pNode); - pNode = pNext; - } - if (pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::PageArea) { - delete pLayoutItem; - } -} -void CXFA_LayoutPageMgr::PrepareLayout() { - m_pPageSetCurRoot = nullptr; - m_ePageSetMode = XFA_ATTRIBUTEENUM_OrderedOccurrence; - m_nAvailPages = 0; - ClearRecordList(); - if (!m_pPageSetLayoutItemRoot) { - return; - } - CXFA_ContainerLayoutItem* pRootLayoutItem = m_pPageSetLayoutItemRoot; - if (pRootLayoutItem && - pRootLayoutItem->m_pFormNode->GetPacketID() == XFA_XDPPACKET_Form) { - CXFA_Node* pPageSetFormNode = pRootLayoutItem->m_pFormNode; - pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.RemoveAll(); - if (pPageSetFormNode->HasRemovedChildren()) { - XFA_ReleaseLayoutItem(pRootLayoutItem); - m_pPageSetLayoutItemRoot = nullptr; - pRootLayoutItem = nullptr; - pPageSetFormNode = nullptr; - m_PageArray.RemoveAll(); - } - while (pPageSetFormNode) { - CXFA_Node* pNextPageSet = - pPageSetFormNode->GetNextSameClassSibling(XFA_Element::PageSet); - pPageSetFormNode->GetNodeItem(XFA_NODEITEM_Parent) - ->RemoveChild(pPageSetFormNode, FALSE); - pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.Add( - pPageSetFormNode); - pPageSetFormNode = pNextPageSet; - } - } - pRootLayoutItem = m_pPageSetLayoutItemRoot; - CXFA_ContainerLayoutItem* pNextLayout = nullptr; - for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) { - pNextLayout = (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling; - SaveLayoutItem(pRootLayoutItem); - delete pRootLayoutItem; - } - m_pPageSetLayoutItemRoot = nullptr; -} diff --git a/xfa/fxfa/parser/xfa_layout_pagemgr_new.h b/xfa/fxfa/parser/xfa_layout_pagemgr_new.h deleted file mode 100644 index f4cc175dcb..0000000000 --- a/xfa/fxfa/parser/xfa_layout_pagemgr_new.h +++ /dev/null @@ -1,156 +0,0 @@ -// 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 XFA_FXFA_PARSER_XFA_LAYOUT_PAGEMGR_NEW_H_ -#define XFA_FXFA_PARSER_XFA_LAYOUT_PAGEMGR_NEW_H_ - -#include "xfa/fxfa/parser/xfa_layout_itemlayout.h" - -class CXFA_LayoutItem; - -class CXFA_ContainerRecord { - public: - CXFA_ContainerRecord(CXFA_ContainerLayoutItem* pPageSet = nullptr, - CXFA_ContainerLayoutItem* pPageArea = nullptr, - CXFA_ContainerLayoutItem* pContentArea = nullptr) - : pCurPageSet(pPageSet), - pCurPageArea(pPageArea), - pCurContentArea(pContentArea) {} - CXFA_ContainerLayoutItem* pCurPageSet; - CXFA_ContainerLayoutItem* pCurPageArea; - CXFA_ContainerLayoutItem* pCurContentArea; -}; - -class CXFA_LayoutPageMgr { - public: - CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor); - ~CXFA_LayoutPageMgr(); - - FX_BOOL InitLayoutPage(CXFA_Node* pFormNode); - FX_BOOL PrepareFirstPage(CXFA_Node* pRootSubform); - FX_FLOAT GetAvailHeight(); - FX_BOOL GetNextAvailContentHeight(FX_FLOAT fChildHeight); - void SubmitContentItem(CXFA_ContentLayoutItem* pContentLayoutItem, - XFA_ItemLayoutProcessorResult eStatus); - void FinishPaginatedPageSets(); - void SyncLayoutData(); - int32_t GetPageCount() const; - CXFA_ContainerLayoutItem* GetPage(int32_t index) const; - int32_t GetPageIndex(const CXFA_ContainerLayoutItem* pPage) const; - inline CXFA_ContainerLayoutItem* GetRootLayoutItem() const { - return m_pPageSetLayoutItemRoot; - } - FX_BOOL ProcessBreakBeforeOrAfter(CXFA_Node* pBreakNode, - FX_BOOL bBefore, - CXFA_Node*& pBreakLeaderNode, - CXFA_Node*& pBreakTrailerNode, - FX_BOOL& bCreatePage); - FX_BOOL ProcessOverflow(CXFA_Node* pFormNode, - CXFA_Node*& pLeaderNode, - CXFA_Node*& pTrailerNode, - FX_BOOL bDataMerge = FALSE, - FX_BOOL bCreatePage = TRUE); - CXFA_Node* QueryOverflow(CXFA_Node* pFormNode, - CXFA_LayoutContext* pLayoutContext = nullptr); - FX_BOOL ProcessBookendLeaderOrTrailer(CXFA_Node* pBookendNode, - FX_BOOL bLeader, - CXFA_Node*& pBookendAppendNode); - CXFA_LayoutItem* FindOrCreateLayoutItem(CXFA_Node* pFormNode); - - protected: - FX_BOOL AppendNewPage(FX_BOOL bFirstTemPage = FALSE); - void ReorderPendingLayoutRecordToTail(CXFA_ContainerRecord* pNewRecord, - CXFA_ContainerRecord* pPrevRecord); - void RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord, - CXFA_ContainerRecord* pPrevRecord); - inline CXFA_ContainerRecord* GetCurrentContainerRecord() { - CXFA_ContainerRecord* result = - ((CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetAt( - m_pCurrentContainerRecord)); - ASSERT(result); - return result; - } - CXFA_ContainerRecord* CreateContainerRecord(CXFA_Node* pPageNode = nullptr, - FX_BOOL bCreateNew = FALSE); - void AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, - CXFA_Node* pNewPageArea); - void AddContentAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, - CXFA_Node* pContentArea); - FX_BOOL RunBreak(XFA_Element eBreakType, - XFA_ATTRIBUTEENUM eTargetType, - CXFA_Node* pTarget, - FX_BOOL bStartNew); - CXFA_Node* BreakOverflow(CXFA_Node* pOverflowNode, - CXFA_Node*& pLeaderTemplate, - CXFA_Node*& pTrailerTemplate, - FX_BOOL bCreatePage = TRUE); - FX_BOOL ResolveBookendLeaderOrTrailer(CXFA_Node* pBookendNode, - FX_BOOL bLeader, - CXFA_Node*& pBookendAppendTemplate); - FX_BOOL ExecuteBreakBeforeOrAfter(CXFA_Node* pCurNode, - FX_BOOL bBefore, - CXFA_Node*& pBreakLeaderTemplate, - CXFA_Node*& pBreakTrailerTemplate); - - int32_t CreateMinPageRecord(CXFA_Node* pPageArea, - FX_BOOL bTargetPageArea, - FX_BOOL bCreateLast = FALSE); - void CreateMinPageSetRecord(CXFA_Node* pPageSet, FX_BOOL bCreateAll = FALSE); - void CreateNextMinRecord(CXFA_Node* pRecordNode); - FX_BOOL FindPageAreaFromPageSet(CXFA_Node* pPageSet, - CXFA_Node* pStartChild, - CXFA_Node* pTargetPageArea = nullptr, - CXFA_Node* pTargetContentArea = nullptr, - FX_BOOL bNewPage = FALSE, - FX_BOOL bQuery = FALSE); - FX_BOOL FindPageAreaFromPageSet_Ordered( - CXFA_Node* pPageSet, - CXFA_Node* pStartChild, - CXFA_Node* pTargetPageArea = nullptr, - CXFA_Node* pTargetContentArea = nullptr, - FX_BOOL bNewPage = FALSE, - FX_BOOL bQuery = FALSE); - FX_BOOL FindPageAreaFromPageSet_SimplexDuplex( - CXFA_Node* pPageSet, - CXFA_Node* pStartChild, - CXFA_Node* pTargetPageArea = nullptr, - CXFA_Node* pTargetContentArea = nullptr, - FX_BOOL bNewPage = FALSE, - FX_BOOL bQuery = FALSE, - XFA_ATTRIBUTEENUM ePreferredPosition = XFA_ATTRIBUTEENUM_First); - FX_BOOL MatchPageAreaOddOrEven(CXFA_Node* pPageArea, FX_BOOL bLastMatch); - CXFA_Node* GetNextAvailPageArea(CXFA_Node* pTargetPageArea, - CXFA_Node* pTargetContentArea = nullptr, - FX_BOOL bNewPage = FALSE, - FX_BOOL bQuery = FALSE); - FX_BOOL GetNextContentArea(CXFA_Node* pTargetContentArea); - void InitPageSetMap(); - void ProcessLastPageSet(); - inline FX_BOOL IsPageSetRootOrderedOccurrence() { - return m_ePageSetMode == XFA_ATTRIBUTEENUM_OrderedOccurrence; - } - void ClearData(); - void ClearRecordList(); - void MergePageSetContents(); - void LayoutPageSetContents(); - void PrepareLayout(); - void SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem); - CXFA_LayoutProcessor* m_pLayoutProcessor; - CXFA_Node* m_pTemplatePageSetRoot; - CXFA_ContainerLayoutItem* m_pPageSetLayoutItemRoot; - CXFA_ContainerLayoutItem* m_pPageSetCurRoot; - FX_POSITION m_pCurrentContainerRecord; - CFX_PtrList m_rgProposedContainerRecord; - CXFA_Node* m_pCurPageArea; - int32_t m_nAvailPages; - int32_t m_nCurPageCount; - XFA_ATTRIBUTEENUM m_ePageSetMode; - FX_BOOL m_bCreateOverFlowPage; - CFX_MapPtrTemplate m_pPageSetMap; - CFX_ArrayTemplate m_PageArray; -}; - -#endif // XFA_FXFA_PARSER_XFA_LAYOUT_PAGEMGR_NEW_H_ -- cgit v1.2.3