Simplify XFA event handling.

xfa/fxfa/parser/xfa_object_imp.cpp

 // 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_object.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 1280 matching lines @@
 }
 void CXFA_Node::Script_Attribute_BOOLRead(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     FXJSE_Value_SetUTF8String(hValue, GetBoolean(eAttribute) ? "1" : "0");
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Node::Script_Attribute_SendAttributeChangeMessage(
-    void* eAttribute,
-    void* eValue,
+    XFA_ATTRIBUTE eAttribute,
     FX_BOOL bScriptModify) {
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (!pNotify) {
     return;
   }
   uint32_t dwPacket = GetPacketID();
   if (dwPacket & XFA_XDPPACKET_Form) {
     FX_BOOL bNeedFindContainer = FALSE;
     XFA_ELEMENT eType = GetClassID();
     switch (eType) {
       case XFA_ELEMENT_Caption:
         bNeedFindContainer = TRUE;
-        pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                             eValue, this, GetNodeItem(XFA_NODEITEM_Parent));
+        pNotify->OnValueChanged(this, eAttribute, this,
+                                GetNodeItem(XFA_NODEITEM_Parent));
         break;
       case XFA_ELEMENT_Font:
       case XFA_ELEMENT_Para: {
         bNeedFindContainer = TRUE;
         CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParentNode->GetClassID() == XFA_ELEMENT_Caption) {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, pParentNode,
-                               pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
+          pNotify->OnValueChanged(
+              this, eAttribute, pParentNode,
+              pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
         } else {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, this, pParentNode);
+          pNotify->OnValueChanged(this, eAttribute, this, pParentNode);
         }
       } break;
       case XFA_ELEMENT_Margin: {
         bNeedFindContainer = TRUE;
         CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         XFA_ELEMENT eParentType = pParentNode->GetClassID();
         if (pParentNode->IsContainerNode()) {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, this, pParentNode);
+          pNotify->OnValueChanged(this, eAttribute, this, pParentNode);
         } else if (eParentType == XFA_ELEMENT_Caption) {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, pParentNode,
-                               pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
+          pNotify->OnValueChanged(
+              this, eAttribute, pParentNode,
+              pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
         } else {
           CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pNode && pNode->GetClassID() == XFA_ELEMENT_Ui) {
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                                 eValue, pNode,
-                                 pNode->GetNodeItem(XFA_NODEITEM_Parent));
+            pNotify->OnValueChanged(this, eAttribute, pNode,
+                                    pNode->GetNodeItem(XFA_NODEITEM_Parent));
           }
         }
       } break;
       case XFA_ELEMENT_Comb: {
         CXFA_Node* pEditNode = GetNodeItem(XFA_NODEITEM_Parent);
         XFA_ELEMENT eUIType = pEditNode->GetClassID();
         if (pEditNode && (eUIType == XFA_ELEMENT_DateTimeEdit ||
                           eUIType == XFA_ELEMENT_NumericEdit ||
                           eUIType == XFA_ELEMENT_TextEdit)) {
           CXFA_Node* pUINode = pEditNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pUINode) {
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                                 eValue, pUINode,
-                                 pUINode->GetNodeItem(XFA_NODEITEM_Parent));
+            pNotify->OnValueChanged(this, eAttribute, pUINode,
+                                    pUINode->GetNodeItem(XFA_NODEITEM_Parent));
           }
         }
       } break;
       case XFA_ELEMENT_Button:
       case XFA_ELEMENT_Barcode:
       case XFA_ELEMENT_ChoiceList:
       case XFA_ELEMENT_DateTimeEdit:
       case XFA_ELEMENT_NumericEdit:
       case XFA_ELEMENT_PasswordEdit:
       case XFA_ELEMENT_TextEdit: {
         CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pUINode) {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, pUINode,
-                               pUINode->GetNodeItem(XFA_NODEITEM_Parent));
+          pNotify->OnValueChanged(this, eAttribute, pUINode,
+                                  pUINode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       } break;
       case XFA_ELEMENT_CheckButton: {
         bNeedFindContainer = TRUE;
         CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pUINode) {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, pUINode,
-                               pUINode->GetNodeItem(XFA_NODEITEM_Parent));
+          pNotify->OnValueChanged(this, eAttribute, pUINode,
+                                  pUINode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       } break;
       case XFA_ELEMENT_Keep:
       case XFA_ELEMENT_Bookend:
       case XFA_ELEMENT_Break:
       case XFA_ELEMENT_BreakAfter:
       case XFA_ELEMENT_BreakBefore:
       case XFA_ELEMENT_Overflow:
         bNeedFindContainer = TRUE;
         break;
       case XFA_ELEMENT_Area:
       case XFA_ELEMENT_Draw:
       case XFA_ELEMENT_ExclGroup:
       case XFA_ELEMENT_Field:
       case XFA_ELEMENT_Subform:
       case XFA_ELEMENT_SubformSet:
         pLayoutPro->AddChangedContainer(this);
