diff options
Diffstat (limited to 'xfa/fxfa/parser/cxfa_layoutpagemgr.cpp')
| -rw-r--r-- | xfa/fxfa/parser/cxfa_layoutpagemgr.cpp | 2000 |
1 files changed, 2000 insertions, 0 deletions
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<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pFirstChild); + while (pChildItem && + pChildItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) { + pChildItem = + static_cast<CXFA_ContainerLayoutItem*>(pChildItem->m_pNextSibling); + } + return pChildItem; + } + + static CXFA_ContainerLayoutItem* GetNextSibling( + CXFA_ContainerLayoutItem* pLayoutItem) { + CXFA_ContainerLayoutItem* pChildItem = + static_cast<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pNextSibling); + while (pChildItem && + pChildItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) { + pChildItem = + static_cast<CXFA_ContainerLayoutItem*>(pChildItem->m_pNextSibling); + } + return pChildItem; + } + + static CXFA_ContainerLayoutItem* GetParent( + CXFA_ContainerLayoutItem* pLayoutItem) { + return static_cast<CXFA_ContainerLayoutItem*>(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<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pParent); + if (!pParentLayoutItem) + return; + + pParentLayoutItem->RemoveChild(pLayoutItem); + pParentLayoutItem->AddChild(pLayoutItem); +} + +void RemoveLayoutItem(CXFA_ContainerLayoutItem* pLayoutItem) { + CXFA_ContainerLayoutItem* pParentLayoutItem = + static_cast<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 = + static_cast<CXFA_ContainerLayoutItem*>( + pPageAreaLayoutItem->m_pFirstChild); + pLayoutItem; pLayoutItem = static_cast<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 + +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<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 = static_cast<CXFA_ContainerLayoutItem*>( + GetCurrentContainerRecord()->pCurPageSet->m_pParent); + } else { + pParentPageSetLayout = static_cast<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 = static_cast<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 = + static_cast<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 = static_cast<CXFA_ContainerLayoutItem*>( + pRootPageSetLayoutItem->m_pNextSibling)) { + CXFA_NodeIteratorTemplate<CXFA_ContainerLayoutItem, + PageSetContainerLayoutItem> + 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<FX_FLOAT> 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<CXFA_ContainerLayoutItem*>(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<CXFA_ContainerRecord*>( + m_rgProposedContainerRecord.GetNext(psSrcRecord)); + while (psSrcRecord) { + FX_POSITION psSaveRecord = psSrcRecord; + CXFA_ContainerRecord* pInsertRecord = + static_cast<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 = static_cast<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<CXFA_Node, CXFA_TraverseStrategy_XFANode> + 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<CXFA_Node, CXFA_TraverseStrategy_XFANode> + 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<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 = static_cast<CXFA_ContainerLayoutItem*>( + pFormLayout->m_pFirstChild); + if (iLevel == 2) { + while (pFormLayout && + !XFA_ItemLayoutProcessor_IsTakingSpace( + pFormLayout->m_pFormNode)) { + pFormLayout = static_cast<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<CXFA_LayoutItem*>( + 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<CXFA_Node, CXFA_TraverseStrategy_XFANode> + 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<CXFA_LayoutItem*>( + pChildNode->GetUserData(XFA_LAYOUTITEMKEY)); + if (pLayoutItem) { + pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem); + delete pLayoutItem; + } + } + } else if (eType != XFA_Element::ContentArea) { + CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>( + 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<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 = static_cast<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<CXFA_LayoutItem, + CXFA_TraverseStrategy_LayoutItem> + 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<CXFA_ContainerLayoutItem*>(pRootLayoutItem->m_pNextSibling); + SaveLayoutItem(pRootLayoutItem); + delete pRootLayoutItem; + } + m_pPageSetLayoutItemRoot = nullptr; +} |