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 129 matching lines @@
       if (!wsValue.IsEmpty()) {
         pCloneXMLElement->SetTextData(wsValue);
       }
       pCloneXML = pCloneXMLElement;
       pCloneXMLElement = NULL;
       pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       pCloneXML = m_pXMLNode->Clone(FALSE);
     }
     pClone->SetXMLMappingNode(pCloneXML);
-    pClone->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+    pClone->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
   }
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->Clone(bRecursive));
     }
   }
-  pClone->SetFlag(XFA_NODEFLAG_Initialized);
+  pClone->SetFlag(XFA_NODEFLAG_Initialized, true);
   pClone->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
   return pClone;
 }
 CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem) const {
   switch (eItem) {
     case XFA_NODEITEM_NextSibling:
       return m_pNext;
     case XFA_NODEITEM_FirstChild:
       return m_pChild;
     case XFA_NODEITEM_Parent:
@@ skipping 124 matching lines @@
       for (int32_t i = 0; i < iProperties; i++) {
         if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
           CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
           const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID());
           CXFA_Node* pNewNode =
               pFactory->CreateNode(pPacket, (XFA_ELEMENT)pProperty[i].eName);
           if (!pNewNode) {
             break;
           }
           InsertChild(pNewNode, NULL);
-          pNewNode->SetFlag(XFA_NODEFLAG_Initialized);
+          pNewNode->SetFlag(XFA_NODEFLAG_Initialized, true);
           nodes.Add(pNewNode);
           break;
         }
       }
     }
   }
   return nodes.GetSize();
 }
 CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_ELEMENT eElement,
                                            uint32_t dwFlags) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
-  pNode->SetFlag(dwFlags);
+  pNode->SetFlag(dwFlags, true);
   return pNode;
 }
 CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
   FXSYS_assert(m_ePacket == XFA_XDPPACKET_Template);
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pClone = pFactory->CreateNode(XFA_XDPPACKET_Form, m_eNodeClass);
   if (!pClone) {
     return NULL;
   }
   pClone->SetTemplateNode(this);
   pClone->UpdateNameHash();
   pClone->SetXMLMappingNode(GetXMLMappingNode());
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->CloneTemplateToForm(bRecursive));
     }
   }
-  pClone->SetFlag(XFA_NODEFLAG_Initialized);
+  pClone->SetFlag(XFA_NODEFLAG_Initialized, true);
   return pClone;
 }
 
 CXFA_Node* CXFA_Node::GetTemplateNode() const {
   return m_pAuxNode;
 }
 
 void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode) {
   m_pAuxNode = pTemplateNode;
 }
@@ skipping 665 matching lines @@
   pFakeRoot = pParser->GetRootNode();
   if (pFakeRoot) {
     if (bOverwrite) {
       CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild);
       CXFA_Node* pNewChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       int32_t index = 0;
       while (pNewChild) {
         CXFA_Node* pItem = pNewChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pNewChild);
         InsertChild(index++, pNewChild);
-        pNewChild->SetFlag(XFA_NODEFLAG_Initialized);
+        pNewChild->SetFlag(XFA_NODEFLAG_Initialized, true);
         pNewChild = pItem;
       }
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         RemoveChild(pChild);
         pFakeRoot->InsertChild(pChild);
         pChild = pItem;
       }
       if (GetPacketID() == XFA_XDPPACKET_Form &&
           GetClassID() == XFA_ELEMENT_ExData) {
         CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
         SetXMLMappingNode(pFakeXMLRoot);
-        SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+        SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
         if (pTempXMLNode &&
             pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           pFakeXMLRoot = NULL;
         }
       }
       MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE);
     } else {
       CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pChild);
         InsertChild(pChild);
-        pChild->SetFlag(XFA_NODEFLAG_Initialized);
+        pChild->SetFlag(XFA_NODEFLAG_Initialized, true);
         pChild = pItem;
       }
     }
     if (pFakeXMLRoot) {
       pFakeRoot->SetXMLMappingNode(pFakeXMLRoot);
-      pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+      pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
     }