-        pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                             eValue, this, this);
+        pNotify->OnValueChanged(this, eAttribute, this, this);
         break;
       case XFA_ELEMENT_Sharptext:
       case XFA_ELEMENT_Sharpxml:
       case XFA_ELEMENT_SharpxHTML: {
         CXFA_Node* pTextNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (!pTextNode) {
           return;
         }
         CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (!pValueNode) {
           return;
         }
         XFA_ELEMENT eType = pValueNode->GetClassID();
         if (eType == XFA_ELEMENT_Value) {
           bNeedFindContainer = TRUE;
           CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pNode && pNode->IsContainerNode()) {
             if (bScriptModify) {
               pValueNode = pNode;
             }
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                                 eValue, pValueNode, pNode);
+            pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
           } else {
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                                 eValue, pNode,
-                                 pNode->GetNodeItem(XFA_NODEITEM_Parent));
+            pNotify->OnValueChanged(this, eAttribute, pNode,
+                                    pNode->GetNodeItem(XFA_NODEITEM_Parent));
           }
         } else {
           if (eType == XFA_ELEMENT_Items) {
             CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
             if (pNode && pNode->IsContainerNode()) {
-              pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                                   eValue, pValueNode, pNode);
+              pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
             }
           }
         }
       } break;
       default:
         break;
     }
     if (bNeedFindContainer) {
       CXFA_Node* pParent = this;
       while (pParent) {
         if (pParent->IsContainerNode()) {
           break;
         }
         pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
       }
       if (pParent) {
         pLayoutPro->AddChangedContainer(pParent);
       }
     }
   } else {
-    pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue,
-                         this, this);
+    pNotify->OnValueChanged(this, eAttribute, this, this);
   }
 }
+
 void CXFA_Node::Script_Attribute_String(FXJSE_HVALUE hValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString szValue;
     FXJSE_Value_ToUTF8String(hValue, szValue);
     CFX_WideString wsValue = CFX_WideString::FromUTF8(szValue.AsStringC());
     SetAttribute(eAttribute, wsValue.AsStringC(), TRUE);
     if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_ELEMENT_Desc) {
       CFX_WideString wsUseVal = wsValue, wsID, wsSOM;
@@ skipping 2428 matching lines @@
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue)) {
     return FALSE;
   }
   eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   return TRUE;
 }
 FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement mValue,
                               FX_BOOL bNotify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  OnChanging(eAttr, &mValue, bNotify);
+  OnChanging(eAttr, bNotify);
   SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
-  OnChanged(eAttr, &mValue, bNotify);
+  OnChanged(eAttr, bNotify);
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement& mValue,
                               FX_BOOL bUseDefault) const {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   void* pValue;
   int32_t iBytes;
   if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
@@ skipping 11 matching lines @@
 CXFA_Measurement CXFA_Node::GetMeasure(XFA_ATTRIBUTE eAttr) const {
   CXFA_Measurement mValue;
   return TryMeasure(eAttr, mValue, TRUE) ? mValue : CXFA_Measurement();
 }
 
 FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr,
                             const CFX_WideString& wsValue,
                             FX_BOOL bNotify,
                             FX_BOOL bScriptModify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  OnChanging(eAttr, (void*)wsValue.c_str(), bNotify);
+  OnChanging(eAttr, bNotify);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pClone = new CFX_WideString(wsValue);
     SetUserData(pKey, pClone, &deleteWideStringCallBack);
   } else {
     SetMapModuleString(pKey, wsValue.AsStringC());
     if (eAttr == XFA_ATTRIBUTE_Name)
       UpdateNameHash();
   }
