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) {
+  if (!pLayoutPro)
+    return;
+
+  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  if (!pNotify)
+    return;
+
+  uint32_t dwPacket = GetPacketID();
+  if (!(dwPacket & XFA_XDPPACKET_Form)) {
+    pNotify->OnValueChanged(this, eAttribute, this, this);
     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));
-        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));
+
+  bool bNeedFindContainer = false;
+  XFA_ELEMENT eType = GetClassID();
+  switch (eType) {
+    case XFA_ELEMENT_Caption:
+      bNeedFindContainer = true;
+      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->OnValueChanged(this, eAttribute, pParentNode,
+                                pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
+      } else {
+        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->OnValueChanged(this, eAttribute, this, pParentNode);
+      } else if (eParentType == XFA_ELEMENT_Caption) {
+        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->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->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->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->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->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->OnValueChanged(this, eAttribute, pValueNode, pNode);
         } else {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, this, pParentNode);
+          pNotify->OnValueChanged(this, eAttribute, pNode,
+                                  pNode->GetNodeItem(XFA_NODEITEM_Parent));
         }
-      } 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);
-        } else if (eParentType == XFA_ELEMENT_Caption) {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, 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));
+      } else {
+        if (eType == XFA_ELEMENT_Items) {
+          CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
+          if (pNode && pNode->IsContainerNode()) {
+            pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
           }
         }
-      } 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));
-          }
-        }
-      } 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));
-        }
-      } 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));
-        }
-      } 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;
+    default:
+      break;
+  }
+  if (bNeedFindContainer) {
+    CXFA_Node* pParent = this;
+    while (pParent) {
+      if (pParent->IsContainerNode()) {
         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);
-        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);
-          } else {
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                                 eValue, 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);
-            }
-          }
-        }
-      } break;
-      default:
-        break;
+      }
+      pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
     }
-    if (bNeedFindContainer) {
-      CXFA_Node* pParent = this;
-      while (pParent) {
-        if (pParent->IsContainerNode()) {
-          break;
-        }
-        pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
-      }
-      if (pParent) {
-        pLayoutPro->AddChangedContainer(pParent);
-      }
+    if (pParent) {
+      pLayoutPro->AddChangedContainer(pParent);
     }
-  } else {
-    pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue,
-                         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);
   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);
-  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) {
-        case FDE_XMLNODE_Element:
-          if (IsAttributeInXML()) {
-            static_cast<CFDE_XMLElement*>(m_pXMLNode)
-                ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsValue);
-          } else {
-            FX_BOOL bDeleteChildren = TRUE;
-            if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-              for (CXFA_Node* pChildDataNode =
-                       GetNodeItem(XFA_NODEITEM_FirstChild);
-                   pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
-                                       XFA_NODEITEM_NextSibling)) {
-                CXFA_NodeArray formNodes;
-                if (pChildDataNode->GetBindItems(formNodes) > 0) {
-                  bDeleteChildren = FALSE;
-                  break;
-                }
+  OnChanged(eAttr, bNotify, bScriptModify);
+
+  if (!IsNeedSavingXMLNode() || eAttr == XFA_ATTRIBUTE_QualifiedName ||
+      eAttr == XFA_ATTRIBUTE_BindingNode) {
+    return TRUE;
+  }
+
+  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) {
+      case FDE_XMLNODE_Element:
+        if (IsAttributeInXML()) {
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)
+              ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsValue);
+        } else {
+          FX_BOOL bDeleteChildren = TRUE;
+          if (GetPacketID() == XFA_XDPPACKET_Datasets) {
+            for (CXFA_Node* pChildDataNode =
+                     GetNodeItem(XFA_NODEITEM_FirstChild);
+                 pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
+                                     XFA_NODEITEM_NextSibling)) {
+              CXFA_NodeArray formNodes;
+              if (pChildDataNode->GetBindItems(formNodes) > 0) {
+                bDeleteChildren = FALSE;
+                break;
               }
             }
-            if (bDeleteChildren) {
-              static_cast<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
-            }
-            static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsValue);
           }
-          break;
-        case FDE_XMLNODE_Text:
-          static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsValue);
-          break;
-        default:
-          FXSYS_assert(0);
-      }
-      return TRUE;
+          if (bDeleteChildren) {
+            static_cast<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
+          }
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsValue);
+        }
+        break;
+      case FDE_XMLNODE_Text:
+        static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsValue);
+        break;
+      default:
+        FXSYS_assert(0);
     }
-    const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
-    if (pInfo) {
-      FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
-      CFX_WideString wsAttrName = pInfo->pName;
-      if (pInfo->eName == XFA_ATTRIBUTE_ContentType) {
-        wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName;
-      }
-      static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetString(wsAttrName, wsValue);
+    return TRUE;
+  }
+
+  const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
+  if (pInfo) {
+    FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
+    CFX_WideString wsAttrName = pInfo->pName;
+    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);
   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) {
-  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);
-          }
-        }
-        break;
-      default:
-        break;
+
+void CXFA_Node::SetFlag(uint32_t dwFlag, FX_BOOL bOn, bool bNotify) {

[Tom Sepez, 2016/04/14 22:08:55]

might be worth having a separate ClearFlag rather than taking a boolean arg ...
I doubt we ever pass a computed value vs. "false"

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

Done.

+  if (!bOn) {
+    m_uFlags &= ~dwFlag;
+    return;
+  }
+
+  if (dwFlag == XFA_NODEFLAG_Initialized && bNotify &&
+      !HasFlag(XFA_NODEFLAG_Initialized)) {
+    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    if (pNotify) {
+      pNotify->OnNodeReady(this);
     }
-    m_uFlags |= dwFlag;
-  } else {
-    m_uFlags &= ~dwFlag;
   }
+  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) {
     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);
 }