| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| |
| #include "xfa/fxfa/parser/xfa_layout_pagemgr_new.h" |
| |
| #include "xfa/fxfa/app/xfa_ffnotify.h" |
| #include "xfa/fxfa/parser/xfa_doclayout.h" |
| #include "xfa/fxfa/parser/xfa_document.h" |
| #include "xfa/fxfa/parser/xfa_document_datamerger_imp.h" |
| #include "xfa/fxfa/parser/xfa_document_layout_imp.h" |
| #include "xfa/fxfa/parser/xfa_layout_appadapter.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_script.h" |
| #include "xfa/fxfa/parser/xfa_script_imp.h" |
| #include "xfa/fxfa/parser/xfa_utils.h" |
| |
| namespace { |
| |
| class PageSetContainerLayoutItem { |
| public: |
| static inline CXFA_ContainerLayoutItem* GetFirstChild( |
| CXFA_ContainerLayoutItem* pLayoutItem) { |
| if (pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::PageSet) |
| return nullptr; |
| |
| CXFA_ContainerLayoutItem* pChildItem = |
| static_cast<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 inline 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 inline 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 = |
| (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent; |
| if (!pParentLayoutItem) |
| return; |
| |
| pParentLayoutItem->RemoveChild(pLayoutItem); |
| pParentLayoutItem->AddChild(pLayoutItem); |
| } |
| |
| void RemoveLayoutItem(CXFA_ContainerLayoutItem* pLayoutItem) { |
| CXFA_ContainerLayoutItem* pParentLayoutItem = |
| (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent; |
| if (!pParentLayoutItem) |
| return; |
| |
| pParentLayoutItem->RemoveChild(pLayoutItem); |
| } |
| |
| CXFA_Node* ResolveBreakTarget(CXFA_Node* pPageSetRoot, |
| FX_BOOL bNewExprStyle, |
| CFX_WideStringC& wsTargetExpr) { |
| CXFA_Document* pDocument = pPageSetRoot->GetDocument(); |
| if (wsTargetExpr.IsEmpty()) |
| return nullptr; |
| |
| CFX_WideString wsTargetAll(wsTargetExpr); |
| wsTargetAll.TrimLeft(); |
| wsTargetAll.TrimRight(); |
| int32_t iSpliteIndex = 0; |
| FX_BOOL bTargetAllFind = TRUE; |
| while (iSpliteIndex != -1) { |
| CFX_WideString wsExpr; |
| int32_t iSpliteNextIndex = 0; |
| if (!bTargetAllFind) { |
| iSpliteNextIndex = wsTargetAll.Find(' ', iSpliteIndex); |
| wsExpr = wsTargetAll.Mid(iSpliteIndex, iSpliteNextIndex - iSpliteIndex); |
| } else { |
| wsExpr = wsTargetAll; |
| } |
| if (wsExpr.IsEmpty()) |
| return nullptr; |
| |
| bTargetAllFind = FALSE; |
| if (wsExpr.GetAt(0) == '#') { |
| CXFA_Node* pNode = pDocument->GetNodeByID( |
| ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Template)), |
| wsExpr.Mid(1).AsStringC()); |
| if (pNode) |
| return pNode; |
| } else if (bNewExprStyle) { |
| CFX_WideString wsProcessedTarget = wsExpr; |
| if (wsExpr.Left(4) == FX_WSTRC(L"som(") && |
| wsExpr.Right(1) == FX_WSTRC(L")")) { |
| wsProcessedTarget = wsExpr.Mid(4, wsExpr.GetLength() - 5); |
| } |
| XFA_RESOLVENODE_RS rs; |
| int32_t iCount = pDocument->GetScriptContext()->ResolveObjects( |
| pPageSetRoot, wsProcessedTarget.AsStringC(), rs, |
| XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties | |
| XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Siblings | |
| XFA_RESOLVENODE_Parent); |
| if (iCount > 0 && rs.nodes[0]->IsNode()) |
| return rs.nodes[0]->AsNode(); |
| } |
| iSpliteIndex = iSpliteNextIndex; |
| } |
| return nullptr; |
| } |
| |
| void SetLayoutGeneratedNodeFlag(CXFA_Node* pNode) { |
| pNode->SetFlag(XFA_NodeFlag_LayoutGeneratedNode, false); |
| pNode->ClearFlag(XFA_NodeFlag_UnusedNode); |
| } |
| |
| FX_BOOL CheckContentAreaNotUsed( |
| CXFA_ContainerLayoutItem* pPageAreaLayoutItem, |
| CXFA_Node* pContentArea, |
| CXFA_ContainerLayoutItem*& pContentAreaLayoutItem) { |
| for (CXFA_ContainerLayoutItem* pLayoutItem = |
| (CXFA_ContainerLayoutItem*)pPageAreaLayoutItem->m_pFirstChild; |
| pLayoutItem; |
| pLayoutItem = (CXFA_ContainerLayoutItem*)pLayoutItem->m_pNextSibling) { |
| if (pLayoutItem->m_pFormNode == pContentArea) { |
| if (!pLayoutItem->m_pFirstChild) { |
| pContentAreaLayoutItem = pLayoutItem; |
| return TRUE; |
| } |
| return FALSE; |
| } |
| } |
| return TRUE; |
| } |
| |
| void SyncRemoveLayoutItem(CXFA_LayoutItem* pParentLayoutItem, |
| CXFA_FFNotify* pNotify, |
| CXFA_LayoutProcessor* pDocLayout) { |
| CXFA_LayoutItem* pNextLayoutItem; |
| CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild; |
| while (pCurLayoutItem) { |
| pNextLayoutItem = pCurLayoutItem->m_pNextSibling; |
| if (pCurLayoutItem->m_pFirstChild) |
| SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout); |
| |
| pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem); |
| delete pCurLayoutItem; |
| pCurLayoutItem = pNextLayoutItem; |
| } |
| } |
| |
| } // namespace |
| |
| CXFA_LayoutPageMgr::CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor) |
| : m_pLayoutProcessor(pLayoutProcessor), |
| m_pTemplatePageSetRoot(nullptr), |
| m_pPageSetLayoutItemRoot(nullptr), |
| m_pPageSetCurRoot(nullptr), |
| m_pCurrentContainerRecord(nullptr), |
| m_pCurPageArea(nullptr), |
| m_nAvailPages(0), |
| m_nCurPageCount(0), |
| m_ePageSetMode(XFA_ATTRIBUTEENUM_OrderedOccurrence), |
| m_bCreateOverFlowPage(FALSE) {} |
| CXFA_LayoutPageMgr::~CXFA_LayoutPageMgr() { |
| ClearData(); |
| CXFA_LayoutItem* pLayoutItem = GetRootLayoutItem(); |
| CXFA_LayoutItem* pNextLayout = nullptr; |
| for (; pLayoutItem; pLayoutItem = pNextLayout) { |
| pNextLayout = pLayoutItem->m_pNextSibling; |
| XFA_ReleaseLayoutItem(pLayoutItem); |
| } |
| } |
| FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) { |
| PrepareLayout(); |
| CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode(); |
| if (!pTemplateNode) { |
| return FALSE; |
| } |
| m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_Element::PageSet); |
| ASSERT(m_pTemplatePageSetRoot); |
| if (m_pPageSetLayoutItemRoot) { |
| m_pPageSetLayoutItemRoot->m_pParent = nullptr; |
| m_pPageSetLayoutItemRoot->m_pFirstChild = nullptr; |
| m_pPageSetLayoutItemRoot->m_pNextSibling = nullptr; |
| m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot; |
| } else { |
| m_pPageSetLayoutItemRoot = |
| new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot); |
| } |
| m_pPageSetCurRoot = m_pPageSetLayoutItemRoot; |
| m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY, |
| (void*)m_pPageSetLayoutItemRoot); |
| XFA_ATTRIBUTEENUM eRelation = |
| m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation); |
| if (eRelation != XFA_ATTRIBUTEENUM_Unknown) { |
| m_ePageSetMode = eRelation; |
| } |
| InitPageSetMap(); |
| CXFA_Node* pPageArea = nullptr; |
| int32_t iCount = 0; |
| for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pPageArea; |
| pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pPageArea->GetElementType() == XFA_Element::PageArea) { |
| iCount++; |
| if (pPageArea->GetFirstChildByClass(XFA_Element::ContentArea)) { |
| return TRUE; |
| } |
| } |
| } |
| if (iCount > 0) { |
| return FALSE; |
| } |
| CXFA_Document* pDocument = pTemplateNode->GetDocument(); |
| pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_Element::PageArea); |
| if (!pPageArea) { |
| pPageArea = pDocument->CreateNode(m_pTemplatePageSetRoot->GetPacketID(), |
| XFA_Element::PageArea); |
| if (!pPageArea) { |
| return FALSE; |
| } |
| m_pTemplatePageSetRoot->InsertChild(pPageArea, nullptr); |
| pPageArea->SetFlag(XFA_NodeFlag_Initialized, true); |
| } |
| CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_Element::ContentArea); |
| if (!pContentArea) { |
| pContentArea = pDocument->CreateNode(pPageArea->GetPacketID(), |
| XFA_Element::ContentArea); |
| if (!pContentArea) { |
| return FALSE; |
| } |
| pPageArea->InsertChild(pContentArea, nullptr); |
| pContentArea->SetFlag(XFA_NodeFlag_Initialized, true); |
| pContentArea->SetMeasure(XFA_ATTRIBUTE_X, |
| CXFA_Measurement(0.25f, XFA_UNIT_In)); |
| pContentArea->SetMeasure(XFA_ATTRIBUTE_Y, |
| CXFA_Measurement(0.25f, XFA_UNIT_In)); |
| pContentArea->SetMeasure(XFA_ATTRIBUTE_W, |
| CXFA_Measurement(8.0f, XFA_UNIT_In)); |
| pContentArea->SetMeasure(XFA_ATTRIBUTE_H, |
| CXFA_Measurement(10.5f, XFA_UNIT_In)); |
| } |
| CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_Element::Medium); |
| if (!pMedium) { |
| pMedium = |
| pDocument->CreateNode(pPageArea->GetPacketID(), XFA_Element::Medium); |
| if (!pContentArea) { |
| return FALSE; |
| } |
| pPageArea->InsertChild(pMedium, nullptr); |
| pMedium->SetFlag(XFA_NodeFlag_Initialized, true); |
| pMedium->SetMeasure(XFA_ATTRIBUTE_Short, |
| CXFA_Measurement(8.5f, XFA_UNIT_In)); |
| pMedium->SetMeasure(XFA_ATTRIBUTE_Long, |
| CXFA_Measurement(11.0f, XFA_UNIT_In)); |
| } |
| return TRUE; |
| } |
| FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) { |
| FX_BOOL bProBreakBefore = FALSE; |
| CXFA_Node* pBreakBeforeNode = nullptr; |
| while (pRootSubform) { |
| for (CXFA_Node* pBreakNode = |
| pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pBreakNode; |
| pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| XFA_Element eType = pBreakNode->GetElementType(); |
| if (eType == XFA_Element::BreakBefore || |
| (eType == XFA_Element::Break && |
| pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) != |
| XFA_ATTRIBUTEENUM_Auto)) { |
| bProBreakBefore = TRUE; |
| pBreakBeforeNode = pBreakNode; |
| break; |
| } |
| } |
| if (bProBreakBefore) { |
| break; |
| } |
| bProBreakBefore = TRUE; |
| pRootSubform = pRootSubform->GetFirstChildByClass(XFA_Element::Subform); |
| while (pRootSubform && |
| !XFA_ItemLayoutProcessor_IsTakingSpace(pRootSubform)) { |
| pRootSubform = |
| pRootSubform->GetNextSameClassSibling(XFA_Element::Subform); |
| } |
| } |
| CXFA_Node *pLeader, *pTrailer; |
| if (pBreakBeforeNode && |
| ExecuteBreakBeforeOrAfter(pBreakBeforeNode, TRUE, pLeader, pTrailer)) { |
| m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition(); |
| return TRUE; |
| } |
| return AppendNewPage(TRUE); |
| } |
| FX_BOOL CXFA_LayoutPageMgr::AppendNewPage(FX_BOOL bFirstTemPage) { |
| if (m_pCurrentContainerRecord != |
| m_rgProposedContainerRecord.GetTailPosition()) { |
| return TRUE; |
| } |
| CXFA_Node* pPageNode = GetNextAvailPageArea(nullptr); |
| if (!pPageNode) { |
| return FALSE; |
| } |
| if (bFirstTemPage && !m_pCurrentContainerRecord) { |
| m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition(); |
| } |
| return !bFirstTemPage || m_pCurrentContainerRecord; |
| } |
| |
| void CXFA_LayoutPageMgr::RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord, |
| CXFA_ContainerRecord* pPrevRecord) { |
| if (!pNewRecord || !pPrevRecord) { |
| return; |
| } |
| if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) { |
| RemoveLayoutItem(pNewRecord->pCurPageSet); |
| return; |
| } |
| if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) { |
| RemoveLayoutItem(pNewRecord->pCurPageArea); |
| return; |
| } |
| if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) { |
| RemoveLayoutItem(pNewRecord->pCurContentArea); |
| return; |
| } |
| } |
| void CXFA_LayoutPageMgr::ReorderPendingLayoutRecordToTail( |
| CXFA_ContainerRecord* pNewRecord, |
| CXFA_ContainerRecord* pPrevRecord) { |
| if (!pNewRecord || !pPrevRecord) { |
| return; |
| } |
| if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) { |
| ReorderLayoutItemToTail(pNewRecord->pCurPageSet); |
| return; |
| } |
| if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) { |
| ReorderLayoutItemToTail(pNewRecord->pCurPageArea); |
| return; |
| } |
| if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) { |
| ReorderLayoutItemToTail(pNewRecord->pCurContentArea); |
| return; |
| } |
| } |
| void CXFA_LayoutPageMgr::SubmitContentItem( |
| CXFA_ContentLayoutItem* pContentLayoutItem, |
| XFA_ItemLayoutProcessorResult eStatus) { |
| if (pContentLayoutItem) { |
| GetCurrentContainerRecord()->pCurContentArea->AddChild(pContentLayoutItem); |
| m_bCreateOverFlowPage = FALSE; |
| } |
| if (eStatus != XFA_ItemLayoutProcessorResult_Done) { |
| if (eStatus == XFA_ItemLayoutProcessorResult_PageFullBreak && |
| m_pCurrentContainerRecord == |
| m_rgProposedContainerRecord.GetTailPosition()) { |
| AppendNewPage(); |
| } |
| m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetTailPosition(); |
| m_pCurPageArea = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode; |
| } |
| } |
| FX_FLOAT CXFA_LayoutPageMgr::GetAvailHeight() { |
| CXFA_ContainerLayoutItem* pLayoutItem = |
| GetCurrentContainerRecord()->pCurContentArea; |
| if (!pLayoutItem || !pLayoutItem->m_pFormNode) |
| return 0.0f; |
| FX_FLOAT fAvailHeight = |
| pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); |
| if (fAvailHeight >= XFA_LAYOUT_FLOAT_PERCISION) |
| return fAvailHeight; |
| if (m_pCurrentContainerRecord == |
| m_rgProposedContainerRecord.GetHeadPosition()) { |
| return 0.0f; |
| } |
| return XFA_LAYOUT_FLOAT_MAX; |
| } |
| |
| FX_BOOL XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) { |
| CFX_WideString wsExpression; |
| pTestScript->TryContent(wsExpression); |
| if (wsExpression.IsEmpty()) { |
| return TRUE; |
| } |
| return pTestScript->GetDocument()->GetNotify()->RunScript( |
| pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent, |
| XFA_ObjectType::ContainerNode)); |
| } |
| CXFA_ContainerRecord* CXFA_LayoutPageMgr::CreateContainerRecord( |
| CXFA_Node* pPageNode, |
| FX_BOOL bCreateNew) { |
| CXFA_ContainerRecord* pNewRecord = new CXFA_ContainerRecord(); |
| if (m_pCurrentContainerRecord) { |
| if (!IsPageSetRootOrderedOccurrence() || !pPageNode) { |
| *pNewRecord = *GetCurrentContainerRecord(); |
| m_rgProposedContainerRecord.AddTail(pNewRecord); |
| return pNewRecord; |
| } |
| CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent); |
| if (!bCreateNew) { |
| if (pPageSet == m_pTemplatePageSetRoot) { |
| pNewRecord->pCurPageSet = m_pPageSetCurRoot; |
| } else { |
| CXFA_ContainerLayoutItem* pParentLayoutItem = |
| (CXFA_ContainerLayoutItem*)pPageSet->GetUserData(XFA_LAYOUTITEMKEY); |
| if (!pParentLayoutItem) { |
| pParentLayoutItem = m_pPageSetCurRoot; |
| } |
| pNewRecord->pCurPageSet = pParentLayoutItem; |
| } |
| } else { |
| CXFA_ContainerLayoutItem* pParentPageSetLayout = nullptr; |
| if (pPageSet == GetCurrentContainerRecord()->pCurPageSet->m_pFormNode) { |
| pParentPageSetLayout = |
| (CXFA_ContainerLayoutItem*)GetCurrentContainerRecord() |
| ->pCurPageSet->m_pParent; |
| } else { |
| pParentPageSetLayout = |
| (CXFA_ContainerLayoutItem*)pPageSet->GetNodeItem( |
| XFA_NODEITEM_Parent) |
| ->GetUserData(XFA_LAYOUTITEMKEY); |
| } |
| CXFA_ContainerLayoutItem* pPageSetLayoutItem = |
| new CXFA_ContainerLayoutItem(pPageSet); |
| pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem); |
| if (!pParentPageSetLayout) { |
| CXFA_ContainerLayoutItem* pPrePageSet = m_pPageSetLayoutItemRoot; |
| while (pPrePageSet->m_pNextSibling) { |
| pPrePageSet = (CXFA_ContainerLayoutItem*)pPrePageSet->m_pNextSibling; |
| } |
| pPrePageSet->m_pNextSibling = pPageSetLayoutItem; |
| m_pPageSetCurRoot = pPageSetLayoutItem; |
| } else { |
| pParentPageSetLayout->AddChild(pPageSetLayoutItem); |
| } |
| pNewRecord->pCurPageSet = pPageSetLayoutItem; |
| } |
| } else { |
| if (pPageNode) { |
| CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent); |
| if (pPageSet == m_pTemplatePageSetRoot) { |
| pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot; |
| } else { |
| CXFA_ContainerLayoutItem* pPageSetLayoutItem = |
| new CXFA_ContainerLayoutItem(pPageSet); |
| pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem); |
| m_pPageSetLayoutItemRoot->AddChild(pPageSetLayoutItem); |
| pNewRecord->pCurPageSet = pPageSetLayoutItem; |
| } |
| } else { |
| pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot; |
| } |
| } |
| m_rgProposedContainerRecord.AddTail(pNewRecord); |
| return pNewRecord; |
| } |
| void CXFA_LayoutPageMgr::AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord, |
| CXFA_Node* pNewPageArea) { |
| CXFA_ContainerLayoutItem* pNewPageAreaLayoutItem = nullptr; |
| if (m_PageArray.GetSize() > m_nAvailPages) { |
| CXFA_ContainerLayoutItem* pContainerItem = m_PageArray[m_nAvailPages]; |
| pContainerItem->m_pFormNode = pNewPageArea; |
| m_nAvailPages++; |
| pNewPageAreaLayoutItem = pContainerItem; |
| } else { |
| CXFA_FFNotify* pNotify = pNewPageArea->GetDocument()->GetNotify(); |
| CXFA_ContainerLayoutItem* pContainerItem = |
| (CXFA_ContainerLayoutItem*)pNotify->OnCreateLayoutItem(pNewPageArea); |
| m_PageArray.Add(pContainerItem); |
| m_nAvailPages++; |
| pNotify->OnPageEvent(pContainerItem, XFA_PAGEVIEWEVENT_PostRemoved); |
| pNewPageAreaLayoutItem = pContainerItem; |
| } |
| pNewRecord->pCurPageSet->AddChild(pNewPageAreaLayoutItem); |
| pNewRecord->pCurPageArea = pNewPageAreaLayoutItem; |
| pNewRecord->pCurContentArea = nullptr; |
| } |
| void CXFA_LayoutPageMgr::AddContentAreaLayoutItem( |
| CXFA_ContainerRecord* pNewRecord, |
| CXFA_Node* pContentArea) { |
| if (!pContentArea) { |
| pNewRecord->pCurContentArea = nullptr; |
| return; |
| } |
| CXFA_ContainerLayoutItem* pNewContentAreaLayoutItem = |
| new CXFA_ContainerLayoutItem(pContentArea); |
| ASSERT(pNewRecord->pCurPageArea); |
| pNewRecord->pCurPageArea->AddChild(pNewContentAreaLayoutItem); |
| pNewRecord->pCurContentArea = pNewContentAreaLayoutItem; |
| } |
| |
| void CXFA_LayoutPageMgr::FinishPaginatedPageSets() { |
| CXFA_ContainerLayoutItem* pRootPageSetLayoutItem = m_pPageSetLayoutItemRoot; |
| for (; pRootPageSetLayoutItem; |
| pRootPageSetLayoutItem = |
| (CXFA_ContainerLayoutItem*)pRootPageSetLayoutItem->m_pNextSibling) { |
| CXFA_NodeIteratorTemplate<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; |
| } else { |
| if (m_rgProposedContainerRecord.GetCount() > 0 && |
| m_pCurrentContainerRecord == |
| m_rgProposedContainerRecord.GetHeadPosition() && |
| eType == XFA_Element::BreakBefore) { |
| CXFA_Node* pParentNode = pFormNode->GetNodeItem( |
| XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); |
| if (!pParentNode || |
| pFormNode != |
| pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild, |
| XFA_ObjectType::ContainerNode)) { |
| break; |
| } |
| pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent); |
| if (!pParentNode || |
| pParentNode->GetElementType() != XFA_Element::Form) { |
| break; |
| } |
| return TRUE; |
| } |
| } |
| } break; |
| case XFA_Element::Break: { |
| FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0; |
| CFX_WideStringC wsTarget = pCurNode->GetCData( |
| bBefore ? XFA_ATTRIBUTE_BeforeTarget : XFA_ATTRIBUTE_AfterTarget); |
| CXFA_Node* pTarget = |
| ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget); |
| if (RunBreak(bBefore ? XFA_Element::BreakBefore : XFA_Element::BreakAfter, |
| pCurNode->GetEnum(bBefore ? XFA_ATTRIBUTE_Before |
| : XFA_ATTRIBUTE_After), |
| pTarget, bStartNew)) { |
| return TRUE; |
| } |
| } break; |
| default: |
| break; |
| } |
| return FALSE; |
| } |
| |
| FX_BOOL CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter( |
| CXFA_Node* pBreakNode, |
| FX_BOOL bBefore, |
| CXFA_Node*& pBreakLeaderNode, |
| CXFA_Node*& pBreakTrailerNode, |
| FX_BOOL& bCreatePage) { |
| CXFA_Node* pLeaderTemplate = nullptr; |
| CXFA_Node* pTrailerTemplate = nullptr; |
| CXFA_Node* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent, |
| XFA_ObjectType::ContainerNode); |
| if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) { |
| bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore, |
| pLeaderTemplate, pTrailerTemplate); |
| CXFA_Document* pDocument = pBreakNode->GetDocument(); |
| CXFA_Node* pDataScope = nullptr; |
| pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent, |
| XFA_ObjectType::ContainerNode); |
| if (pLeaderTemplate) { |
| if (!pDataScope) { |
| pDataScope = XFA_DataMerge_FindDataScope(pFormNode); |
| } |
| pBreakLeaderNode = pDocument->DataMerge_CopyContainer( |
| pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); |
| pDocument->DataMerge_UpdateBindingRelations(pBreakLeaderNode); |
| SetLayoutGeneratedNodeFlag(pBreakLeaderNode); |
| } |
| if (pTrailerTemplate) { |
| if (!pDataScope) { |
| pDataScope = XFA_DataMerge_FindDataScope(pFormNode); |
| } |
| pBreakTrailerNode = pDocument->DataMerge_CopyContainer( |
| pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); |
| pDocument->DataMerge_UpdateBindingRelations(pBreakTrailerNode); |
| SetLayoutGeneratedNodeFlag(pBreakTrailerNode); |
| } |
| return TRUE; |
| } |
| return FALSE; |
| } |
| FX_BOOL CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer( |
| CXFA_Node* pBookendNode, |
| FX_BOOL bLeader, |
| CXFA_Node*& pBookendAppendNode) { |
| CXFA_Node* pLeaderTemplate = nullptr; |
| CXFA_Node* pFormNode = pBookendNode->GetNodeItem( |
| XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode); |
| if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) { |
| CXFA_Document* pDocument = pBookendNode->GetDocument(); |
| CXFA_Node* pDataScope = nullptr; |
| if (pLeaderTemplate) { |
| if (!pDataScope) { |
| pDataScope = XFA_DataMerge_FindDataScope(pFormNode); |
| } |
| pBookendAppendNode = pDocument->DataMerge_CopyContainer( |
| pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); |
| pDocument->DataMerge_UpdateBindingRelations(pBookendAppendNode); |
| SetLayoutGeneratedNodeFlag(pBookendAppendNode); |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode, |
| CXFA_Node*& pLeaderTemplate, |
| CXFA_Node*& pTrailerTemplate, |
| FX_BOOL bCreatePage) { |
| CXFA_Node* pContainer = |
| pOverflowNode |
| ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode) |
| ->GetTemplateNode(); |
| if (pOverflowNode->GetElementType() == XFA_Element::Break) { |
| CFX_WideStringC wsOverflowLeader; |
| CFX_WideStringC wsOverflowTarget; |
| CFX_WideStringC wsOverflowTrailer; |
| pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader); |
| pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer); |
| pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget); |
| if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() || |
| !wsOverflowTarget.IsEmpty()) { |
| if (!wsOverflowTarget.IsEmpty() && bCreatePage && |
| !m_bCreateOverFlowPage) { |
| CXFA_Node* pTarget = |
| ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget); |
| if (pTarget) { |
| m_bCreateOverFlowPage = TRUE; |
| switch (pTarget->GetElementType()) { |
| case XFA_Element::PageArea: |
| RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, |
| pTarget, TRUE); |
| break; |
| case XFA_Element::ContentArea: |
| RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea, |
| pTarget, TRUE); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| if (!bCreatePage) { |
| pLeaderTemplate = |
| ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader); |
| pTrailerTemplate = |
| ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer); |
| } |
| return pOverflowNode; |
| } |
| return nullptr; |
| } |
| |
| if (pOverflowNode->GetElementType() != XFA_Element::Overflow) |
| return nullptr; |
| |
| CFX_WideStringC wsOverflowLeader; |
| CFX_WideStringC wsOverflowTrailer; |
| CFX_WideStringC wsOverflowTarget; |
| pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader); |
| pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer); |
| pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget); |
| if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) { |
| CXFA_Node* pTarget = |
| ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget); |
| if (pTarget) { |
| m_bCreateOverFlowPage = TRUE; |
| switch (pTarget->GetElementType()) { |
| case XFA_Element::PageArea: |
| RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget, |
| TRUE); |
| break; |
| case XFA_Element::ContentArea: |
| RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea, |
| pTarget, TRUE); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| if (!bCreatePage) { |
| pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader); |
| pTrailerTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer); |
| } |
| return pOverflowNode; |
| } |
| |
| FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode, |
| CXFA_Node*& pLeaderNode, |
| CXFA_Node*& pTrailerNode, |
| FX_BOOL bDataMerge, |
| FX_BOOL bCreatePage) { |
| if (!pFormNode) { |
| return FALSE; |
| } |
| CXFA_Node* pLeaderTemplate = nullptr; |
| CXFA_Node* pTrailerTemplate = nullptr; |
| FX_BOOL bIsOverflowNode = FALSE; |
| if (pFormNode->GetElementType() == XFA_Element::Overflow || |
| pFormNode->GetElementType() == XFA_Element::Break) { |
| bIsOverflowNode = TRUE; |
| } |
| for (CXFA_Node* pCurNode = |
| bIsOverflowNode ? pFormNode |
| : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) { |
| if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate, |
| bCreatePage)) { |
| if (bIsOverflowNode) { |
| pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent); |
| } |
| CXFA_Document* pDocument = pCurNode->GetDocument(); |
| CXFA_Node* pDataScope = nullptr; |
| if (pLeaderTemplate) { |
| if (!pDataScope) { |
| pDataScope = XFA_DataMerge_FindDataScope(pFormNode); |
| } |
| pLeaderNode = pDocument->DataMerge_CopyContainer( |
| pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); |
| pDocument->DataMerge_UpdateBindingRelations(pLeaderNode); |
| SetLayoutGeneratedNodeFlag(pLeaderNode); |
| } |
| if (pTrailerTemplate) { |
| if (!pDataScope) { |
| pDataScope = XFA_DataMerge_FindDataScope(pFormNode); |
| } |
| pTrailerNode = pDocument->DataMerge_CopyContainer( |
| pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE); |
| pDocument->DataMerge_UpdateBindingRelations(pTrailerNode); |
| SetLayoutGeneratedNodeFlag(pTrailerNode); |
| } |
| return TRUE; |
| } |
| if (bIsOverflowNode) { |
| break; |
| } |
| } |
| return FALSE; |
| } |
| FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer( |
| CXFA_Node* pBookendNode, |
| FX_BOOL bLeader, |
| CXFA_Node*& pBookendAppendTemplate) { |
| CFX_WideStringC wsBookendLeader; |
| CXFA_Node* pContainer = |
| pBookendNode |
| ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode) |
| ->GetTemplateNode(); |
| if (pBookendNode->GetElementType() == XFA_Element::Break) { |
| pBookendNode->TryCData( |
| bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer, |
| wsBookendLeader); |
| if (!wsBookendLeader.IsEmpty()) { |
| pBookendAppendTemplate = |
| ResolveBreakTarget(pContainer, FALSE, wsBookendLeader); |
| return TRUE; |
| } |
| return FALSE; |
| } else if (pBookendNode->GetElementType() == XFA_Element::Bookend) { |
| pBookendNode->TryCData( |
| bLeader ? XFA_ATTRIBUTE_Leader : XFA_ATTRIBUTE_Trailer, |
| wsBookendLeader); |
| pBookendAppendTemplate = |
| ResolveBreakTarget(pContainer, TRUE, wsBookendLeader); |
| return TRUE; |
| } |
| return FALSE; |
| } |
| FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet( |
| CXFA_Node* pPageSet, |
| CXFA_Node* pStartChild, |
| CXFA_Node* pTargetPageArea, |
| CXFA_Node* pTargetContentArea, |
| FX_BOOL bNewPage, |
| FX_BOOL bQuery) { |
| if (!pPageSet && !pStartChild) { |
| return FALSE; |
| } |
| if (IsPageSetRootOrderedOccurrence()) { |
| return FindPageAreaFromPageSet_Ordered(pPageSet, pStartChild, |
| pTargetPageArea, pTargetContentArea, |
| bNewPage, bQuery); |
| } |
| XFA_ATTRIBUTEENUM ePreferredPosition = m_pCurrentContainerRecord |
| ? XFA_ATTRIBUTEENUM_Rest |
| : XFA_ATTRIBUTEENUM_First; |
| return FindPageAreaFromPageSet_SimplexDuplex( |
| pPageSet, pStartChild, pTargetPageArea, pTargetContentArea, bNewPage, |
| bQuery, ePreferredPosition); |
| } |
| FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_Ordered( |
| CXFA_Node* pPageSet, |
| CXFA_Node* pStartChild, |
| CXFA_Node* pTargetPageArea, |
| CXFA_Node* pTargetContentArea, |
| FX_BOOL bNewPage, |
| FX_BOOL bQuery) { |
| int32_t iPageSetCount = 0; |
| if (!pStartChild && !bQuery) { |
| m_pPageSetMap.Lookup(pPageSet, iPageSetCount); |
| int32_t iMax = -1; |
| CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur); |
| if (pOccurNode) { |
| pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE); |
| } |
| if (iMax >= 0 && iMax <= iPageSetCount) { |
| return FALSE; |
| } |
| } |
| FX_BOOL bRes = FALSE; |
| CXFA_Node* pCurrentNode = |
| pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling) |
| : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); |
| for (; pCurrentNode; |
| pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { |
| if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) { |
| if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) { |
| if (pTargetPageArea == pCurrentNode) { |
| CreateMinPageRecord(pCurrentNode, TRUE); |
| pTargetPageArea = nullptr; |
| } |
| continue; |
| } |
| if (!bQuery) { |
| CXFA_ContainerRecord* pNewRecord = |
| CreateContainerRecord(pCurrentNode, !pStartChild); |
| AddPageAreaLayoutItem(pNewRecord, pCurrentNode); |
| if (!pTargetContentArea) { |
| pTargetContentArea = |
| pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea); |
| } |
| AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); |
| } |
| m_pCurPageArea = pCurrentNode; |
| m_nCurPageCount = 1; |
| bRes = TRUE; |
| break; |
| } |
| if (!bQuery) { |
| CreateMinPageRecord(pCurrentNode, FALSE); |
| } |
| } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { |
| if (FindPageAreaFromPageSet_Ordered(pCurrentNode, nullptr, |
| pTargetPageArea, pTargetContentArea, |
| bNewPage, bQuery)) { |
| bRes = TRUE; |
| break; |
| } |
| if (!bQuery) { |
| CreateMinPageSetRecord(pCurrentNode, TRUE); |
| } |
| } |
| } |
| if (!pStartChild && bRes && !bQuery) { |
| m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount); |
| } |
| return bRes; |
| } |
| FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex( |
| CXFA_Node* pPageSet, |
| CXFA_Node* pStartChild, |
| CXFA_Node* pTargetPageArea, |
| CXFA_Node* pTargetContentArea, |
| FX_BOOL bNewPage, |
| FX_BOOL bQuery, |
| XFA_ATTRIBUTEENUM ePreferredPosition) { |
| const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any; |
| CXFA_Node* pPreferredPageArea = nullptr; |
| CXFA_Node* pFallbackPageArea = nullptr; |
| CXFA_Node* pCurrentNode = nullptr; |
| if (!pStartChild || pStartChild->GetElementType() == XFA_Element::PageArea) { |
| pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); |
| } else { |
| pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling); |
| } |
| for (; pCurrentNode; |
| pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { |
| if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE)) { |
| continue; |
| } |
| XFA_ATTRIBUTEENUM eCurPagePosition = |
| pCurrentNode->GetEnum(XFA_ATTRIBUTE_PagePosition); |
| if (ePreferredPosition == XFA_ATTRIBUTEENUM_Last) { |
| if (eCurPagePosition != ePreferredPosition) { |
| continue; |
| } |
| if (m_ePageSetMode == XFA_ATTRIBUTEENUM_SimplexPaginated || |
| pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) == |
| XFA_ATTRIBUTEENUM_Any) { |
| pPreferredPageArea = pCurrentNode; |
| break; |
| } |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| AddPageAreaLayoutItem(pNewRecord, pCurrentNode); |
| AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass( |
| XFA_Element::ContentArea)); |
| pPreferredPageArea = pCurrentNode; |
| return FALSE; |
| } else if (ePreferredPosition == XFA_ATTRIBUTEENUM_Only) { |
| if (eCurPagePosition != ePreferredPosition) { |
| continue; |
| } |
| if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated || |
| pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) == |
| XFA_ATTRIBUTEENUM_Any) { |
| pPreferredPageArea = pCurrentNode; |
| break; |
| } |
| return FALSE; |
| } |
| if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) { |
| if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) { |
| if (pTargetPageArea == pCurrentNode) { |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| AddPageAreaLayoutItem(pNewRecord, pCurrentNode); |
| pTargetPageArea = nullptr; |
| } |
| continue; |
| } |
| if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest && |
| eCurPagePosition == XFA_ATTRIBUTEENUM_Any) || |
| eCurPagePosition == ePreferredPosition) { |
| pPreferredPageArea = pCurrentNode; |
| break; |
| } else if (eCurPagePosition == eFallbackPosition && |
| !pFallbackPageArea) { |
| pFallbackPageArea = pCurrentNode; |
| } |
| } else if (pTargetPageArea && |
| !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) { |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| AddPageAreaLayoutItem(pNewRecord, pCurrentNode); |
| AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass( |
| XFA_Element::ContentArea)); |
| } |
| } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { |
| if (FindPageAreaFromPageSet_SimplexDuplex( |
| pCurrentNode, nullptr, pTargetPageArea, pTargetContentArea, |
| bNewPage, bQuery, ePreferredPosition)) { |
| break; |
| } |
| } |
| } |
| CXFA_Node* pCurPageArea = nullptr; |
| if (pPreferredPageArea) { |
| pCurPageArea = pPreferredPageArea; |
| } else if (pFallbackPageArea) { |
| pCurPageArea = pFallbackPageArea; |
| } |
| if (!pCurPageArea) { |
| return FALSE; |
| } |
| if (!bQuery) { |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| AddPageAreaLayoutItem(pNewRecord, pCurPageArea); |
| if (!pTargetContentArea) { |
| pTargetContentArea = |
| pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea); |
| } |
| AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); |
| } |
| m_pCurPageArea = pCurPageArea; |
| return TRUE; |
| } |
| FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea, |
| FX_BOOL bLastMatch) { |
| if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated) { |
| return TRUE; |
| } |
| XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any; |
| pPageArea->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven); |
| if (eOddOrEven != XFA_ATTRIBUTEENUM_Any) { |
| int32_t iPageCount = GetPageCount(); |
| if (bLastMatch) { |
| return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 1 |
| : iPageCount % 2 == 0; |
| } |
| return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 0 |
| : iPageCount % 2 == 1; |
| } |
| return TRUE; |
| } |
| CXFA_Node* CXFA_LayoutPageMgr::GetNextAvailPageArea( |
| CXFA_Node* pTargetPageArea, |
| CXFA_Node* pTargetContentArea, |
| FX_BOOL bNewPage, |
| FX_BOOL bQuery) { |
| if (!m_pCurPageArea) { |
| FindPageAreaFromPageSet(m_pTemplatePageSetRoot, nullptr, pTargetPageArea, |
| pTargetContentArea, bNewPage, bQuery); |
| ASSERT(m_pCurPageArea); |
| return m_pCurPageArea; |
| } |
| if (!pTargetPageArea || pTargetPageArea == m_pCurPageArea) { |
| if (!bNewPage && GetNextContentArea(pTargetContentArea)) { |
| return m_pCurPageArea; |
| } |
| if (IsPageSetRootOrderedOccurrence()) { |
| int32_t iMax = -1; |
| CXFA_Node* pOccurNode = |
| m_pCurPageArea->GetFirstChildByClass(XFA_Element::Occur); |
| if (pOccurNode) { |
| pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE); |
| } |
| if ((iMax < 0 || m_nCurPageCount < iMax)) { |
| if (!bQuery) { |
| CXFA_ContainerRecord* pNewRecord = |
| CreateContainerRecord(m_pCurPageArea); |
| AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea); |
| if (!pTargetContentArea) { |
| pTargetContentArea = |
| m_pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea); |
| } |
| AddContentAreaLayoutItem(pNewRecord, pTargetContentArea); |
| } |
| m_nCurPageCount++; |
| return m_pCurPageArea; |
| } |
| } |
| } |
| if (!bQuery && IsPageSetRootOrderedOccurrence()) { |
| CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE); |
| } |
| if (FindPageAreaFromPageSet(m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent), |
| m_pCurPageArea, pTargetPageArea, |
| pTargetContentArea, bNewPage, bQuery)) { |
| return m_pCurPageArea; |
| } |
| CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent); |
| while (TRUE) { |
| if (FindPageAreaFromPageSet(pPageSet, nullptr, pTargetPageArea, |
| pTargetContentArea, bNewPage, bQuery)) { |
| return m_pCurPageArea; |
| } |
| if (!bQuery && IsPageSetRootOrderedOccurrence()) { |
| CreateMinPageSetRecord(pPageSet); |
| } |
| if (FindPageAreaFromPageSet(nullptr, pPageSet, pTargetPageArea, |
| pTargetContentArea, bNewPage, bQuery)) { |
| return m_pCurPageArea; |
| } |
| if (pPageSet == m_pTemplatePageSetRoot) { |
| break; |
| } |
| pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent); |
| } |
| return nullptr; |
| } |
| |
| FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) { |
| CXFA_Node* pCurContentNode = |
| GetCurrentContainerRecord()->pCurContentArea->m_pFormNode; |
| if (!pContentArea) { |
| pContentArea = |
| pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea); |
| if (!pContentArea) { |
| return FALSE; |
| } |
| } else { |
| if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea) { |
| return FALSE; |
| } |
| CXFA_ContainerLayoutItem* pContentAreaLayout = nullptr; |
| if (!CheckContentAreaNotUsed(GetCurrentContainerRecord()->pCurPageArea, |
| pContentArea, pContentAreaLayout)) { |
| return FALSE; |
| } |
| if (pContentAreaLayout) { |
| if (pContentAreaLayout->m_pFormNode != pCurContentNode) { |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| pNewRecord->pCurContentArea = pContentAreaLayout; |
| return TRUE; |
| } else { |
| return FALSE; |
| } |
| } |
| } |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| AddContentAreaLayoutItem(pNewRecord, pContentArea); |
| return TRUE; |
| } |
| void CXFA_LayoutPageMgr::InitPageSetMap() { |
| if (!IsPageSetRootOrderedOccurrence()) { |
| return; |
| } |
| CXFA_NodeIterator sIterator(m_pTemplatePageSetRoot); |
| for (CXFA_Node* pPageSetNode = sIterator.GetCurrent(); pPageSetNode; |
| pPageSetNode = sIterator.MoveToNext()) { |
| if (pPageSetNode->GetElementType() == XFA_Element::PageSet) { |
| XFA_ATTRIBUTEENUM eRelation = |
| pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation); |
| if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence) { |
| m_pPageSetMap.SetAt(pPageSetNode, 0); |
| } |
| } |
| } |
| } |
| int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea, |
| FX_BOOL bTargetPageArea, |
| FX_BOOL bCreateLast) { |
| if (!pPageArea) { |
| return 0; |
| } |
| CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_Element::Occur); |
| int32_t iMin = 0; |
| if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) || |
| bTargetPageArea) { |
| CXFA_Node* pContentArea = |
| pPageArea->GetFirstChildByClass(XFA_Element::ContentArea); |
| if (iMin < 1 && bTargetPageArea && !pContentArea) { |
| iMin = 1; |
| } |
| int32_t i = 0; |
| if (bCreateLast) { |
| i = m_nCurPageCount; |
| } |
| for (; i < iMin; i++) { |
| CXFA_ContainerRecord* pNewRecord = CreateContainerRecord(); |
| AddPageAreaLayoutItem(pNewRecord, pPageArea); |
| AddContentAreaLayoutItem(pNewRecord, pContentArea); |
| } |
| } |
| return iMin; |
| } |
| void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet, |
| FX_BOOL bCreateAll) { |
| if (!pPageSet) { |
| return; |
| } |
| int32_t iCurSetCount = 0; |
| if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount)) { |
| return; |
| } |
| if (bCreateAll) { |
| iCurSetCount = 0; |
| } |
| CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur); |
| int32_t iMin = 0; |
| if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) { |
| if (iCurSetCount < iMin) { |
| for (int32_t i = 0; i < iMin - iCurSetCount; i++) { |
| for (CXFA_Node* pCurrentPageNode = |
| pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pCurrentPageNode; pCurrentPageNode = pCurrentPageNode->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (pCurrentPageNode->GetElementType() == XFA_Element::PageArea) { |
| CreateMinPageRecord(pCurrentPageNode, FALSE); |
| } else if (pCurrentPageNode->GetElementType() == |
| XFA_Element::PageSet) { |
| CreateMinPageSetRecord(pCurrentPageNode, TRUE); |
| } |
| } |
| } |
| m_pPageSetMap.SetAt(pPageSet, iMin); |
| } |
| } |
| } |
| void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) { |
| if (!pRecordNode) { |
| return; |
| } |
| for (CXFA_Node* pCurrentNode = |
| pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling); |
| pCurrentNode; |
| pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pCurrentNode->GetElementType() == XFA_Element::PageArea) { |
| CreateMinPageRecord(pCurrentNode, FALSE); |
| } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) { |
| CreateMinPageSetRecord(pCurrentNode, TRUE); |
| } |
| } |
| } |
| void CXFA_LayoutPageMgr::ProcessLastPageSet() { |
| CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE); |
| CreateNextMinRecord(m_pCurPageArea); |
| CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent); |
| while (TRUE) { |
| CreateMinPageSetRecord(pPageSet); |
| if (pPageSet == m_pTemplatePageSetRoot) { |
| break; |
| } |
| CreateNextMinRecord(pPageSet); |
| pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent); |
| } |
| } |
| FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) { |
| CXFA_Node* pCurContentNode = |
| GetCurrentContainerRecord()->pCurContentArea->m_pFormNode; |
| if (!pCurContentNode) { |
| return FALSE; |
| } |
| pCurContentNode = |
| pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea); |
| if (pCurContentNode) { |
| FX_FLOAT fNextContentHeight = |
| pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); |
| return fNextContentHeight > fChildHeight; |
| } |
| CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode; |
| CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_Element::Occur); |
| int32_t iMax = 0; |
| if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) { |
| if (m_nCurPageCount == iMax) { |
| CXFA_Node* pSrcPage = m_pCurPageArea; |
| int32_t nSrcPageCount = m_nCurPageCount; |
| FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition(); |
| CXFA_Node* pNextPage = |
| GetNextAvailPageArea(nullptr, nullptr, FALSE, TRUE); |
| m_pCurPageArea = pSrcPage; |
| m_nCurPageCount = nSrcPageCount; |
| CXFA_ContainerRecord* pPrevRecord = |
| (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext( |
| psSrcRecord); |
| while (psSrcRecord) { |
| FX_POSITION psSaveRecord = psSrcRecord; |
| CXFA_ContainerRecord* pInsertRecord = |
| (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext( |
| psSrcRecord); |
| RemoveLayoutRecord(pInsertRecord, pPrevRecord); |
| delete pInsertRecord; |
| m_rgProposedContainerRecord.RemoveAt(psSaveRecord); |
| } |
| if (pNextPage) { |
| CXFA_Node* pContentArea = |
| pNextPage->GetFirstChildByClass(XFA_Element::ContentArea); |
| if (pContentArea) { |
| FX_FLOAT fNextContentHeight = |
| pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); |
| if (fNextContentHeight > fChildHeight) { |
| return TRUE; |
| } |
| } |
| } |
| return FALSE; |
| } |
| } |
| CXFA_Node* pContentArea = |
| pPageNode->GetFirstChildByClass(XFA_Element::ContentArea); |
| FX_FLOAT fNextContentHeight = |
| pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt); |
| if (fNextContentHeight < XFA_LAYOUT_FLOAT_PERCISION) { |
| return TRUE; |
| } |
| if (fNextContentHeight > fChildHeight) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| void CXFA_LayoutPageMgr::ClearData() { |
| ClearRecordList(); |
| } |
| void CXFA_LayoutPageMgr::ClearRecordList() { |
| if (!m_pTemplatePageSetRoot) { |
| return; |
| } |
| if (m_rgProposedContainerRecord.GetCount() > 0) { |
| FX_POSITION sPos; |
| sPos = m_rgProposedContainerRecord.GetHeadPosition(); |
| while (sPos) { |
| CXFA_ContainerRecord* pRecord = |
| (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(sPos); |
| delete pRecord; |
| } |
| m_rgProposedContainerRecord.RemoveAll(); |
| } |
| m_pCurrentContainerRecord = nullptr; |
| m_pCurPageArea = nullptr; |
| m_nCurPageCount = 0; |
| m_bCreateOverFlowPage = FALSE; |
| m_pPageSetMap.RemoveAll(); |
| } |
| CXFA_LayoutItem* CXFA_LayoutPageMgr::FindOrCreateLayoutItem( |
| CXFA_Node* pFormNode) { |
| return pFormNode->GetDocument()->GetNotify()->OnCreateLayoutItem(pFormNode); |
| } |
| |
| void CXFA_LayoutPageMgr::SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem) { |
| CXFA_LayoutItem* pNextLayoutItem; |
| CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild; |
| while (pCurLayoutItem) { |
| pNextLayoutItem = pCurLayoutItem->m_pNextSibling; |
| if (pCurLayoutItem->IsContentLayoutItem()) { |
| if (pCurLayoutItem->m_pFormNode->HasRemovedChildren()) { |
| CXFA_FFNotify* pNotify = |
| m_pTemplatePageSetRoot->GetDocument()->GetNotify(); |
| CXFA_LayoutProcessor* pDocLayout = |
| m_pTemplatePageSetRoot->GetDocument()->GetDocLayout(); |
| if (pCurLayoutItem->m_pFirstChild) { |
| SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout); |
| } |
| pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem); |
| delete pCurLayoutItem; |
| pCurLayoutItem = pNextLayoutItem; |
| continue; |
| } |
| if (pCurLayoutItem->m_pFormNode->IsLayoutGeneratedNode()) { |
| CXFA_NodeIteratorTemplate<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; |
| } else if (pCurNode->GetElementType() == XFA_Element::Overflow) { |
| return pCurNode; |
| } |
| } |
| return nullptr; |
| } |
| |
| void CXFA_LayoutPageMgr::MergePageSetContents() { |
| CXFA_Document* pDocument = m_pTemplatePageSetRoot->GetDocument(); |
| CXFA_FFNotify* pNotify = pDocument->GetNotify(); |
| CXFA_LayoutProcessor* pDocLayout = pDocument->GetDocLayout(); |
| CXFA_ContainerLayoutItem* pRootLayout = GetRootLayoutItem(); |
| { |
| for (int32_t iIndex = 0; iIndex < pDocument->m_pPendingPageSet.GetSize(); |
| iIndex++) { |
| CXFA_NodeIteratorTemplate<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 = (CXFA_ContainerLayoutItem*)pRootLayout->m_pNextSibling) { |
| CXFA_Node* pPendingPageSet = nullptr; |
| CXFA_NodeIteratorTemplate< |
| CXFA_ContainerLayoutItem, |
| CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> |
| iterator(pRootLayout); |
| CXFA_ContainerLayoutItem* pRootPageSetContainerItem = iterator.GetCurrent(); |
| ASSERT(pRootPageSetContainerItem->m_pFormNode->GetElementType() == |
| XFA_Element::PageSet); |
| if (iIndex < pDocument->m_pPendingPageSet.GetSize()) { |
| pPendingPageSet = pDocument->m_pPendingPageSet.GetAt(iIndex); |
| iIndex++; |
| } |
| if (!pPendingPageSet) { |
| if (pRootPageSetContainerItem->m_pFormNode->GetPacketID() == |
| XFA_XDPPACKET_Template) { |
| pPendingPageSet = |
| pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE); |
| } else { |
| pPendingPageSet = pRootPageSetContainerItem->m_pFormNode; |
| } |
| } |
| if (pRootPageSetContainerItem->m_pFormNode->GetUserData( |
| XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) { |
| pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY, |
| nullptr); |
| } |
| pRootPageSetContainerItem->m_pFormNode = pPendingPageSet; |
| pPendingPageSet->ClearFlag(XFA_NodeFlag_UnusedNode); |
| for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext(); |
| pContainerItem; pContainerItem = iterator.MoveToNext()) { |
| CXFA_Node* pNode = pContainerItem->m_pFormNode; |
| if (pNode->GetPacketID() != XFA_XDPPACKET_Template) { |
| continue; |
| } |
| switch (pNode->GetElementType()) { |
| case XFA_Element::PageSet: { |
| CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; |
| pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE, |
| nullptr); |
| } break; |
| case XFA_Element::PageArea: { |
| CXFA_ContainerLayoutItem* pFormLayout = pContainerItem; |
| CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode; |
| FX_BOOL bIsExistForm = TRUE; |
| for (int32_t iLevel = 0; iLevel < 3; iLevel++) { |
| pFormLayout = (CXFA_ContainerLayoutItem*)pFormLayout->m_pFirstChild; |
| if (iLevel == 2) { |
| while (pFormLayout && |
| !XFA_ItemLayoutProcessor_IsTakingSpace( |
| pFormLayout->m_pFormNode)) { |
| pFormLayout = |
| (CXFA_ContainerLayoutItem*)pFormLayout->m_pNextSibling; |
| } |
| } |
| if (!pFormLayout) { |
| bIsExistForm = FALSE; |
| break; |
| } |
| } |
| if (bIsExistForm) { |
| CXFA_Node* pNewSubform = pFormLayout->m_pFormNode; |
| if (pContainerItem->m_pOldSubform && |
| pContainerItem->m_pOldSubform != pNewSubform) { |
| CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance( |
| pDocument, pContainerItem->m_pFormNode->GetElementType(), |
| pContainerItem->m_pFormNode->GetNameHash(), pParentNode); |
| CXFA_ContainerIterator sIterator(pExistingNode); |
| for (CXFA_Node* pIter = sIterator.GetCurrent(); pIter; |
| pIter = sIterator.MoveToNext()) { |
| if (pIter->GetElementType() != XFA_Element::ContentArea) { |
| CXFA_LayoutItem* pLayoutItem = static_cast<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 = |
| (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) { |
| CXFA_NodeIteratorTemplate< |
| CXFA_ContainerLayoutItem, |
| CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> |
| iterator(pRootLayoutItem); |
| for (CXFA_ContainerLayoutItem* pContainerItem = iterator.GetCurrent(); |
| pContainerItem; pContainerItem = iterator.MoveToNext()) { |
| CXFA_Node* pNode = pContainerItem->m_pFormNode; |
| switch (pNode->GetElementType()) { |
| case XFA_Element::PageArea: |
| m_pLayoutProcessor->GetRootRootItemLayoutProcessor() |
| ->DoLayoutPageArea(pContainerItem); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| } |
| |
| void CXFA_LayoutPageMgr::SyncLayoutData() { |
| MergePageSetContents(); |
| LayoutPageSetContents(); |
| CXFA_FFNotify* pNotify = m_pTemplatePageSetRoot->GetDocument()->GetNotify(); |
| int32_t nPageIdx = -1; |
| CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem(); |
| for (; pRootLayoutItem; |
| pRootLayoutItem = |
| (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) { |
| CXFA_NodeIteratorTemplate< |
| CXFA_ContainerLayoutItem, |
| CXFA_TraverseStrategy_ContentAreaContainerLayoutItem> |
| iteratorParent(pRootLayoutItem); |
| for (CXFA_ContainerLayoutItem* pContainerItem = iteratorParent.GetCurrent(); |
| pContainerItem; pContainerItem = iteratorParent.MoveToNext()) { |
| switch (pContainerItem->m_pFormNode->GetElementType()) { |
| case XFA_Element::PageArea: { |
| nPageIdx++; |
| uint32_t dwRelevant = |
| XFA_WidgetStatus_Viewable | XFA_WidgetStatus_Printable; |
| CXFA_NodeIteratorTemplate<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 = (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling; |
| SaveLayoutItem(pRootLayoutItem); |
| delete pRootLayoutItem; |
| } |
| m_pPageSetLayoutItemRoot = nullptr; |
| } |