-  OnChanged(eAttr, (void*)wsValue.c_str(), bNotify, bScriptModify);
+  OnChanged(eAttr, bNotify, bScriptModify);
   if (IsNeedSavingXMLNode() && eAttr != XFA_ATTRIBUTE_QualifiedName &&
       eAttr != XFA_ATTRIBUTE_BindingNode) {
     if (eAttr == XFA_ATTRIBUTE_Name &&
         (m_eNodeClass == XFA_ELEMENT_DataValue ||
          m_eNodeClass == XFA_ELEMENT_DataGroup)) {
       return TRUE;
     }
     if (eAttr == XFA_ATTRIBUTE_Value) {
       FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
       switch (eXMLType) {
@@ skipping 39 matching lines @@
       static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetString(wsAttrName, wsValue);
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
                                      const CFX_WideString& wsXMLValue,
                                      FX_BOOL bNotify,
                                      FX_BOOL bScriptModify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), XFA_ATTRIBUTE_Value);
-  OnChanging(XFA_ATTRIBUTE_Value, (void*)wsValue.c_str(), bNotify);
+  OnChanging(XFA_ATTRIBUTE_Value, bNotify);
   CFX_WideString* pClone = new CFX_WideString(wsValue);
   SetUserData(pKey, pClone, &deleteWideStringCallBack);
-  OnChanged(XFA_ATTRIBUTE_Value, (void*)wsValue.c_str(), bNotify,
-            bScriptModify);
+  OnChanged(XFA_ATTRIBUTE_Value, bNotify, bScriptModify);
   if (IsNeedSavingXMLNode()) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsXMLValue);
         } else {
           FX_BOOL bDeleteChildren = TRUE;
           if (GetPacketID() == XFA_XDPPACKET_Datasets) {
@@ skipping 88 matching lines @@
 FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   pData = GetUserData(pKey);
   return pData != NULL;
 }
 FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr,
                             XFA_ATTRIBUTETYPE eType,
                             void* pValue,
                             FX_BOOL bNotify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  OnChanging(eAttr, pValue, bNotify);
+  OnChanging(eAttr, bNotify);
   SetMapModuleValue(pKey, pValue);
-  OnChanged(eAttr, pValue, bNotify);
+  OnChanged(eAttr, bNotify);
   if (IsNeedSavingXMLNode()) {
     FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       switch (eType) {
         case XFA_ATTRIBUTETYPE_Enum:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(
                   pInfo->pName,
                   XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
@@ skipping 469 matching lines @@
     pPrev->m_pNext = pNode;
     index = iCount;
   }
   if (pNode->m_pNext == NULL) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(m_pLastChild->m_pNext == NULL);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved, FALSE);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (pNotify) {
-    pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
-  }
+  if (pNotify)
+    pNotify->OnChildAdded(this);
+
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL);
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
     pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, FALSE, FALSE);
   }
   return index;
 }
 FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) {
   if (!pNode || pNode->m_pParent ||
       (pBeforeNode && pBeforeNode->m_pParent != this)) {
@@ skipping 23 matching lines @@
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
   }
   if (pNode->m_pNext == NULL) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(m_pLastChild->m_pNext == NULL);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved, FALSE);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (pNotify) {
-    pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
-  }
+  if (pNotify)
+    pNotify->OnChildAdded(this);
+
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL);
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
     pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, FALSE, FALSE);
   }
   return TRUE;
 }
 CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() {
   if (!m_pParent) {
     return NULL;
@@ skipping 169 matching lines @@
   }
   return FALSE;
 }
 void CXFA_Node::SetFlag(uint32_t dwFlag, FX_BOOL bOn, FX_BOOL bNotify) {
   if (bOn) {
     switch (dwFlag) {
       case XFA_NODEFLAG_Initialized:
         if (bNotify && !HasFlag(XFA_NODEFLAG_Initialized)) {
           CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
           if (pNotify) {
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_Ready);
+            pNotify->OnNodeReady(this);
           }
         }
         break;
       default:
         break;
     }
     m_uFlags |= dwFlag;
   } else {
     m_uFlags &= ~dwFlag;
   }
 }
 FX_BOOL CXFA_Node::IsAttributeInXML() {
   return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData;
 }
+
 void CXFA_Node::OnRemoved(CXFA_Node* pParent,
                           CXFA_Node* pRemoved,
                           FX_BOOL bNotify) {
   if (bNotify && pParent) {

[Tom Sepez, 2016/04/14 22:45:44]

nit: prefer early returns.

[Lei Zhang, 2016/04/15 01:16:40]

Done.

     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (pNotify) {
-      pNotify->OnNodeEvent(pParent, XFA_NODEEVENT_ChildRemoved, pRemoved);
+      pNotify->OnChildRemoved();
     }
   }
 }
-void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr,
-                           void* pNewValue,
-                           FX_BOOL bNotify) {
+
+void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, FX_BOOL bNotify) {
   if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (pNotify) {
-      pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanging,
-                           (void*)(uintptr_t)eAttr, pNewValue);
+      pNotify->OnValueChanging(this, eAttr);
     }
   }
 }
+
 void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
-                          void* pNewValue,
                           FX_BOOL bNotify,
                           FX_BOOL bScriptModify) {
   if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
-    Script_Attribute_SendAttributeChangeMessage((void*)(uintptr_t)eAttr,
-                                                pNewValue, bScriptModify);
+    Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
 int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName,
                                          XFA_ELEMENT eElementType) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   const XFA_ExecEventParaInfo* eventParaInfo =
       GetEventParaInfoByName(wsEventName);
   if (eventParaInfo) {
     uint32_t validFlags = eventParaInfo->m_validFlags;
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
@@ skipping 496 matching lines @@
   return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
 }
 FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
   return m_pAttachNode->RemoveChild(pNode);
 }
 CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
   return m_pAttachNode->GetChild(
       iIndex, XFA_ELEMENT_UNKNOWN,
       m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
 }