summaryrefslogtreecommitdiff
path: root/xfa/fxfa/parser/cxfa_layoutpagemgr.cpp
diff options
context:
space:
mode:
authordsinclair <dsinclair@chromium.org>2016-08-03 12:58:53 -0700
committerCommit bot <commit-bot@chromium.org>2016-08-03 12:58:53 -0700
commit8d0cc67cdf3ef45ee7268d3e00a21c0a99843a84 (patch)
tree36e5098671adcfd2c307e0db482186770a3f3c83 /xfa/fxfa/parser/cxfa_layoutpagemgr.cpp
parentd9a39d0e09df7f09d0f6caec525642f3472fe6f3 (diff)
downloadpdfium-8d0cc67cdf3ef45ee7268d3e00a21c0a99843a84.tar.xz
Rename xfa_layout_pagemgr_new.h
This renames the file to match the class name. Review-Url: https://codereview.chromium.org/2209823002
Diffstat (limited to 'xfa/fxfa/parser/cxfa_layoutpagemgr.cpp')
-rw-r--r--xfa/fxfa/parser/cxfa_layoutpagemgr.cpp2000
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;
+}