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 2270 matching lines @@
 void* XFA_GetMapKey_Element(XFA_ELEMENT eElement, XFA_ATTRIBUTE eAttribute) {
   return (void*)(uintptr_t)((eElement << 16) | (eAttribute << 8) |
                             XFA_KEYTYPE_Element);
 }
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
 FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
                                 const CFX_WideStringC& wsValue,
-                                FX_BOOL bNotify) {
+                                bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (pAttr == NULL) {
     return FALSE;
   }
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
         XFA_GetNotsureAttribute(GetClassID(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
@@ skipping 75 matching lines @@
       mValue.ToString(wsValue);
       return TRUE;
     } break;
     default:
       break;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::SetAttribute(const CFX_WideStringC& wsAttr,
                                 const CFX_WideStringC& wsValue,
-                                FX_BOOL bNotify) {
+                                bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsValue);
   if (pAttributeInfo) {
     return SetAttribute(pAttributeInfo->eName, wsValue, bNotify);
   }
   void* pKey = XFA_GetMapKey_Custom(wsAttr);
   SetMapModuleString(pKey, wsValue);
   return TRUE;
 }
 FX_BOOL CXFA_Node::GetAttribute(const CFX_WideStringC& wsAttr,
                                 CFX_WideString& wsValue,
@@ skipping 37 matching lines @@
 FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr,
                            XFA_ATTRIBUTEENUM& eValue,
                            FX_BOOL bUseDefault) {
   void* pValue = NULL;
   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) {
+                              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, FALSE);

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

nit: false vs. FALSE ?

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

I didn't change the last parameter to a bool yet. I tried to change as many of
the |bNotify| arguments as I can in other places.

   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));
     return TRUE;
   }
   if (bUseDefault &&
       XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
                                    XFA_ATTRIBUTETYPE_Measure, m_ePacket)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
     return TRUE;
   }
   return FALSE;
 }
 
 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,
+                            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 36 matching lines @@
       if (pInfo->eName == XFA_ATTRIBUTE_ContentType) {
         wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName;
       }
       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,
+                                     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 86 matching lines @@
   return SetUserData(pKey, pData, pCallbackInfo);
 }
 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) {
+                            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, FALSE);

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

ditto

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

same as above.

   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 41 matching lines @@
 }
 FX_BOOL CXFA_Node::TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso) {
   int32_t iBytes = 0;
   if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) {
     return FALSE;
   }
   return iBytes == sizeof(void*) && FXSYS_memcpy(&pData, pData, iBytes);
 }
 FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent,
                                     const CFX_WideString& wsXMLValue,
-                                    FX_BOOL bNotify,
+                                    bool bNotify,
                                     FX_BOOL bScriptModify,
                                     FX_BOOL bSyncData) {
   CXFA_Node* pNode = NULL;
   CXFA_Node* pBindNode = NULL;
   switch (GetObjectType()) {
     case XFA_OBJECTTYPE_ContainerNode: {
       if (XFA_FieldIsMultiListBox(this)) {
         CXFA_Node* pValue = GetProperty(0, XFA_ELEMENT_Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         FXSYS_assert(pChildValue);
@@ skipping 155 matching lines @@
         pNode->SetScriptContent(wsContent, wsContent, bNotify, bScriptModify,
                                 FALSE);
       }
     }
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::SetContent(const CFX_WideString& wsContent,
                               const CFX_WideString& wsXMLValue,
-                              FX_BOOL bNotify,
+                              bool bNotify,
                               FX_BOOL bScriptModify,
                               FX_BOOL bSyncData) {
   return SetScriptContent(wsContent, wsXMLValue, bNotify, bScriptModify,
                           bSyncData);
 }
 CFX_WideString CXFA_Node::GetScriptContent(FX_BOOL bScriptModify) {
   CFX_WideString wsContent;
   return TryContent(wsContent, bScriptModify) ? wsContent : CFX_WideString();
 }
 CFX_WideString CXFA_Node::GetContent() {
@@ skipping 231 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;
   }
   for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling;
        pSibling = pSibling->m_pNext) {
     if (pSibling->m_pNext == this) {
       return pSibling;
     }
   }
   return NULL;
 }
-FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, FX_BOOL bNotify) {
+FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) {
   if (pNode == NULL || pNode->m_pParent != this) {
     FXSYS_assert(FALSE);
     return FALSE;
   }
   if (m_pChild == pNode) {
     m_pChild = pNode->m_pNext;
     if (m_pLastChild == pNode) {
       m_pLastChild = pNode->m_pNext;
     }
     pNode->m_pNext = NULL;
     pNode->m_pParent = NULL;
   } else {
     CXFA_Node* pPrev = pNode->Deprecated_GetPrevSibling();
     pPrev->m_pNext = pNode->m_pNext;
     if (m_pLastChild == pNode) {
       m_pLastChild = pNode->m_pNext ? pNode->m_pNext : pPrev;
     }
     pNode->m_pNext = NULL;
     pNode->m_pParent = NULL;
   }
   ASSERT(m_pLastChild == NULL || m_pLastChild->m_pNext == NULL);
-  OnRemoved(this, pNode, bNotify);
+  OnRemoved(bNotify);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved);
   m_pDocument->AddPurgeNode(pNode);
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     if (pNode->IsAttributeInXML()) {
       FXSYS_assert(pNode->m_pXMLNode == m_pXMLNode &&
                    m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
         CFDE_XMLElement* pXMLElement =
             static_cast<CFDE_XMLElement*>(pNode->m_pXMLNode);
         CFX_WideStringC wsAttributeName =
@@ skipping 120 matching lines @@
     return TRUE;
   }
   switch (dwFlag) {
     case XFA_NODEFLAG_HasRemoved:
       return m_pParent && m_pParent->HasFlag(dwFlag);
     default:
       break;
   }
   return FALSE;
 }
-void CXFA_Node::SetFlag(uint32_t dwFlag, FX_BOOL bOn, FX_BOOL bNotify) {
+void CXFA_Node::SetFlag(uint32_t dwFlag, FX_BOOL bOn, 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) {
+
+void CXFA_Node::OnRemoved(bool bNotify) {
+  if (bNotify) {

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

nit: maybe early return?

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

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, 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,
+                          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();
     if (!pNotify) {
       return iRet;
@@ skipping 494 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);
 }