-    pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, TRUE, FALSE);
+    pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, false);
   } else {
     if (pFakeXMLRoot) {
       pFakeXMLRoot->Release();
       pFakeXMLRoot = NULL;
     }
   }
   pParser->Release();
   pParser = NULL;
 }
 void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) {
@@ skipping 191 matching lines @@
 void CXFA_Node::Script_ModelClass_Context(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {}
 void CXFA_Node::Script_ModelClass_AliasNode(FXJSE_HVALUE hValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {}
 void CXFA_Node::Script_Attribute_Integer(FXJSE_HVALUE hValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    SetInteger(eAttribute, FXJSE_Value_ToInteger(hValue), TRUE);
+    SetInteger(eAttribute, FXJSE_Value_ToInteger(hValue), true);
   } else {
     FXJSE_Value_SetInteger(hValue, GetInteger(eAttribute));
   }
 }
 void CXFA_Node::Script_Attribute_IntegerRead(FXJSE_HVALUE hValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     FXJSE_Value_SetInteger(hValue, GetInteger(eAttribute));
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Attribute_BOOL(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    SetBoolean(eAttribute, FXJSE_Value_ToBoolean(hValue), TRUE);
+    SetBoolean(eAttribute, FXJSE_Value_ToBoolean(hValue), true);
   } else {
     FXJSE_Value_SetUTF8String(hValue, GetBoolean(eAttribute) ? "1" : "0");
   }
 }
 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);
+    SetAttribute(eAttribute, wsValue.AsStringC(), true);
     if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_ELEMENT_Desc) {
       CFX_WideString wsUseVal = wsValue, wsID, wsSOM;
       CXFA_Node* pTemplateNode =
           ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)
               ->GetFirstChildByClass(XFA_ELEMENT_Proto);
       if (!wsUseVal.IsEmpty()) {
         if (wsUseVal[0] == '#') {
           wsID = CFX_WideString(wsUseVal.c_str() + 1, wsUseVal.GetLength() - 1);
@@ skipping 199 matching lines @@
         }
         pContainerWidgetData = NULL;
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue.AsStringC(),
                                                wsFormatValue);
     }
-    SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
+    SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty() && classID != XFA_ELEMENT_Text &&
         classID != XFA_ELEMENT_SubmitUrl) {
       FXJSE_Value_SetNull(hValue);
     } else if (classID == XFA_ELEMENT_Integer) {
       FXJSE_Value_SetInteger(hValue, FXSYS_wtoi(content.c_str()));
     } else if (classID == XFA_ELEMENT_Float || classID == XFA_ELEMENT_Decimal) {
       CFX_Decimal decimal(content.AsStringC());
       FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
@@ skipping 29 matching lines @@
       FXJSE_Value_ToUTF8String(hValue, newValue);
     }
     int32_t iValue = FXSYS_atoi(newValue.c_str());
     CFX_WideString wsNewValue = (iValue == 0) ? FX_WSTRC(L"0") : FX_WSTRC(L"1");
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue.AsStringC(),
                                                wsFormatValue);
     }
-    SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
+    SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
   } else {
     CFX_WideString wsValue = GetScriptContent(TRUE);
     FXJSE_Value_SetBoolean(hValue, wsValue == FX_WSTRC(L"1"));
   }
 }
 struct XFA_ExecEventParaInfo {
  public:
   uint32_t m_uHash;
   const FX_WCHAR* m_lpcEventName;
   XFA_EVENTTYPE m_eventType;
@@ skipping 190 matching lines @@
     if (FXJSE_Value_IsUTF8String(hValue)) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       FXSYS_assert(pWidgetData);
       XFA_ELEMENT uiType = pWidgetData->GetUIType();
       if (uiType == XFA_ELEMENT_Text) {
         CFX_ByteString newValue;
         FXJSE_Value_ToUTF8String(hValue, newValue);
         CFX_WideString wsNewValue =
             CFX_WideString::FromUTF8(newValue.AsStringC());
         CFX_WideString wsFormatValue(wsNewValue);
-        SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
+        SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
       } else if (uiType != XFA_ELEMENT_Image) {
       }
     }
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       FXJSE_Value_SetNull(hValue);
     } else {
       FXJSE_Value_SetUTF8String(
           hValue,
@@ skipping 29 matching lines @@
       pWidgetData->GetFracDigits(iFracDigits);
       wsNewText =
           pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits);
     }
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     CFX_WideString wsFormatText(wsNewText);
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewText.AsStringC(),
                                                wsFormatText);
     }
