diff options
Diffstat (limited to 'xfa/src/fxfa/src/app/xfa_ffdocview.cpp')
| -rw-r--r-- | xfa/src/fxfa/src/app/xfa_ffdocview.cpp | 960 |
1 files changed, 960 insertions, 0 deletions
diff --git a/xfa/src/fxfa/src/app/xfa_ffdocview.cpp b/xfa/src/fxfa/src/app/xfa_ffdocview.cpp new file mode 100644 index 0000000000..bb6a5ce2a9 --- /dev/null +++ b/xfa/src/fxfa/src/app/xfa_ffdocview.cpp @@ -0,0 +1,960 @@ +// 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 "../../../foxitlib.h"
+#include "../common/xfa_common.h"
+#include "xfa_fwladapter.h"
+#include "xfa_ffdocview.h"
+#include "xfa_ffpageview.h"
+#include "xfa_ffwidgethandler.h"
+#include "xfa_ffdoc.h"
+#include "xfa_ffwidget.h"
+#include "xfa_fffield.h"
+#include "xfa_ffpushbutton.h"
+#include "xfa_ffcheckbutton.h"
+#include "xfa_ffchoicelist.h"
+#include "xfa_ffimageedit.h"
+#include "xfa_fftextedit.h"
+#include "xfa_ffbarcode.h"
+#include "xfa_ffdraw.h"
+#include "xfa_fftext.h"
+#include "xfa_ffpath.h"
+#include "xfa_ffimage.h"
+#include "xfa_ffexclgroup.h"
+#include "xfa_ffsubform.h"
+#include "xfa_ffsignature.h"
+#include "xfa_ffapp.h"
+#include "xfa_textlayout.h"
+#include "xfa_ffwidgetacc.h"
+extern const XFA_ATTRIBUTEENUM gs_EventActivity[] = {
+ XFA_ATTRIBUTEENUM_Click,
+ XFA_ATTRIBUTEENUM_Change,
+ XFA_ATTRIBUTEENUM_DocClose,
+ XFA_ATTRIBUTEENUM_DocReady,
+ XFA_ATTRIBUTEENUM_Enter,
+ XFA_ATTRIBUTEENUM_Exit,
+ XFA_ATTRIBUTEENUM_Full,
+ XFA_ATTRIBUTEENUM_IndexChange,
+ XFA_ATTRIBUTEENUM_Initialize,
+ XFA_ATTRIBUTEENUM_MouseDown,
+ XFA_ATTRIBUTEENUM_MouseEnter,
+ XFA_ATTRIBUTEENUM_MouseExit,
+ XFA_ATTRIBUTEENUM_MouseUp,
+ XFA_ATTRIBUTEENUM_PostExecute,
+ XFA_ATTRIBUTEENUM_PostOpen,
+ XFA_ATTRIBUTEENUM_PostPrint,
+ XFA_ATTRIBUTEENUM_PostSave,
+ XFA_ATTRIBUTEENUM_PostSign,
+ XFA_ATTRIBUTEENUM_PostSubmit,
+ XFA_ATTRIBUTEENUM_PreExecute,
+ XFA_ATTRIBUTEENUM_PreOpen,
+ XFA_ATTRIBUTEENUM_PrePrint,
+ XFA_ATTRIBUTEENUM_PreSave,
+ XFA_ATTRIBUTEENUM_PreSign,
+ XFA_ATTRIBUTEENUM_PreSubmit,
+ XFA_ATTRIBUTEENUM_Ready,
+ XFA_ATTRIBUTEENUM_Unknown,
+};
+CXFA_FFDocView::CXFA_FFDocView(CXFA_FFDoc* pDoc)
+ : m_pDoc(pDoc)
+ , m_pWidgetHandler(NULL)
+ , m_pXFADocLayout(NULL)
+ , m_iStatus(XFA_DOCVIEW_LAYOUTSTATUS_None)
+ , m_iLock(0)
+ , m_bLayoutEvent(FALSE)
+ , m_pFocusAcc(NULL)
+ , m_pFocusWidget(NULL)
+ , m_pListFocusWidget(NULL)
+ , m_pOldFocusWidget(NULL)
+ , m_bInLayoutStatus(FALSE)
+{
+}
+CXFA_FFDocView::~CXFA_FFDocView()
+{
+ DestroyDocView();
+ if (m_pWidgetHandler) {
+ delete m_pWidgetHandler;
+ }
+ m_pWidgetHandler = NULL;
+}
+void CXFA_FFDocView::InitLayout(CXFA_Node* pNode)
+{
+ RunBindItems();
+ ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Initialize);
+ ExecEventActivityByDeepFirst(pNode, XFA_EVENT_IndexChange);
+}
+FX_INT32 CXFA_FFDocView::StartLayout(FX_INT32 iStartPage )
+{
+ m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Start;
+ m_pDoc->GetXFADoc()->DoProtoMerge();
+ m_pDoc->GetXFADoc()->DoDataMerge();
+ m_pXFADocLayout = GetXFALayout();
+ FX_INT32 iStatus = m_pXFADocLayout->StartLayout();
+ if (iStatus < 0) {
+ return iStatus;
+ }
+ CXFA_Node* pRootItem = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Form);
+ if (!pRootItem) {
+ return iStatus;
+ }
+ InitLayout(pRootItem);
+ InitCalculate(pRootItem);
+ InitValidate(pRootItem);
+ ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, TRUE);
+ m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Start;
+ return iStatus;
+}
+FX_INT32 CXFA_FFDocView::DoLayout(IFX_Pause *pPause )
+{
+ FX_INT32 iStatus = 100;
+ iStatus = m_pXFADocLayout->DoLayout(pPause);
+ if (iStatus != 100) {
+ return iStatus;
+ }
+ m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Doing;
+ return iStatus;
+}
+void CXFA_FFDocView::StopLayout()
+{
+ CXFA_Node* pRootItem = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Form);
+ if (!pRootItem) {
+ return;
+ }
+ CXFA_Node* pSubformNode = pRootItem->GetChild(0, XFA_ELEMENT_Subform);
+ if (!pSubformNode) {
+ return;
+ }
+ CXFA_Node* pPageSetNode = pSubformNode->GetFirstChildByClass(XFA_ELEMENT_PageSet);
+ if(!pPageSetNode) {
+ return;
+ }
+ RunCalculateWidgets();
+ RunValidate();
+ InitLayout(pPageSetNode);
+ InitCalculate(pPageSetNode);
+ InitValidate(pPageSetNode);
+ ExecEventActivityByDeepFirst(pPageSetNode, XFA_EVENT_Ready, TRUE);
+ ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready);
+ ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocReady);
+ RunCalculateWidgets();
+ RunValidate();
+ if(RunLayout()) {
+ ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready);
+ }
+ m_CalculateAccs.RemoveAll();
+ if (m_pFocusAcc && !m_pFocusWidget) {
+ SetFocusWidgetAcc(m_pFocusAcc);
+ }
+ m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_End;
+}
+FX_INT32 CXFA_FFDocView::GetLayoutStatus()
+{
+ return m_iStatus;
+}
+void CXFA_FFDocView::ShowNullTestMsg()
+{
+ FX_INT32 iCount = m_arrNullTestMsg.GetSize();
+ CXFA_FFApp* pApp = m_pDoc->GetApp();
+ IXFA_AppProvider* pAppProvider = pApp->GetAppProvider();
+ if (pAppProvider && iCount) {
+ FX_INT32 iRemain = iCount > 7 ? iCount - 7 : 0;
+ iCount -= iRemain;
+ CFX_WideString wsMsg;
+ for (FX_INT32 i = 0; i < iCount; i++) {
+ wsMsg += m_arrNullTestMsg[i] + FX_WSTRC(L"\n");
+ }
+ if (iRemain > 0) {
+ CFX_WideString wsLimit;
+ pAppProvider->LoadString(XFA_IDS_ValidateLimit, wsLimit);
+ if (!wsLimit.IsEmpty()) {
+ CFX_WideString wsTemp;
+ wsTemp.Format((FX_LPCWSTR)wsLimit, iRemain);
+ wsMsg += FX_WSTRC(L"\n") + wsTemp;
+ }
+ }
+ CFX_WideString wsTitle;
+ pAppProvider->LoadString(XFA_IDS_AppName, wsTitle);
+ pAppProvider->MsgBox(wsMsg, wsTitle, XFA_MBICON_Status, XFA_MB_OK);
+ }
+ m_arrNullTestMsg.RemoveAll();
+}
+void CXFA_FFDocView::UpdateDocView()
+{
+ if (IsUpdateLocked()) {
+ return;
+ }
+ LockUpdate();
+ FX_INT32 iNewAdds = m_NewAddedNodes.GetSize();
+ for (FX_INT32 i = 0; i < iNewAdds; i++) {
+ CXFA_Node* pNode = (CXFA_Node*)m_NewAddedNodes[i];
+ InitCalculate(pNode);
+ InitValidate(pNode);
+ ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Ready, TRUE);
+ }
+ m_NewAddedNodes.RemoveAll();
+ this->RunSubformIndexChange();
+ this->RunCalculateWidgets();
+ this->RunValidate();
+ ShowNullTestMsg();
+ m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Next;
+ if (RunLayout() && m_bLayoutEvent) {
+ RunEventLayoutReady();
+ }
+ m_bLayoutEvent = FALSE;
+ m_CalculateAccs.RemoveAll();
+ this->RunInvalidate();
+ UnlockUpdate();
+}
+FX_INT32 CXFA_FFDocView::CountPageViews()
+{
+ if (!m_pXFADocLayout) {
+ return 0;
+ }
+ return m_pXFADocLayout->CountPages();
+}
+IXFA_PageView* CXFA_FFDocView::GetPageView(FX_INT32 nIndex)
+{
+ if (!m_pXFADocLayout) {
+ return NULL;
+ }
+ return (CXFA_FFPageView*)m_pXFADocLayout->GetPage(nIndex);
+}
+XFA_HWIDGET CXFA_FFDocView::GetWidgetByName(FX_WSTR wsName)
+{
+ return (XFA_HWIDGET)GetWidgetByName(wsName, NULL);
+}
+CXFA_WidgetAcc* CXFA_FFDocView::GetWidgetAccByName(FX_WSTR wsName)
+{
+ return GetWidgetAccByName(wsName, NULL);
+}
+IXFA_DocLayout* CXFA_FFDocView::GetXFALayout() const
+{
+ return m_pDoc->GetXFADoc()->GetDocLayout();
+}
+FX_BOOL CXFA_FFDocView::ResetSingleWidgetAccData(CXFA_WidgetAcc* pWidgetAcc)
+{
+ CXFA_Node* pNode = pWidgetAcc->GetNode();
+ XFA_ELEMENT eType = pNode->GetClassID();
+ if (eType != XFA_ELEMENT_Field && eType != XFA_ELEMENT_ExclGroup) {
+ return FALSE;
+ }
+ FX_BOOL bNotify = IsStaticNotify();
+ pWidgetAcc->ResetData();
+ pWidgetAcc->UpdateUIDisplay();
+ if (bNotify) {
+ pWidgetAcc->NotifyEvent(XFA_WIDGETEVENT_PostContentChanged, NULL, NULL, NULL);
+ }
+ if (CXFA_Validate validate = pWidgetAcc->GetValidate()) {
+ AddValidateWidget(pWidgetAcc);
+ ((CXFA_Node*)validate)->SetFlag(XFA_NODEFLAG_NeedsInitApp, TRUE, FALSE);
+ }
+ return TRUE;
+}
+void CXFA_FFDocView::ResetWidgetData(CXFA_WidgetAcc* pWidgetAcc )
+{
+ m_bLayoutEvent = TRUE;
+ FX_BOOL bChanged = FALSE;
+ CXFA_Node* pFormNode = NULL;
+ if (pWidgetAcc) {
+ bChanged = ResetSingleWidgetAccData(pWidgetAcc);
+ pFormNode = pWidgetAcc->GetNode();
+ } else {
+ pFormNode = GetRootSubform();
+ }
+ if (!pFormNode) {
+ return;
+ }
+ if (pFormNode->GetClassID() != XFA_ELEMENT_Field && pFormNode->GetClassID() != XFA_ELEMENT_ExclGroup) {
+ CXFA_WidgetAccIterator Iterator(this, pFormNode);
+ while (CXFA_WidgetAcc* pAcc = Iterator.MoveToNext()) {
+ bChanged |= ResetSingleWidgetAccData(pAcc);
+ if (pAcc->GetNode()->GetClassID() == XFA_ELEMENT_ExclGroup) {
+ Iterator.SkipTree();
+ }
+ }
+ }
+ if (bChanged) {
+ m_pDoc->GetDocProvider()->SetChangeMark((XFA_HDOC)m_pDoc);
+ }
+}
+FX_INT32 CXFA_FFDocView::ProcessWidgetEvent(CXFA_EventParam* pParam, CXFA_WidgetAcc* pWidgetAcc )
+{
+ if (pParam == NULL) {
+ return XFA_EVENTERROR_Error;
+ }
+ if (pParam->m_eType == XFA_EVENT_Validate) {
+ CFX_WideString wsValidateStr = FX_WSTRC(L"preSubmit");
+ CXFA_Node* pConfigItem = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Config);
+ if (pConfigItem) {
+ CXFA_Node* pValidateNode = NULL;
+ CXFA_Node* pAcrobatNode = pConfigItem->GetChild(0, XFA_ELEMENT_Acrobat);
+ pValidateNode = pAcrobatNode ? pAcrobatNode->GetChild(0, XFA_ELEMENT_Validate) : NULL;
+ if (!pValidateNode) {
+ CXFA_Node* pPresentNode = pConfigItem->GetChild(0, XFA_ELEMENT_Present);
+ pValidateNode = pPresentNode ? pPresentNode->GetChild(0, XFA_ELEMENT_Validate) : NULL;
+ }
+ if (pValidateNode) {
+ wsValidateStr = pValidateNode->GetContent();
+ }
+ }
+ FX_BOOL bValidate = FALSE;
+ switch (pParam->m_iValidateActivities) {
+ case XFA_VALIDATE_preSubmit:
+ bValidate = wsValidateStr.Find(L"preSubmit") != -1;
+ break;
+ case XFA_VALIDATE_prePrint:
+ bValidate = wsValidateStr.Find(L"prePrint") != -1;
+ break;
+ case XFA_VALIDATE_preExecute:
+ bValidate = wsValidateStr.Find(L"preExecute") != -1;
+ break;
+ case XFA_VALIDATE_preSave:
+ bValidate = wsValidateStr.Find(L"preSave") != -1;
+ break;
+ }
+ if (!bValidate) {
+ return XFA_EVENTERROR_Sucess;
+ }
+ }
+ CXFA_Node* pNode = pWidgetAcc ? pWidgetAcc->GetNode() : NULL;
+ if (!pNode) {
+ CXFA_Node* pRootItem = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Form);
+ if (!pRootItem) {
+ return XFA_EVENTERROR_Error;
+ }
+ pNode = pRootItem->GetChild(0, XFA_ELEMENT_Subform);
+ }
+ ExecEventActivityByDeepFirst(pNode, pParam->m_eType, pParam->m_bIsFormReady);
+ return XFA_EVENTERROR_Sucess;
+}
+IXFA_WidgetHandler* CXFA_FFDocView::GetWidgetHandler()
+{
+ if (!m_pWidgetHandler) {
+ m_pWidgetHandler = FX_NEW CXFA_FFWidgetHandler(this);
+ }
+ return m_pWidgetHandler;
+}
+IXFA_WidgetIterator* CXFA_FFDocView::CreateWidgetIterator()
+{
+ CXFA_Node* pFormRoot = GetRootSubform();
+ if (!pFormRoot) {
+ return NULL;
+ }
+ return FX_NEW CXFA_FFDocWidgetIterator(this, pFormRoot);
+}
+IXFA_WidgetAccIterator* CXFA_FFDocView::CreateWidgetAccIterator(XFA_WIDGETORDER eOrder )
+{
+ CXFA_Node* pFormRoot = GetRootSubform();
+ if (!pFormRoot) {
+ return NULL;
+ }
+ return FX_NEW CXFA_WidgetAccIterator(this, pFormRoot);
+}
+XFA_HWIDGET CXFA_FFDocView::GetFocusWidget()
+{
+ return (XFA_HWIDGET)m_pFocusWidget;
+}
+void CXFA_FFDocView::KillFocus()
+{
+ if (m_pFocusWidget && (m_pFocusWidget->GetStatus() & XFA_WIDGETSTATUS_Focused)) {
+ (m_pFocusWidget)->OnKillFocus(NULL);
+ }
+ m_pFocusAcc = NULL;
+ m_pFocusWidget = NULL;
+ m_pOldFocusWidget = NULL;
+}
+FX_BOOL CXFA_FFDocView::SetFocus(XFA_HWIDGET hWidget)
+{
+ CXFA_FFWidget* pNewFocus = (CXFA_FFWidget*)hWidget;
+ if (m_pOldFocusWidget == pNewFocus) {
+ return FALSE;
+ }
+ CXFA_FFWidget* pOldFocus = m_pOldFocusWidget;
+ m_pOldFocusWidget = pNewFocus;
+ if (pOldFocus) {
+ if (m_pFocusWidget != m_pOldFocusWidget && (pOldFocus->GetStatus() & XFA_WIDGETSTATUS_Focused)) {
+ m_pFocusWidget = pOldFocus;
+ pOldFocus->OnKillFocus(pNewFocus);
+ } else if ((pOldFocus->GetStatus() & XFA_WIDGETSTATUS_Visible)) {
+ if (!pOldFocus->IsLoaded()) {
+ pOldFocus->LoadWidget();
+ }
+ pOldFocus->OnSetFocus(m_pFocusWidget);
+ m_pFocusWidget = pOldFocus;
+ pOldFocus->OnKillFocus(pNewFocus);
+ }
+ }
+ if (m_pFocusWidget == m_pOldFocusWidget) {
+ return FALSE;
+ }
+ pNewFocus = m_pOldFocusWidget;
+ if (m_pListFocusWidget && pNewFocus == m_pListFocusWidget) {
+ m_pFocusAcc = NULL;
+ m_pFocusWidget = NULL;
+ m_pListFocusWidget = NULL;
+ m_pOldFocusWidget = NULL;
+ return FALSE;
+ }
+ if (pNewFocus && (pNewFocus->GetStatus() & XFA_WIDGETSTATUS_Visible)) {
+ if (!pNewFocus->IsLoaded()) {
+ pNewFocus->LoadWidget();
+ }
+ pNewFocus->OnSetFocus(m_pFocusWidget);
+ }
+ m_pFocusAcc = pNewFocus ? pNewFocus->GetDataAcc() : NULL;
+ m_pFocusWidget = pNewFocus;
+ m_pOldFocusWidget = m_pFocusWidget;
+ return TRUE;
+}
+CXFA_WidgetAcc* CXFA_FFDocView::GetFocusWidgetAcc()
+{
+ return m_pFocusAcc;
+}
+void CXFA_FFDocView::SetFocusWidgetAcc(CXFA_WidgetAcc* pWidgetAcc)
+{
+ CXFA_FFWidget* pNewFocus = pWidgetAcc ? pWidgetAcc->GetNextWidget(NULL) : NULL;
+ if (SetFocus((XFA_HWIDGET)pNewFocus)) {
+ m_pFocusAcc = pWidgetAcc;
+ if (m_iStatus >= XFA_DOCVIEW_LAYOUTSTATUS_End) {
+ m_pDoc->GetDocProvider()->SetFocusWidget((XFA_HDOC)m_pDoc, (XFA_HWIDGET)m_pFocusWidget);
+ }
+ }
+}
+void CXFA_FFDocView::DeleteLayoutItem(CXFA_FFWidget* pWidget)
+{
+ if (m_pFocusAcc == pWidget->GetDataAcc()) {
+ m_pFocusAcc = NULL;
+ m_pFocusWidget = NULL;
+ m_pOldFocusWidget = NULL;
+ }
+}
+static FX_INT32 XFA_ProcessEvent(CXFA_FFDocView* pDocView, CXFA_WidgetAcc* pWidgetAcc, CXFA_EventParam* pParam)
+{
+ if (!pParam || pParam->m_eType == XFA_EVENT_Unknown) {
+ return XFA_EVENTERROR_NotExist;
+ }
+ if (!pWidgetAcc || pWidgetAcc->GetClassID() == XFA_ELEMENT_Draw) {
+ return XFA_EVENTERROR_NotExist;
+ }
+ switch (pParam->m_eType) {
+ case XFA_EVENT_Calculate:
+ return pWidgetAcc->ProcessCalculate();
+ case XFA_EVENT_Validate:
+ if (((CXFA_FFDoc*)pDocView->GetDoc())->GetDocProvider()->IsValidationsEnabled(pDocView->GetDoc())) {
+ return pWidgetAcc->ProcessValidate(0x01);
+ }
+ return XFA_EVENTERROR_Disabled;
+ case XFA_EVENT_InitCalculate: {
+ CXFA_Calculate calc = pWidgetAcc->GetCalculate();
+ if (!calc) {
+ return XFA_EVENTERROR_NotExist;
+ }
+ if (pWidgetAcc->GetNode()->HasFlag(XFA_NODEFLAG_UserInteractive)) {
+ return XFA_EVENTERROR_Disabled;
+ }
+ CXFA_Script script = calc.GetScript();
+ return pWidgetAcc->ExecuteScript(script, pParam);
+ }
+ default:
+ break;
+ }
+ FX_INT32 iRet = pWidgetAcc->ProcessEvent(gs_EventActivity[pParam->m_eType], pParam);
+ return iRet;
+}
+FX_INT32 CXFA_FFDocView::ExecEventActivityByDeepFirst(CXFA_Node* pFormNode, XFA_EVENTTYPE eEventType, FX_BOOL bIsFormReady, FX_BOOL bRecursive, CXFA_Node* pExclude)
+{
+ FX_INT32 iRet = XFA_EVENTERROR_NotExist;
+ if (pFormNode == pExclude) {
+ return iRet;
+ }
+ XFA_ELEMENT elementType = pFormNode->GetClassID();
+ if (elementType == XFA_ELEMENT_Field) {
+ if (eEventType == XFA_EVENT_IndexChange) {
+ return iRet;
+ }
+ CXFA_WidgetAcc* pWidgetAcc = (CXFA_WidgetAcc*)pFormNode->GetWidgetData();
+ if (pWidgetAcc == NULL) {
+ return iRet;
+ }
+ CXFA_EventParam eParam;
+ eParam.m_eType = eEventType;
+ eParam.m_pTarget = pWidgetAcc;
+ eParam.m_bIsFormReady = bIsFormReady;
+ return XFA_ProcessEvent(this, pWidgetAcc, &eParam);
+ }
+ if (bRecursive) {
+ for(CXFA_Node* pNode = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild, XFA_OBJECTTYPE_ContainerNode); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling, XFA_OBJECTTYPE_ContainerNode)) {
+ elementType = pNode->GetClassID();
+ if (elementType != XFA_ELEMENT_Variables && elementType != XFA_ELEMENT_Draw) {
+ iRet |= ExecEventActivityByDeepFirst(pNode, eEventType, bIsFormReady, bRecursive, pExclude);
+ }
+ }
+ }
+ CXFA_WidgetAcc* pWidgetAcc = (CXFA_WidgetAcc*)pFormNode->GetWidgetData();
+ if (pWidgetAcc == NULL) {
+ return iRet;
+ }
+ CXFA_EventParam eParam;
+ eParam.m_eType = eEventType;
+ eParam.m_pTarget = pWidgetAcc;
+ eParam.m_bIsFormReady = bIsFormReady;
+ iRet |= XFA_ProcessEvent(this, pWidgetAcc, &eParam);
+ return iRet;
+}
+CXFA_FFWidget* CXFA_FFDocView::GetWidgetByName(FX_WSTR wsName, CXFA_FFWidget* pRefWidget )
+{
+ CXFA_WidgetAcc* pRefAcc = pRefWidget ? pRefWidget->GetDataAcc() : NULL;
+ if (CXFA_WidgetAcc* pAcc = GetWidgetAccByName(wsName, pRefAcc)) {
+ return pAcc->GetNextWidget(NULL);
+ }
+ return NULL;
+}
+CXFA_WidgetAcc* CXFA_FFDocView::GetWidgetAccByName(FX_WSTR wsName, CXFA_WidgetAcc* pRefWidgetAcc )
+{
+ CFX_WideString wsExpression;
+ FX_DWORD dwStyle = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
+ IXFA_ScriptContext* pScriptContext = m_pDoc->GetXFADoc()->GetScriptContext();
+ if (!pScriptContext) {
+ return NULL;
+ }
+ CXFA_Node* refNode = NULL;
+ if(pRefWidgetAcc != NULL) {
+ refNode = pRefWidgetAcc->GetNode();
+ wsExpression = wsName;
+ } else {
+ wsExpression = L"$form." + wsName;
+ }
+ XFA_RESOLVENODE_RS resoveNodeRS;
+ FX_INT32 iRet = pScriptContext->ResolveObjects(refNode, wsExpression, resoveNodeRS, dwStyle);
+ if (iRet < 1) {
+ return NULL;
+ }
+ if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
+ CXFA_Object* pNode = resoveNodeRS.nodes[0];
+ if(pNode->IsNode()) {
+ return (CXFA_WidgetAcc*)((CXFA_Node*)pNode)->GetWidgetData();
+ }
+ }
+ return NULL;
+}
+void CXFA_FFDocView::OnPageEvent(IXFA_LayoutPage *pSender, XFA_PAGEEVENT eEvent, FX_INT32 iPageIndex)
+{
+ FX_BOOL bNofify = m_iStatus >= XFA_DOCVIEW_LAYOUTSTATUS_End;
+ if (eEvent == XFA_PAGEEVENT_PageRemoved) {
+ if (bNofify) {
+ m_pDoc->GetDocProvider()->PageViewEvent((CXFA_FFPageView*)pSender, XFA_PAGEVIEWEVENT_PostRemoved);
+ }
+ } else if (eEvent == XFA_PAGEEVENT_PageAdded) {
+ if (bNofify) {
+ m_pDoc->GetDocProvider()->PageViewEvent((CXFA_FFPageView*)pSender, XFA_PAGEVIEWEVENT_PostAdded);
+ ((CXFA_FFPageView*)pSender)->LoadPageView();
+ }
+ }
+}
+void CXFA_FFDocView::LockUpdate()
+{
+ m_iLock++;
+}
+void CXFA_FFDocView::UnlockUpdate()
+{
+ m_iLock--;
+}
+FX_BOOL CXFA_FFDocView::IsUpdateLocked()
+{
+ return m_iLock;
+}
+void CXFA_FFDocView::ClearInvalidateList()
+{
+ FX_POSITION ps = m_mapPageInvalidate.GetStartPosition();
+ while (ps) {
+ void* pPageView = NULL;
+ CFX_RectF* pRect = NULL;
+ m_mapPageInvalidate.GetNextAssoc(ps, pPageView, (void*&)pRect);
+ delete pRect;
+ }
+ m_mapPageInvalidate.RemoveAll();
+}
+void CXFA_FFDocView::AddInvalidateRect(CXFA_FFWidget* pWidget, const CFX_RectF &rtInvalidate)
+{
+ AddInvalidateRect(pWidget->GetPageView(), rtInvalidate);
+}
+void CXFA_FFDocView::AddInvalidateRect(IXFA_PageView* pPageView, const CFX_RectF &rtInvalidate)
+{
+ CFX_RectF* pRect = (CFX_RectF*)m_mapPageInvalidate.GetValueAt(pPageView);
+ if (!pRect) {
+ pRect = FX_NEW CFX_RectF;
+ pRect->Set(rtInvalidate.left, rtInvalidate.top, rtInvalidate.width, rtInvalidate.height);
+ m_mapPageInvalidate.SetAt(pPageView, pRect);
+ } else {
+ pRect->Union(rtInvalidate);
+ }
+}
+void CXFA_FFDocView::RunInvalidate()
+{
+ FX_POSITION ps = m_mapPageInvalidate.GetStartPosition();
+ while (ps) {
+ IXFA_PageView* pPageView = NULL;
+ CFX_RectF* pRect = NULL;
+ m_mapPageInvalidate.GetNextAssoc(ps, (void*&)pPageView, (void*&)pRect);
+ m_pDoc->GetDocProvider()->InvalidateRect(pPageView, *pRect);
+ delete pRect;
+ }
+ m_mapPageInvalidate.RemoveAll();
+}
+FX_BOOL CXFA_FFDocView::RunLayout()
+{
+ LockUpdate();
+ m_bInLayoutStatus = TRUE;
+ if (!m_pXFADocLayout->IncrementLayout() && m_pXFADocLayout->StartLayout() < 100) {
+ m_pXFADocLayout->DoLayout();
+ UnlockUpdate();
+ m_bInLayoutStatus = FALSE;
+ return TRUE;
+ }
+ m_bInLayoutStatus = FALSE;
+ UnlockUpdate();
+ return FALSE;
+}
+void CXFA_FFDocView::RunSubformIndexChange()
+{
+ FX_INT32 iSubforms = m_IndexChangedSubforms.GetSize();
+ for (FX_INT32 i = 0; i < iSubforms; i++) {
+ CXFA_Node* pSubformNode = (CXFA_Node*)m_IndexChangedSubforms[i];
+ CXFA_WidgetAcc* pWidgetAcc = (CXFA_WidgetAcc*)pSubformNode->GetWidgetData();
+ if (!pWidgetAcc) {
+ continue;
+ }
+ CXFA_EventParam eParam;
+ eParam.m_eType = XFA_EVENT_IndexChange;
+ eParam.m_pTarget = pWidgetAcc;
+ pWidgetAcc->ProcessEvent(XFA_ATTRIBUTEENUM_IndexChange, &eParam);
+ }
+ m_IndexChangedSubforms.RemoveAll();
+}
+void CXFA_FFDocView::AddNewFormNode(CXFA_Node* pNode)
+{
+ m_NewAddedNodes.Add(pNode);
+ this->InitLayout(pNode);
+}
+void CXFA_FFDocView::AddIndexChangedSubform(CXFA_Node* pNode)
+{
+ FXSYS_assert(pNode->GetClassID() == XFA_ELEMENT_Subform );
+ m_IndexChangedSubforms.Add(pNode);
+}
+void CXFA_FFDocView::RunDocClose()
+{
+ CXFA_Node* pRootItem = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Form);
+ if (!pRootItem) {
+ return;
+ }
+ ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocClose);
+}
+void CXFA_FFDocView::DestroyDocView()
+{
+ ClearInvalidateList();
+ m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_None;
+ m_iLock = 0;
+ m_ValidateAccs.RemoveAll();
+ m_bindItems.RemoveAll();
+ m_CalculateAccs.RemoveAll();
+}
+FX_BOOL CXFA_FFDocView::IsStaticNotify()
+{
+ return m_pDoc->GetDocType() == XFA_DOCTYPE_Static;
+}
+void CXFA_FFDocView::AddCalculateWidgetAcc(CXFA_WidgetAcc* pWidgetAcc)
+{
+ FX_INT32 iAccs = m_CalculateAccs.GetSize();
+ CXFA_WidgetAcc* pCurrentAcc = (iAccs < 1) ? (CXFA_WidgetAcc*)NULL : (CXFA_WidgetAcc*)m_CalculateAccs[iAccs - 1];
+ if (pCurrentAcc != pWidgetAcc) {
+ m_CalculateAccs.Add(pWidgetAcc);
+ }
+}
+void CXFA_FFDocView::AddCalculateNodeNotify(CXFA_Node* pNodeChange)
+{
+ CXFA_CalcData* pGlobalData = (CXFA_CalcData*)pNodeChange->GetUserData(XFA_CalcData);
+ FX_INT32 iCount = pGlobalData ? pGlobalData->m_Globals.GetSize() : 0;
+ for (FX_INT32 i = 0; i < iCount; i++) {
+ CXFA_WidgetAcc* pResultAcc = (CXFA_WidgetAcc*)pGlobalData->m_Globals[i];
+ if (pResultAcc->GetNode()->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+ continue;
+ }
+ FX_INT32 iAccs = m_CalculateAccs.GetSize();
+ CXFA_WidgetAcc* pCurrentAcc = (iAccs < 1) ? (CXFA_WidgetAcc*)NULL : (CXFA_WidgetAcc*)m_CalculateAccs[iAccs - 1];
+ if (pCurrentAcc != pResultAcc) {
+ m_CalculateAccs.Add(pResultAcc);
+ }
+ }
+}
+void CXFA_FFDocView::RunCalculateRecursive(FX_INT32& iIndex)
+{
+ while (iIndex < m_CalculateAccs.GetSize()) {
+ CXFA_WidgetAcc* pCurAcc = (CXFA_WidgetAcc*)m_CalculateAccs[iIndex];
+ AddCalculateNodeNotify(pCurAcc->GetNode());
+ FX_INT32 iRefCount = (FX_INT32)(FX_UINTPTR)pCurAcc->GetNode()->GetUserData(XFA_CalcRefCount);
+ iRefCount++;
+ pCurAcc->GetNode()->SetUserData(XFA_CalcRefCount, (FX_LPVOID)(FX_UINTPTR)iRefCount);
+ if (iRefCount > 11) {
+ break;
+ }
+ if ((pCurAcc->ProcessCalculate()) == XFA_EVENTERROR_Sucess) {
+ AddValidateWidget(pCurAcc);
+ }
+ iIndex++;
+ RunCalculateRecursive(iIndex);
+ }
+}
+FX_INT32 CXFA_FFDocView::RunCalculateWidgets()
+{
+ if (!m_pDoc->GetDocProvider()->IsCalculationsEnabled((XFA_HDOC)m_pDoc)) {
+ return XFA_EVENTERROR_Disabled;
+ }
+ FX_INT32 iCounts = m_CalculateAccs.GetSize();
+ FX_INT32 iIndex = 0;
+ if (iCounts > 0) {
+ RunCalculateRecursive(iIndex);
+ }
+ for (FX_INT32 i = 0; i < m_CalculateAccs.GetSize(); i++) {
+ CXFA_WidgetAcc* pCurAcc = (CXFA_WidgetAcc*)m_CalculateAccs[i];
+ pCurAcc->GetNode()->SetUserData(XFA_CalcRefCount, (FX_LPVOID)(FX_UINTPTR)0);
+ }
+ m_CalculateAccs.RemoveAll();
+ return XFA_EVENTERROR_Sucess;
+}
+void CXFA_FFDocView::AddValidateWidget(CXFA_WidgetAcc* pWidget)
+{
+ if (m_ValidateAccs.Find(pWidget) < 0) {
+ m_ValidateAccs.Add(pWidget);
+ }
+}
+FX_BOOL CXFA_FFDocView::InitCalculate(CXFA_Node* pNode)
+{
+ ExecEventActivityByDeepFirst(pNode, XFA_EVENT_InitCalculate);
+ return TRUE;
+}
+FX_BOOL CXFA_FFDocView::InitValidate(CXFA_Node* pNode)
+{
+ if (!m_pDoc->GetDocProvider()->IsValidationsEnabled((XFA_HDOC)m_pDoc)) {
+ return FALSE;
+ }
+ ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Validate);
+ m_ValidateAccs.RemoveAll();
+ return TRUE;
+}
+FX_BOOL CXFA_FFDocView::RunValidate()
+{
+ if (!m_pDoc->GetDocProvider()->IsValidationsEnabled((XFA_HDOC)m_pDoc)) {
+ return FALSE;
+ }
+ FX_INT32 iCounts = m_ValidateAccs.GetSize();
+ for (FX_INT32 i = 0; i < iCounts; i++) {
+ CXFA_WidgetAcc* pAcc = (CXFA_WidgetAcc*)m_ValidateAccs[i];
+ if (pAcc->GetNode()->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+ continue;
+ }
+ pAcc->ProcessValidate();
+ }
+ m_ValidateAccs.RemoveAll();
+ return TRUE;
+}
+FX_BOOL CXFA_FFDocView::RunEventLayoutReady()
+{
+ CXFA_Node* pRootItem = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Form);
+ if (!pRootItem) {
+ return FALSE;
+ }
+ ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready);
+ RunLayout();
+ return TRUE;
+}
+void CXFA_FFDocView::RunBindItems()
+{
+ FX_INT32 iCount = m_bindItems.GetSize();
+ for (FX_INT32 i = 0; i < iCount; i++) {
+ if (((CXFA_Node*)m_bindItems[i])->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+ continue;
+ }
+ CXFA_Node* pWidgetNode = ((CXFA_Node*)m_bindItems[i])->GetNodeItem(XFA_NODEITEM_Parent);
+ CXFA_WidgetAcc* pAcc = (CXFA_WidgetAcc*)pWidgetNode->GetWidgetData();
+ if (!pAcc) {
+ continue;
+ }
+ CXFA_BindItems binditems((CXFA_Node*)m_bindItems[i]);
+ IXFA_ScriptContext* pScriptContext = pWidgetNode->GetDocument()->GetScriptContext();
+ CFX_WideStringC wsRef;
+ binditems.GetRef(wsRef);
+ FX_DWORD dwStyle = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_ALL;
+ XFA_RESOLVENODE_RS rs;
+ pScriptContext->ResolveObjects(pWidgetNode, wsRef, rs, dwStyle);
+ FX_INT32 iCount = rs.nodes.GetSize();
+ pAcc->DeleteItem(-1);
+ if (rs.dwFlags != XFA_RESOVENODE_RSTYPE_Nodes || iCount < 1) {
+ continue;
+ }
+ CFX_WideStringC wsValueRef, wsLabelRef;
+ binditems.GetValueRef(wsValueRef);
+ binditems.GetLabelRef(wsLabelRef);
+ FX_BOOL bUseValue = wsLabelRef.IsEmpty() || wsLabelRef == wsValueRef;
+ FX_BOOL bLabelUseContent = wsLabelRef.IsEmpty() || wsLabelRef == FX_WSTRC(L"$");
+ FX_BOOL bValueUseContent = wsValueRef.IsEmpty() || wsValueRef == FX_WSTRC(L"$");
+ CFX_WideString wsValue, wsLabel;
+ FX_DWORD uValueHash = FX_HashCode_String_GetW(CFX_WideString(wsValueRef), wsValueRef.GetLength());
+ FX_DWORD uLableHash = FX_HashCode_String_GetW(CFX_WideString(wsLabelRef), wsLabelRef.GetLength());
+ for (FX_INT32 i = 0; i < iCount; i++) {
+ CXFA_Object* refObj = rs.nodes[i];
+ if(!refObj->IsNode()) {
+ continue;
+ }
+ CXFA_Node* refNode = (CXFA_Node*)refObj;
+ if (bValueUseContent) {
+ wsValue = refNode->GetContent();
+ } else {
+ CXFA_Node* nodeValue = refNode->GetFirstChildByName(uValueHash);
+ if (nodeValue == NULL) {
+ wsValue = refNode->GetContent();
+ } else {
+ wsValue = nodeValue->GetContent();
+ }
+ }
+ if (!bUseValue) {
+ if (bLabelUseContent) {
+ wsLabel = refNode->GetContent();
+ } else {
+ CXFA_Node* nodeLabel = refNode->GetFirstChildByName(wsLabelRef);
+ if (nodeLabel != NULL) {
+ wsLabel = nodeLabel->GetContent();
+ }
+ }
+ } else {
+ wsLabel = wsValue;
+ }
+ pAcc->InsertItem(wsLabel, wsValue);
+ }
+ }
+ m_bindItems.RemoveAll();
+}
+void CXFA_FFDocView::SetChangeMark()
+{
+ if (m_iStatus < XFA_DOCVIEW_LAYOUTSTATUS_End) {
+ return;
+ }
+ m_pDoc->GetDocProvider()->SetChangeMark((XFA_HDOC)m_pDoc);
+}
+CXFA_Node* CXFA_FFDocView::GetRootSubform()
+{
+ CXFA_Node* pFormPacketNode = (CXFA_Node*)m_pDoc->GetXFADoc()->GetXFANode(XFA_HASHCODE_Form);
+ if (!pFormPacketNode) {
+ return NULL;
+ }
+ return pFormPacketNode->GetFirstChildByClass(XFA_ELEMENT_Subform);
+}
+CXFA_FFDocWidgetIterator::CXFA_FFDocWidgetIterator(CXFA_FFDocView* pDocView, CXFA_Node* pTravelRoot)
+ : m_ContentIterator(pTravelRoot)
+{
+ m_pDocView = pDocView;
+ m_pCurWidget = NULL;
+}
+CXFA_FFDocWidgetIterator::~CXFA_FFDocWidgetIterator()
+{
+}
+void CXFA_FFDocWidgetIterator::Reset()
+{
+ m_ContentIterator.Reset();
+ m_pCurWidget = NULL;
+}
+XFA_HWIDGET CXFA_FFDocWidgetIterator::MoveToFirst()
+{
+ return NULL;
+}
+XFA_HWIDGET CXFA_FFDocWidgetIterator::MoveToLast()
+{
+ return NULL;
+}
+XFA_HWIDGET CXFA_FFDocWidgetIterator::MoveToNext()
+{
+ CXFA_Node* pItem = m_pCurWidget ? m_ContentIterator.MoveToNext() : m_ContentIterator.GetCurrent();
+ while (pItem) {
+ if (CXFA_WidgetAcc* pAcc = (CXFA_WidgetAcc*)pItem->GetWidgetData()) {
+ while ((m_pCurWidget = pAcc->GetNextWidget(NULL)) != NULL) {
+ if (!m_pCurWidget->IsLoaded() && (m_pCurWidget->GetStatus() & XFA_WIDGETSTATUS_Visible)) {
+ m_pCurWidget->LoadWidget();
+ }
+ return (XFA_HWIDGET)m_pCurWidget;
+ }
+ }
+ pItem = m_ContentIterator.MoveToNext();
+ }
+ return NULL;
+}
+XFA_HWIDGET CXFA_FFDocWidgetIterator::MoveToPrevious()
+{
+ return NULL;
+}
+XFA_HWIDGET CXFA_FFDocWidgetIterator::GetCurrentWidget()
+{
+ return NULL;
+}
+FX_BOOL CXFA_FFDocWidgetIterator::SetCurrentWidget(XFA_HWIDGET hWidget)
+{
+ return FALSE;
+}
+IXFA_WidgetAccIterator* XFA_WidgetAccIterator_Create(CXFA_WidgetAcc* pTravelRoot, XFA_WIDGETORDER eOrder)
+{
+ if (!pTravelRoot) {
+ return NULL;
+ }
+ return FX_NEW CXFA_WidgetAccIterator(pTravelRoot->GetDocView(), pTravelRoot->GetNode());
+}
+CXFA_WidgetAccIterator::CXFA_WidgetAccIterator(CXFA_FFDocView* pDocView, CXFA_Node* pTravelRoot)
+ : m_ContentIterator(pTravelRoot)
+{
+ m_pDocView = pDocView;
+ m_pCurWidgetAcc = NULL;
+}
+CXFA_WidgetAccIterator::~CXFA_WidgetAccIterator()
+{
+}
+void CXFA_WidgetAccIterator::Reset()
+{
+ m_pCurWidgetAcc = NULL;
+ m_ContentIterator.Reset();
+}
+CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToFirst()
+{
+ return NULL;
+}
+CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToLast()
+{
+ return NULL;
+}
+CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToNext()
+{
+ CXFA_Node* pItem = m_pCurWidgetAcc ? m_ContentIterator.MoveToNext() : m_ContentIterator.GetCurrent();
+ while (pItem) {
+ if ((m_pCurWidgetAcc = (CXFA_WidgetAcc*)pItem->GetWidgetData()) != NULL) {
+ return m_pCurWidgetAcc;
+ }
+ pItem = m_ContentIterator.MoveToNext();
+ }
+ return NULL;
+}
+CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToPrevious()
+{
+ return NULL;
+}
+CXFA_WidgetAcc* CXFA_WidgetAccIterator::GetCurrentWidgetAcc()
+{
+ return NULL;
+}
+FX_BOOL CXFA_WidgetAccIterator::SetCurrentWidgetAcc(CXFA_WidgetAcc* hWidget)
+{
+ return FALSE;
+}
+void CXFA_WidgetAccIterator::SkipTree()
+{
+ m_ContentIterator.SkipChildrenAndMoveToNext();
+ m_pCurWidgetAcc = NULL;
+}
|