-    SetScriptContent(wsNewText, wsFormatText, TRUE, TRUE);
+    SetScriptContent(wsNewText, wsFormatText, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       FXJSE_Value_SetNull(hValue);
     } else {
       CXFA_Node* pUIChild = pWidgetData->GetUIChild();
       XFA_ELEMENT eUI = pUIChild->GetClassID();
       CXFA_Value defVal = pWidgetData->GetFormValue();
       CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (pNode && pNode->GetClassID() == XFA_ELEMENT_Decimal) {
@@ skipping 575 matching lines @@
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Subform_Locale(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsLocaleName;
     FXJSE_Value_ToUTF8String(hValue, bsLocaleName);
     SetCData(XFA_ATTRIBUTE_Locale,
-             CFX_WideString::FromUTF8(bsLocaleName.AsStringC()), TRUE, TRUE);
+             CFX_WideString::FromUTF8(bsLocaleName.AsStringC()), true, TRUE);
   } else {
     CFX_WideString wsLocaleName;
     GetLocaleName(wsLocaleName);
     FXJSE_Value_SetUTF8String(
         hValue, FX_UTF8Encode(wsLocaleName.c_str(), wsLocaleName.GetLength())
                     .AsStringC());
   }
 }
 void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
@@ skipping 117 matching lines @@
     }
     const XFA_ELEMENTINFO* pElement =
         XFA_GetElementByName(strTagName.AsStringC());
     CXFA_Node* pNewNode = CreateSamePacketNode(pElement->eName);
     if (!pNewNode) {
       FXJSE_Value_SetNull(pArguments->GetReturnValue());
     } else {
       if (!strName.IsEmpty()) {
         if (XFA_GetAttributeOfElement(pElement->eName, XFA_ATTRIBUTE_Name,
                                       XFA_XDPPACKET_UNKNOWN)) {
-          pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), TRUE);
+          pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), true);
           if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) {
             pNewNode->CreateXMLMappingNode();
           }
           FXJSE_Value_Set(
               pArguments->GetReturnValue(),
               m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
         } else {
           ThrowScriptErrorMessage(XFA_IDS_NOT_HAVE_PROPERTY, strTagName.c_str(),
                                   L"name");
         }
@@ skipping 997 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 83 matching lines @@
       if (pBindNode && bSyncData) {
         pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
                                     bScriptModify, FALSE);
         CXFA_NodeArray nodeArray;
         pBindNode->GetBindItems(nodeArray);
         for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
           CXFA_Node* pNode = nodeArray[i];
           if (pNode == this) {
             continue;
           }
-          pNode->SetScriptContent(wsContent, wsContent, bNotify, TRUE, FALSE);
+          pNode->SetScriptContent(wsContent, wsContent, bNotify, true, FALSE);
         }
       }
       pBindNode = NULL;
       break;
     }
     case XFA_OBJECTTYPE_ContentNode: {
       CFX_WideString wsContentType;
       if (GetClassID() == XFA_ELEMENT_ExData) {
         GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
         if (wsContentType == FX_WSTRC(L"text/html")) {
@@ skipping 51 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 151 matching lines @@
   }
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket);
   CXFA_Node* pNewNode;
   for (; iCount <= index; iCount++) {
     pNewNode = pFactory->CreateNode(pPacket, eProperty);
     if (!pNewNode) {
       return NULL;
     }
     InsertChild(pNewNode, nullptr);
-    pNewNode->SetFlag(XFA_NODEFLAG_Initialized);
+    pNewNode->SetFlag(XFA_NODEFLAG_Initialized, true);
   }
   return pNewNode;
 }
 int32_t CXFA_Node::CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
@@ skipping 57 matching lines @@
     }
     pNode->m_pNext = pPrev->m_pNext;
     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);
+  pNode->ClearFlag(XFA_NODEFLAG_HasRemoved);
   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);
+    pNode->ClearFlag(XFA_NODEFLAG_OwnXMLNode);
   }
   return index;
 }
 FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) {
   if (!pNode || pNode->m_pParent ||
       (pBeforeNode && pBeforeNode->m_pParent != this)) {
     FXSYS_assert(false);
     return FALSE;
   }
   FX_BOOL bWasPurgeNode = m_pDocument->RemovePurgeNode(pNode);
@@ skipping 17 matching lines @@
       nIndex++;
     }
     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);
+  pNode->ClearFlag(XFA_NODEFLAG_HasRemoved);
   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);
+    pNode->ClearFlag(XFA_NODEFLAG_OwnXMLNode);
   }
   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);
-  pNode->SetFlag(XFA_NODEFLAG_HasRemoved);
+  OnRemoved(bNotify);
+  pNode->SetFlag(XFA_NODEFLAG_HasRemoved, true);
   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 =
             pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
         pXMLElement->RemoveAttribute(wsAttributeName.c_str());
       }
       CFX_WideString wsName;
       pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
       CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pNewXMLElement->SetTextData(wsValue);
       }
       pNode->m_pXMLNode = pNewXMLElement;
       pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode);
     }
-    pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+    pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
   }
   return TRUE;
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const {
   return GetFirstChildByName(
       wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.c_str(),
                                                      wsName.GetLength()));
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
@@ skipping 94 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, bool bNotify) {
+  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;
 }
+
+void CXFA_Node::ClearFlag(uint32_t 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)
+    return;
+
+  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  if (pNotify)
+    pNotify->OnChildRemoved();
+}
+
+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(pParent, XFA_NODEEVENT_ChildRemoved, pRemoved);
+      pNotify->OnValueChanging(this, eAttr);
     }
   }
 }
-void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr,
-                           void* pNewValue,
-                           FX_BOOL bNotify) {
+
+void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
+                          bool bNotify,
+                          FX_BOOL bScriptModify) {
   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);
-    }
+    Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
-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);
-  }
-}
+
 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 60 matching lines @@
         XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash =
         wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.c_str(),
                                                        wsName.GetLength());
   }
 }
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideStringC wsTag = GetCData(XFA_ATTRIBUTE_Name);
     m_pXMLNode = new CFDE_XMLElement(wsTag);
-    SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+    SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
   }
   return m_pXMLNode;
 }
 FX_BOOL CXFA_Node::IsNeedSavingXMLNode() {
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
                         GetClassID() == XFA_ELEMENT_Xfa);
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() {
   if (!m_pMapModuleData)
@@ skipping 218 matching lines @@
                                         (XFA_MAPDATABLOCK*)pBufferBlockData);
     }
   }
   if (pDstModule->GetObjectType() == XFA_OBJECTTYPE_NodeV) {
     CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE);
     CFX_WideString wsFormatValue(wsValue);
     CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData();
     if (pWidgetData) {
       pWidgetData->GetFormatDataValue(wsValue.AsStringC(), wsFormatValue);
     }
-    pDstModule->SetScriptContent(wsValue, wsFormatValue, TRUE, TRUE);
+    pDstModule->SetScriptContent(wsValue, wsFormatValue, true, TRUE);
   }
 }
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule,
                                   CXFA_Node* pDstModule,
                                   void* pKey,
                                   FX_BOOL bRecursive) {
   if (!pSrcModule || !pDstModule || !pKey) {
     return;
   }
   if (bRecursive) {
@@ skipping 174 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);
 }