Move xfa/src up to xfa/.

This CL moves the xfa/src files up to the xfa/ directory and fixes the includes,
include guards, and build files.

R=tsepez@chromium.org

Review URL: https://codereview.chromium.org/1803723002 .

57 files changed, 0 insertions, 36662 deletions

diff --git a/xfa/src/fxfa/parser/xfa_basic_data.cpp b/xfa/src/fxfa/parser/xfa_basic_data.cpp
deleted file mode 100644
index 418ebf374b..0000000000
--- a/xfa/src/fxfa/parser/xfa_basic_data.cpp
+++ /dev/null
@@ -1,7333 +0,0 @@
-// 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/src/fxfa/parser/xfa_basic_data.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_script_datawindow.h"
-#include "xfa/src/fxfa/parser/xfa_script_eventpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_hostpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_logpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-const XFA_ATTRIBUTEENUMINFO g_XFAEnumData[] = {
-    {0x2a, L"*", XFA_ATTRIBUTEENUM_Asterisk},
-    {0x2f, L"/", XFA_ATTRIBUTEENUM_Slash},
-    {0x5c, L"\\", XFA_ATTRIBUTEENUM_Backslash},
-    {0x239bd, L"on", XFA_ATTRIBUTEENUM_On},
-    {0x25356, L"tb", XFA_ATTRIBUTEENUM_Tb},
-    {0x25885, L"up", XFA_ATTRIBUTEENUM_Up},
-    {0x91b281, L"metaData", XFA_ATTRIBUTEENUM_MetaData},
-    {0x1f8dedb, L"delegate", XFA_ATTRIBUTEENUM_Delegate},
-    {0x2a6c55a, L"postSubmit", XFA_ATTRIBUTEENUM_PostSubmit},
-    {0x31b19c1, L"name", XFA_ATTRIBUTEENUM_Name},
-    {0x378a38a, L"cross", XFA_ATTRIBUTEENUM_Cross},
-    {0x3848b3f, L"next", XFA_ATTRIBUTEENUM_Next},
-    {0x48b6670, L"none", XFA_ATTRIBUTEENUM_None},
-    {0x51aafe5, L"shortEdge", XFA_ATTRIBUTEENUM_ShortEdge},
-    {0x55264c4, L"1mod10_1mod11", XFA_ATTRIBUTEENUM_1mod10_1mod11},
-    {0x5a5c519, L"height", XFA_ATTRIBUTEENUM_Height},
-    {0x89ce549, L"crossDiagonal", XFA_ATTRIBUTEENUM_CrossDiagonal},
-    {0x9f9d0f9, L"all", XFA_ATTRIBUTEENUM_All},
-    {0x9f9db48, L"any", XFA_ATTRIBUTEENUM_Any},
-    {0xa126261, L"toRight", XFA_ATTRIBUTEENUM_ToRight},
-    {0xa36de29, L"matchTemplate", XFA_ATTRIBUTEENUM_MatchTemplate},
-    {0xa48d040, L"dpl", XFA_ATTRIBUTEENUM_Dpl},
-    {0xa559c05, L"invisible", XFA_ATTRIBUTEENUM_Invisible},
-    {0xa7d48e3, L"fit", XFA_ATTRIBUTEENUM_Fit},
-    {0xa8a8f80, L"width", XFA_ATTRIBUTEENUM_Width},
-    {0xab466bb, L"preSubmit", XFA_ATTRIBUTEENUM_PreSubmit},
-    {0xacc5785, L"ipl", XFA_ATTRIBUTEENUM_Ipl},
-    {0xafab0f8, L"flateCompress", XFA_ATTRIBUTEENUM_FlateCompress},
-    {0xb355816, L"med", XFA_ATTRIBUTEENUM_Med},
-    {0xb69ef77, L"odd", XFA_ATTRIBUTEENUM_Odd},
-    {0xb69f9bb, L"off", XFA_ATTRIBUTEENUM_Off},
-    {0xb843dba, L"pdf", XFA_ATTRIBUTEENUM_Pdf},
-    {0xbb912b8, L"row", XFA_ATTRIBUTEENUM_Row},
-    {0xbedaf33, L"top", XFA_ATTRIBUTEENUM_Top},
-    {0xc56afcc, L"xdp", XFA_ATTRIBUTEENUM_Xdp},
-    {0xc56ba02, L"xfd", XFA_ATTRIBUTEENUM_Xfd},
-    {0xc56ddf1, L"xml", XFA_ATTRIBUTEENUM_Xml},
-    {0xc8b65f3, L"zip", XFA_ATTRIBUTEENUM_Zip},
-    {0xc8b89d6, L"zpl", XFA_ATTRIBUTEENUM_Zpl},
-    {0xf55d7ee, L"visible", XFA_ATTRIBUTEENUM_Visible},
-    {0xfe3596a, L"exclude", XFA_ATTRIBUTEENUM_Exclude},
-    {0x109d7ce7, L"mouseEnter", XFA_ATTRIBUTEENUM_MouseEnter},
-    {0x10f1bc0c, L"pair", XFA_ATTRIBUTEENUM_Pair},
-    {0x1154efe6, L"filter", XFA_ATTRIBUTEENUM_Filter},
-    {0x125bc94b, L"moveLast", XFA_ATTRIBUTEENUM_MoveLast},
-    {0x12e1f1f0, L"exportAndImport", XFA_ATTRIBUTEENUM_ExportAndImport},
-    {0x13000c60, L"push", XFA_ATTRIBUTEENUM_Push},
-    {0x138ee315, L"portrait", XFA_ATTRIBUTEENUM_Portrait},
-    {0x14da2125, L"default", XFA_ATTRIBUTEENUM_Default},
-    {0x157749a5, L"storedProc", XFA_ATTRIBUTEENUM_StoredProc},
-    {0x16641198, L"stayBOF", XFA_ATTRIBUTEENUM_StayBOF},
-    {0x16b2fc5b, L"stayEOF", XFA_ATTRIBUTEENUM_StayEOF},
-    {0x17fad373, L"postPrint", XFA_ATTRIBUTEENUM_PostPrint},
-    {0x193207d0, L"usCarrier", XFA_ATTRIBUTEENUM_UsCarrier},
-    {0x193ade3e, L"right", XFA_ATTRIBUTEENUM_Right},
-    {0x1bfc72d9, L"preOpen", XFA_ATTRIBUTEENUM_PreOpen},
-    {0x1cc9317a, L"actual", XFA_ATTRIBUTEENUM_Actual},
-    {0x1f31df1e, L"rest", XFA_ATTRIBUTEENUM_Rest},
-    {0x1fb1bf14, L"topCenter", XFA_ATTRIBUTEENUM_TopCenter},
-    {0x207de667, L"standardSymbol", XFA_ATTRIBUTEENUM_StandardSymbol},
-    {0x2196a452, L"initialize", XFA_ATTRIBUTEENUM_Initialize},
-    {0x23bd40c7, L"justifyAll", XFA_ATTRIBUTEENUM_JustifyAll},
-    {0x247cf3e9, L"normal", XFA_ATTRIBUTEENUM_Normal},
-    {0x25aa946b, L"landscape", XFA_ATTRIBUTEENUM_Landscape},
-    {0x2739b5c9, L"nonInteractive", XFA_ATTRIBUTEENUM_NonInteractive},
-    {0x27410f03, L"mouseExit", XFA_ATTRIBUTEENUM_MouseExit},
-    {0x2854e62c, L"minus", XFA_ATTRIBUTEENUM_Minus},
-    {0x287e936a, L"diagonalLeft", XFA_ATTRIBUTEENUM_DiagonalLeft},
-    {0x2972a98f, L"simplexPaginated", XFA_ATTRIBUTEENUM_SimplexPaginated},
-    {0x29d8225f, L"document", XFA_ATTRIBUTEENUM_Document},
-    {0x2a9d3016, L"warning", XFA_ATTRIBUTEENUM_Warning},
-    {0x2b35b6d9, L"auto", XFA_ATTRIBUTEENUM_Auto},
-    {0x2c1653d9, L"below", XFA_ATTRIBUTEENUM_Below},
-    {0x2c1f0540, L"bottomLeft", XFA_ATTRIBUTEENUM_BottomLeft},
-    {0x2c44e816, L"bottomCenter", XFA_ATTRIBUTEENUM_BottomCenter},
-    {0x2cd3e9f3, L"tcpl", XFA_ATTRIBUTEENUM_Tcpl},
-    {0x2d08af85, L"text", XFA_ATTRIBUTEENUM_Text},
-    {0x2dc478eb, L"grouping", XFA_ATTRIBUTEENUM_Grouping},
-    {0x2ef3afdd, L"secureSymbol", XFA_ATTRIBUTEENUM_SecureSymbol},
-    {0x2f2dd29a, L"preExecute", XFA_ATTRIBUTEENUM_PreExecute},
-    {0x33c43dec, L"docClose", XFA_ATTRIBUTEENUM_DocClose},
-    {0x33f25bb5, L"keyset", XFA_ATTRIBUTEENUM_Keyset},
-    {0x34e363da, L"vertical", XFA_ATTRIBUTEENUM_Vertical},
-    {0x361fa1b6, L"preSave", XFA_ATTRIBUTEENUM_PreSave},
-    {0x36f1c6d8, L"preSign", XFA_ATTRIBUTEENUM_PreSign},
-    {0x399f02b5, L"bottom", XFA_ATTRIBUTEENUM_Bottom},
-    {0x3b0ab096, L"toTop", XFA_ATTRIBUTEENUM_ToTop},
-    {0x3c752495, L"verify", XFA_ATTRIBUTEENUM_Verify},
-    {0x3ce05d68, L"first", XFA_ATTRIBUTEENUM_First},
-    {0x3ecead94, L"contentArea", XFA_ATTRIBUTEENUM_ContentArea},
-    {0x40623b5b, L"solid", XFA_ATTRIBUTEENUM_Solid},
-    {0x42c6cd8d, L"pessimistic", XFA_ATTRIBUTEENUM_Pessimistic},
-    {0x43ddc6bf, L"duplexPaginated", XFA_ATTRIBUTEENUM_DuplexPaginated},
-    {0x442f68c8, L"round", XFA_ATTRIBUTEENUM_Round},
-    {0x45efb847, L"remerge", XFA_ATTRIBUTEENUM_Remerge},
-    {0x46972265, L"ordered", XFA_ATTRIBUTEENUM_Ordered},
-    {0x46f95531, L"percent", XFA_ATTRIBUTEENUM_Percent},
-    {0x46fd25ae, L"even", XFA_ATTRIBUTEENUM_Even},
-    {0x4731d6ba, L"exit", XFA_ATTRIBUTEENUM_Exit},
-    {0x4977356b, L"toolTip", XFA_ATTRIBUTEENUM_ToolTip},
-    {0x49b980ee, L"orderedOccurrence", XFA_ATTRIBUTEENUM_OrderedOccurrence},
-    {0x4a7e2dfe, L"readOnly", XFA_ATTRIBUTEENUM_ReadOnly},
-    {0x4c4e8acb, L"currency", XFA_ATTRIBUTEENUM_Currency},
-    {0x4dcf25f8, L"concat", XFA_ATTRIBUTEENUM_Concat},
-    {0x4febb826, L"Thai", XFA_ATTRIBUTEENUM_Thai},
-    {0x50ef95b2, L"embossed", XFA_ATTRIBUTEENUM_Embossed},
-    {0x516e35ce, L"formdata", XFA_ATTRIBUTEENUM_Formdata},
-    {0x52fa6f0e, L"Greek", XFA_ATTRIBUTEENUM_Greek},
-    {0x54034c2f, L"decimal", XFA_ATTRIBUTEENUM_Decimal},
-    {0x542c7300, L"select", XFA_ATTRIBUTEENUM_Select},
-    {0x551f0ae5, L"longEdge", XFA_ATTRIBUTEENUM_LongEdge},
-    {0x55520a8a, L"protected", XFA_ATTRIBUTEENUM_Protected},
-    {0x559f76f3, L"bottomRight", XFA_ATTRIBUTEENUM_BottomRight},
-    {0x568cb500, L"zero", XFA_ATTRIBUTEENUM_Zero},
-    {0x56bcecb7, L"forwardOnly", XFA_ATTRIBUTEENUM_ForwardOnly},
-    {0x56bf456b, L"docReady", XFA_ATTRIBUTEENUM_DocReady},
-    {0x573cb40c, L"hidden", XFA_ATTRIBUTEENUM_Hidden},
-    {0x582e3424, L"include", XFA_ATTRIBUTEENUM_Include},
-    {0x58a3dd29, L"dashed", XFA_ATTRIBUTEENUM_Dashed},
-    {0x5955b22b, L"multiSelect", XFA_ATTRIBUTEENUM_MultiSelect},
-    {0x598d5c53, L"inactive", XFA_ATTRIBUTEENUM_Inactive},
-    {0x59c8f27d, L"embed", XFA_ATTRIBUTEENUM_Embed},
-    {0x5e7555e8, L"static", XFA_ATTRIBUTEENUM_Static},
-    {0x606d4def, L"onEntry", XFA_ATTRIBUTEENUM_OnEntry},
-    {0x6195eafb, L"Cyrillic", XFA_ATTRIBUTEENUM_Cyrillic},
-    {0x6491b0f3, L"nonBlank", XFA_ATTRIBUTEENUM_NonBlank},
-    {0x67bef031, L"topRight", XFA_ATTRIBUTEENUM_TopRight},
-    {0x67df5ebd, L"Hebrew", XFA_ATTRIBUTEENUM_Hebrew},
-    {0x6aea98be, L"topLeft", XFA_ATTRIBUTEENUM_TopLeft},
-    {0x6c51afc1, L"center", XFA_ATTRIBUTEENUM_Center},
-    {0x7145e6bf, L"moveFirst", XFA_ATTRIBUTEENUM_MoveFirst},
-    {0x7375465c, L"diamond", XFA_ATTRIBUTEENUM_Diamond},
-    {0x7461aef4, L"pageOdd", XFA_ATTRIBUTEENUM_PageOdd},
-    {0x75f8aeb2, L"1mod10", XFA_ATTRIBUTEENUM_1mod10},
-    {0x76d708e0, L"Korean", XFA_ATTRIBUTEENUM_Korean},
-    {0x789f14d7, L"aboveEmbedded", XFA_ATTRIBUTEENUM_AboveEmbedded},
-    {0x792ea39f, L"zipCompress", XFA_ATTRIBUTEENUM_ZipCompress},
-    {0x7a5b7193, L"numeric", XFA_ATTRIBUTEENUM_Numeric},
-    {0x7abec0d2, L"circle", XFA_ATTRIBUTEENUM_Circle},
-    {0x7afbba38, L"toBottom", XFA_ATTRIBUTEENUM_ToBottom},
-    {0x7b95e661, L"inverted", XFA_ATTRIBUTEENUM_Inverted},
-    {0x7baca2e3, L"update", XFA_ATTRIBUTEENUM_Update},
-    {0x7eb5da2c, L"isoname", XFA_ATTRIBUTEENUM_Isoname},
-    {0x7f6fd3d7, L"server", XFA_ATTRIBUTEENUM_Server},
-    {0x814f82b5, L"position", XFA_ATTRIBUTEENUM_Position},
-    {0x82deacf0, L"middleCenter", XFA_ATTRIBUTEENUM_MiddleCenter},
-    {0x83a49dc6, L"optional", XFA_ATTRIBUTEENUM_Optional},
-    {0x861a116f, L"usePrinterSetting", XFA_ATTRIBUTEENUM_UsePrinterSetting},
-    {0x86701ce0, L"outline", XFA_ATTRIBUTEENUM_Outline},
-    {0x8808385e, L"indexChange", XFA_ATTRIBUTEENUM_IndexChange},
-    {0x891f4606, L"change", XFA_ATTRIBUTEENUM_Change},
-    {0x89939f36, L"pageArea", XFA_ATTRIBUTEENUM_PageArea},
-    {0x8b5c3b25, L"once", XFA_ATTRIBUTEENUM_Once},
-    {0x8b5c6962, L"only", XFA_ATTRIBUTEENUM_Only},
-    {0x8b90e1f2, L"open", XFA_ATTRIBUTEENUM_Open},
-    {0x8bcfe96e, L"caption", XFA_ATTRIBUTEENUM_Caption},
-    {0x8ce83ef8, L"raised", XFA_ATTRIBUTEENUM_Raised},
-    {0x8d269cae, L"justify", XFA_ATTRIBUTEENUM_Justify},
-    {0x8fd520dc, L"refAndDescendants", XFA_ATTRIBUTEENUM_RefAndDescendants},
-    {0x9041d4b0, L"short", XFA_ATTRIBUTEENUM_Short},
-    {0x90c94426, L"pageFront", XFA_ATTRIBUTEENUM_PageFront},
-    {0x936beee5, L"monospace", XFA_ATTRIBUTEENUM_Monospace},
-    {0x947fa00f, L"middle", XFA_ATTRIBUTEENUM_Middle},
-    {0x9528a7b4, L"prePrint", XFA_ATTRIBUTEENUM_PrePrint},
-    {0x959ab231, L"always", XFA_ATTRIBUTEENUM_Always},
-    {0x96d61bf0, L"unknown", XFA_ATTRIBUTEENUM_Unknown},
-    {0x997194ee, L"toLeft", XFA_ATTRIBUTEENUM_ToLeft},
-    {0x9a83a3cd, L"above", XFA_ATTRIBUTEENUM_Above},
-    {0x9d0d71c7, L"dashDot", XFA_ATTRIBUTEENUM_DashDot},
-    {0x9df56f3e, L"gregorian", XFA_ATTRIBUTEENUM_Gregorian},
-    {0x9f6723fd, L"Roman", XFA_ATTRIBUTEENUM_Roman},
-    {0x9f693b21, L"mouseDown", XFA_ATTRIBUTEENUM_MouseDown},
-    {0xa1429b36, L"symbol", XFA_ATTRIBUTEENUM_Symbol},
-    {0xa5aa45cb, L"pageEven", XFA_ATTRIBUTEENUM_PageEven},
-    {0xa68635f1, L"sign", XFA_ATTRIBUTEENUM_Sign},
-    {0xa7315093, L"addNew", XFA_ATTRIBUTEENUM_AddNew},
-    {0xa7a773fa, L"star", XFA_ATTRIBUTEENUM_Star},
-    {0xa7d57b45, L"optimistic", XFA_ATTRIBUTEENUM_Optimistic},
-    {0xa8077321, L"rl-tb", XFA_ATTRIBUTEENUM_Rl_tb},
-    {0xa8f1468d, L"middleRight", XFA_ATTRIBUTEENUM_MiddleRight},
-    {0xaa84a1f1, L"maintain", XFA_ATTRIBUTEENUM_Maintain},
-    {0xab40b12c, L"package", XFA_ATTRIBUTEENUM_Package},
-    {0xac8b4d85, L"SimplifiedChinese", XFA_ATTRIBUTEENUM_SimplifiedChinese},
-    {0xadae6744, L"toCenter", XFA_ATTRIBUTEENUM_ToCenter},
-    {0xb0129df1, L"back", XFA_ATTRIBUTEENUM_Back},
-    {0xb0f088cf, L"unspecified", XFA_ATTRIBUTEENUM_Unspecified},
-    {0xb1271067, L"batchOptimistic", XFA_ATTRIBUTEENUM_BatchOptimistic},
-    {0xb18313a1, L"bold", XFA_ATTRIBUTEENUM_Bold},
-    {0xb1833cad, L"both", XFA_ATTRIBUTEENUM_Both},
-    {0xb221123f, L"butt", XFA_ATTRIBUTEENUM_Butt},
-    {0xb40c36bf, L"client", XFA_ATTRIBUTEENUM_Client},
-    {0xb56c7053, L"2mod10", XFA_ATTRIBUTEENUM_2mod10},
-    {0xb683a345, L"imageOnly", XFA_ATTRIBUTEENUM_ImageOnly},
-    {0xb7732dea, L"horizontal", XFA_ATTRIBUTEENUM_Horizontal},
-    {0xb88652a4, L"dotted", XFA_ATTRIBUTEENUM_Dotted},
-    {0xbb2f2880, L"userControl", XFA_ATTRIBUTEENUM_UserControl},
-    {0xbbb79c5d, L"diagonalRight", XFA_ATTRIBUTEENUM_DiagonalRight},
-    {0xbd077154, L"consumeData", XFA_ATTRIBUTEENUM_ConsumeData},
-    {0xbd3fb11e, L"check", XFA_ATTRIBUTEENUM_Check},
-    {0xbde9abda, L"data", XFA_ATTRIBUTEENUM_Data},
-    {0xbf5a02d8, L"down", XFA_ATTRIBUTEENUM_Down},
-    {0xbf7450ee, L"sansSerif", XFA_ATTRIBUTEENUM_SansSerif},
-    {0xc02d649f, L"inline", XFA_ATTRIBUTEENUM_Inline},
-    {0xc11a9e3a, L"TraditionalChinese", XFA_ATTRIBUTEENUM_TraditionalChinese},
-    {0xc16169d8, L"warn", XFA_ATTRIBUTEENUM_Warn},
-    {0xc16f071f, L"refOnly", XFA_ATTRIBUTEENUM_RefOnly},
-    {0xc27c8ba5, L"interactiveForms", XFA_ATTRIBUTEENUM_InteractiveForms},
-    {0xc2d1b15c, L"word", XFA_ATTRIBUTEENUM_Word},
-    {0xc3621288, L"unordered", XFA_ATTRIBUTEENUM_Unordered},
-    {0xc5251981, L"required", XFA_ATTRIBUTEENUM_Required},
-    {0xc7088e7d, L"importOnly", XFA_ATTRIBUTEENUM_ImportOnly},
-    {0xc72cf0e3, L"belowEmbedded", XFA_ATTRIBUTEENUM_BelowEmbedded},
-    {0xc819cf07, L"Japanese", XFA_ATTRIBUTEENUM_Japanese},
-    {0xcdce56b3, L"full", XFA_ATTRIBUTEENUM_Full},
-    {0xce0122e3, L"rl-row", XFA_ATTRIBUTEENUM_Rl_row},
-    {0xcf7d71f1, L"Vietnamese", XFA_ATTRIBUTEENUM_Vietnamese},
-    {0xcfde3e09, L"EastEuropeanRoman", XFA_ATTRIBUTEENUM_EastEuropeanRoman},
-    {0xd576d08e, L"mouseUp", XFA_ATTRIBUTEENUM_MouseUp},
-    {0xd7a92904, L"exportOnly", XFA_ATTRIBUTEENUM_ExportOnly},
-    {0xd8ed1467, L"clear", XFA_ATTRIBUTEENUM_Clear},
-    {0xd95657a6, L"click", XFA_ATTRIBUTEENUM_Click},
-    {0xd96c7de5, L"base64", XFA_ATTRIBUTEENUM_Base64},
-    {0xd9f47f36, L"close", XFA_ATTRIBUTEENUM_Close},
-    {0xdb075bde, L"host", XFA_ATTRIBUTEENUM_Host},
-    {0xdb103411, L"global", XFA_ATTRIBUTEENUM_Global},
-    {0xdb647188, L"blank", XFA_ATTRIBUTEENUM_Blank},
-    {0xdb9be968, L"table", XFA_ATTRIBUTEENUM_Table},
-    {0xdf590fbb, L"import", XFA_ATTRIBUTEENUM_Import},
-    {0xe0e573fb, L"custom", XFA_ATTRIBUTEENUM_Custom},
-    {0xe0ecc79a, L"middleLeft", XFA_ATTRIBUTEENUM_MiddleLeft},
-    {0xe1452019, L"postExecute", XFA_ATTRIBUTEENUM_PostExecute},
-    {0xe1911d98, L"radix", XFA_ATTRIBUTEENUM_Radix},
-    {0xe25fa7b8, L"postOpen", XFA_ATTRIBUTEENUM_PostOpen},
-    {0xe28dce7e, L"enter", XFA_ATTRIBUTEENUM_Enter},
-    {0xe2c44de4, L"ignore", XFA_ATTRIBUTEENUM_Ignore},
-    {0xe2cd8c61, L"lr-tb", XFA_ATTRIBUTEENUM_Lr_tb},
-    {0xe2da8336, L"fantasy", XFA_ATTRIBUTEENUM_Fantasy},
-    {0xe31d5396, L"italic", XFA_ATTRIBUTEENUM_Italic},
-    {0xe7ada113, L"author", XFA_ATTRIBUTEENUM_Author},
-    {0xe8e7cc18, L"toEdge", XFA_ATTRIBUTEENUM_ToEdge},
-    {0xe97aa98b, L"choice", XFA_ATTRIBUTEENUM_Choice},
-    {0xeafd2a38, L"disabled", XFA_ATTRIBUTEENUM_Disabled},
-    {0xeb2b7972, L"crossHatch", XFA_ATTRIBUTEENUM_CrossHatch},
-    {0xeb2db2d7, L"dataRef", XFA_ATTRIBUTEENUM_DataRef},
-    {0xec35dc6e, L"dashDotDot", XFA_ATTRIBUTEENUM_DashDotDot},
-    {0xef85d351, L"square", XFA_ATTRIBUTEENUM_Square},
-    {0xf2102445, L"dynamic", XFA_ATTRIBUTEENUM_Dynamic},
-    {0xf272c7be, L"manual", XFA_ATTRIBUTEENUM_Manual},
-    {0xf2bbb64d, L"etched", XFA_ATTRIBUTEENUM_Etched},
-    {0xf3b8fc6c, L"validationState", XFA_ATTRIBUTEENUM_ValidationState},
-    {0xf42f2b81, L"cursive", XFA_ATTRIBUTEENUM_Cursive},
-    {0xf54481d4, L"last", XFA_ATTRIBUTEENUM_Last},
-    {0xf5ad782b, L"left", XFA_ATTRIBUTEENUM_Left},
-    {0xf616da2e, L"link", XFA_ATTRIBUTEENUM_Link},
-    {0xf6b4afb0, L"long", XFA_ATTRIBUTEENUM_Long},
-    {0xf8636460, L"internationalCarrier",
-     XFA_ATTRIBUTEENUM_InternationalCarrier},
-    {0xf9fb37ac, L"PDF1.3", XFA_ATTRIBUTEENUM_PDF1_3},
-    {0xf9fb37af, L"PDF1.6", XFA_ATTRIBUTEENUM_PDF1_6},
-    {0xfbce7f19, L"serif", XFA_ATTRIBUTEENUM_Serif},
-    {0xfc82d695, L"postSave", XFA_ATTRIBUTEENUM_PostSave},
-    {0xfcef86b5, L"ready", XFA_ATTRIBUTEENUM_Ready},
-    {0xfd54fbb7, L"postSign", XFA_ATTRIBUTEENUM_PostSign},
-    {0xfdc0aae2, L"Arabic", XFA_ATTRIBUTEENUM_Arabic},
-    {0xfe06d2ca, L"error", XFA_ATTRIBUTEENUM_Error},
-    {0xfefc4885, L"urlencoded", XFA_ATTRIBUTEENUM_Urlencoded},
-    {0xff795ad2, L"lowered", XFA_ATTRIBUTEENUM_Lowered},
-};
-const int32_t g_iXFAEnumCount =
-    sizeof(g_XFAEnumData) / sizeof(XFA_ATTRIBUTEENUMINFO);
-static const CXFA_Measurement g_XFAMeasurementData[] = {
-    CXFA_Measurement(0, XFA_UNIT_In),
-    CXFA_Measurement(0, XFA_UNIT_Pt),
-    CXFA_Measurement(5, XFA_UNIT_Mm),
-    CXFA_Measurement(0.25, XFA_UNIT_Mm),
-    CXFA_Measurement(-1, XFA_UNIT_Unknown),
-    CXFA_Measurement(0, XFA_UNIT_Angle),
-    CXFA_Measurement(10, XFA_UNIT_Pt),
-    CXFA_Measurement(360, XFA_UNIT_Angle),
-    CXFA_Measurement(0.5, XFA_UNIT_Pt),
-};
-const XFA_ATTRIBUTEINFO g_XFAAttributeData[] = {
-    {0x68, L"h", XFA_ATTRIBUTE_H, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x77, L"w", XFA_ATTRIBUTE_W, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x78, L"x", XFA_ATTRIBUTE_X, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x79, L"y", XFA_ATTRIBUTE_Y, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x21aed, L"id", XFA_ATTRIBUTE_Id, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x25363, L"to", XFA_ATTRIBUTE_To, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Config, (void*)NULL},
-    {0xcb0ac9, L"lineThrough", XFA_ATTRIBUTE_LineThrough,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x2282c73, L"hAlign", XFA_ATTRIBUTE_HAlign, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Left},
-    {0x2c1c7f1, L"typeface", XFA_ATTRIBUTE_Typeface, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"Courier"},
-    {0x3106c3a, L"beforeTarget", XFA_ATTRIBUTE_BeforeTarget,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x31b19c1, L"name", XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet |
-         XFA_XDPPACKET_Template | XFA_XDPPACKET_Datasets | XFA_XDPPACKET_Form |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x3848b3f, L"next", XFA_ATTRIBUTE_Next, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {0x43e349b, L"dataRowCount", XFA_ATTRIBUTE_DataRowCount,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x5518c25, L"break", XFA_ATTRIBUTE_Break, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Close},
-    {0x5ce6195, L"vScrollPolicy", XFA_ATTRIBUTE_VScrollPolicy,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0x8c74ae9, L"fontHorizontalScale", XFA_ATTRIBUTE_FontHorizontalScale,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"100%"},
-    {0x8d4f1c7, L"textIndent", XFA_ATTRIBUTE_TextIndent,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x97c1c65, L"context", XFA_ATTRIBUTE_Context, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_UNKNOWN, (void*)0},
-    {0x9876578, L"trayOut", XFA_ATTRIBUTE_TrayOut, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0xa2e3514, L"cap", XFA_ATTRIBUTE_Cap, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Square},
-    {0xb3543a6, L"max", XFA_ATTRIBUTE_Max, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xb356ca4, L"min", XFA_ATTRIBUTE_Min, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)1},
-    {0xbb8df5d, L"ref", XFA_ATTRIBUTE_Ref, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Config | XFA_XDPPACKET_Template |
-         XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xbb8f3df, L"rid", XFA_ATTRIBUTE_Rid, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xc080cd3, L"url", XFA_ATTRIBUTE_Url, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xc0811ed, L"use", XFA_ATTRIBUTE_Use, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xcfea02e, L"leftInset", XFA_ATTRIBUTE_LeftInset,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x1026c59d, L"widows", XFA_ATTRIBUTE_Widows, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x1059ec18, L"level", XFA_ATTRIBUTE_Level, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Config, (void*)0},
-    {0x1356caf8, L"bottomInset", XFA_ATTRIBUTE_BottomInset,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x13a08bdb, L"overflowTarget", XFA_ATTRIBUTE_OverflowTarget,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x1414d431, L"allowMacro", XFA_ATTRIBUTE_AllowMacro,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x14a32d52, L"pagePosition", XFA_ATTRIBUTE_PagePosition,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Any},
-    {0x1517dfa1, L"columnWidths", XFA_ATTRIBUTE_ColumnWidths,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x169134a1, L"overflowLeader", XFA_ATTRIBUTE_OverflowLeader,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x1b8dce3e, L"action", XFA_ATTRIBUTE_Action, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Include},
-    {0x1e459b8f, L"nonRepudiation", XFA_ATTRIBUTE_NonRepudiation,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x1ec8ab2c, L"rate", XFA_ATTRIBUTE_Rate, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)50},
-    {0x1ef3a64a, L"allowRichText", XFA_ATTRIBUTE_AllowRichText,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x2038c9b2, L"role", XFA_ATTRIBUTE_Role, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x20914367, L"overflowTrailer", XFA_ATTRIBUTE_OverflowTrailer,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x226ca8f1, L"operation", XFA_ATTRIBUTE_Operation,
-     XFA_ATTRIBUTETYPE_NOTSURE, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x24d85167, L"timeout", XFA_ATTRIBUTE_Timeout, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_SourceSet, (void*)NULL},
-    {0x25764436, L"topInset", XFA_ATTRIBUTE_TopInset, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x25839852, L"access", XFA_ATTRIBUTE_Access, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Open},
-    {0x268b7ec1, L"commandType", XFA_ATTRIBUTE_CommandType,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_SourceSet,
-     (void*)XFA_ATTRIBUTEENUM_Unknown},
-    {0x28dee6e9, L"format", XFA_ATTRIBUTE_Format, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x28e17e91, L"dataPrep", XFA_ATTRIBUTE_DataPrep, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {0x292b88fe, L"widgetData", XFA_ATTRIBUTE_WidgetData,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_UNKNOWN, (void*)0},
-    {0x29418bb7, L"abbr", XFA_ATTRIBUTE_Abbr, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_LocaleSet, (void*)0},
-    {0x2a82d99c, L"marginRight", XFA_ATTRIBUTE_MarginRight,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x2b5df51e, L"dataDescription", XFA_ATTRIBUTE_DataDescription,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_ConnectionSet, (void*)NULL},
-    {0x2bb3f470, L"encipherOnly", XFA_ATTRIBUTE_EncipherOnly,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x2cd79033, L"kerningMode", XFA_ATTRIBUTE_KerningMode,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {0x2ee7678f, L"rotate", XFA_ATTRIBUTE_Rotate, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 5)},
-    {0x2f105f72, L"wordCharacterCount", XFA_ATTRIBUTE_WordCharacterCount,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)7},
-    {0x2f16a382, L"type", XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x34ae103c, L"reserve", XFA_ATTRIBUTE_Reserve, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 4)},
-    {0x3650557e, L"textLocation", XFA_ATTRIBUTE_TextLocation,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Below},
-    {0x39cdb0a2, L"priority", XFA_ATTRIBUTE_Priority, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Custom},
-    {0x3a0273a6, L"underline", XFA_ATTRIBUTE_Underline,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x3b582286, L"moduleWidth", XFA_ATTRIBUTE_ModuleWidth,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 3)},
-    {0x3d123c26, L"hyphenate", XFA_ATTRIBUTE_Hyphenate,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x3e7af94f, L"listen", XFA_ATTRIBUTE_Listen, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_RefOnly},
-    {0x4156ee3f, L"delimiter", XFA_ATTRIBUTE_Delimiter, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x42fed1fd, L"contentType", XFA_ATTRIBUTE_ContentType,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template |
-                                  XFA_XDPPACKET_Datasets | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x453eaf38, L"startNew", XFA_ATTRIBUTE_StartNew, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x45a6daf8, L"eofAction", XFA_ATTRIBUTE_EofAction, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_SourceSet, (void*)XFA_ATTRIBUTEENUM_MoveLast},
-    {0x47cfa43a, L"allowNeutral", XFA_ATTRIBUTE_AllowNeutral,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x47d03490, L"connection", XFA_ATTRIBUTE_Connection,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x4873c601, L"baselineShift", XFA_ATTRIBUTE_BaselineShift,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x4b319767, L"overlinePeriod", XFA_ATTRIBUTE_OverlinePeriod,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_All},
-    {0x4b8bc840, L"fracDigits", XFA_ATTRIBUTE_FracDigits,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)2},
-    {0x4ef3d02c, L"orientation", XFA_ATTRIBUTE_Orientation,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Portrait},
-    {0x4fdc3454, L"timeStamp", XFA_ATTRIBUTE_TimeStamp, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_XDP, (void*)NULL},
-    {0x52666f1c, L"printCheckDigit", XFA_ATTRIBUTE_PrintCheckDigit,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x534729c9, L"marginLeft", XFA_ATTRIBUTE_MarginLeft,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x5392ea58, L"stroke", XFA_ATTRIBUTE_Stroke, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Solid},
-    {0x5404d6df, L"moduleHeight", XFA_ATTRIBUTE_ModuleHeight,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 2)},
-    {0x54fa722c, L"transferEncoding", XFA_ATTRIBUTE_TransferEncoding,
-     XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x552d9ad5, L"usage", XFA_ATTRIBUTE_Usage, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_ExportAndImport},
-    {0x570ce835, L"presence", XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Visible},
-    {0x5739d1ff, L"radixOffset", XFA_ATTRIBUTE_RadixOffset,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x577682ac, L"preserve", XFA_ATTRIBUTE_Preserve, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x58be2870, L"aliasNode", XFA_ATTRIBUTE_AliasNode,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_UNKNOWN, (void*)0},
-    {0x5a32e493, L"multiLine", XFA_ATTRIBUTE_MultiLine,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x5a50e9e6, L"version", XFA_ATTRIBUTE_Version, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x5ab23b6c, L"startChar", XFA_ATTRIBUTE_StartChar, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x5b707a35, L"scriptTest", XFA_ATTRIBUTE_ScriptTest,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Error},
-    {0x5c054755, L"startAngle", XFA_ATTRIBUTE_StartAngle,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 5)},
-    {0x5ec958c0, L"cursorType", XFA_ATTRIBUTE_CursorType,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_SourceSet,
-     (void*)XFA_ATTRIBUTEENUM_ForwardOnly},
-    {0x5f760b50, L"digitalSignature", XFA_ATTRIBUTE_DigitalSignature,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x60a61edd, L"codeType", XFA_ATTRIBUTE_CodeType, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x60d4c8b1, L"output", XFA_ATTRIBUTE_Output, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_ConnectionSet, (void*)NULL},
-    {0x64110ab5, L"bookendTrailer", XFA_ATTRIBUTE_BookendTrailer,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x65e30c67, L"imagingBBox", XFA_ATTRIBUTE_ImagingBBox,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"none"},
-    {0x66539c48, L"excludeInitialCap", XFA_ATTRIBUTE_ExcludeInitialCap,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x66642f8f, L"force", XFA_ATTRIBUTE_Force, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Config, (void*)NULL},
-    {0x69aa2292, L"crlSign", XFA_ATTRIBUTE_CrlSign, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x6a3405dd, L"previous", XFA_ATTRIBUTE_Previous, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {0x6a95c976, L"pushCharacterCount", XFA_ATTRIBUTE_PushCharacterCount,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)3},
-    {0x6b6ddcfb, L"nullTest", XFA_ATTRIBUTE_NullTest, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Disabled},
-    {0x6cfa828a, L"runAt", XFA_ATTRIBUTE_RunAt, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Client},
-    {0x731e0665, L"spaceBelow", XFA_ATTRIBUTE_SpaceBelow,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x74788f8b, L"sweepAngle", XFA_ATTRIBUTE_SweepAngle,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 7)},
-    {0x78bff531, L"numberOfCells", XFA_ATTRIBUTE_NumberOfCells,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0x79543055, L"letterSpacing", XFA_ATTRIBUTE_LetterSpacing,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x79975f2b, L"lockType", XFA_ATTRIBUTE_LockType, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_SourceSet, (void*)XFA_ATTRIBUTEENUM_ReadOnly},
-    {0x7a0cc471, L"passwordChar", XFA_ATTRIBUTE_PasswordChar,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"*"},
-    {0x7a7cc341, L"vAlign", XFA_ATTRIBUTE_VAlign, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)XFA_ATTRIBUTEENUM_Top},
-    {0x7b29630a, L"sourceBelow", XFA_ATTRIBUTE_SourceBelow,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Config,
-     (void*)XFA_ATTRIBUTEENUM_Update},
-    {0x7b95e661, L"inverted", XFA_ATTRIBUTE_Inverted, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x7c2fd80b, L"mark", XFA_ATTRIBUTE_Mark, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Default},
-    {0x7c2ff6ae, L"maxH", XFA_ATTRIBUTE_MaxH, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x7c2ff6bd, L"maxW", XFA_ATTRIBUTE_MaxW, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x7c732a66, L"truncate", XFA_ATTRIBUTE_Truncate, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x7d02356c, L"minH", XFA_ATTRIBUTE_MinH, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x7d02357b, L"minW", XFA_ATTRIBUTE_MinW, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x7d0b5fca, L"initial", XFA_ATTRIBUTE_Initial, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)1},
-    {0x7d9fd7c5, L"mode", XFA_ATTRIBUTE_Mode, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Config, (void*)XFA_ATTRIBUTEENUM_UsePrinterSetting},
-    {0x7e7e845e, L"layout", XFA_ATTRIBUTE_Layout, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Position},
-    {0x7f6fd3d7, L"server", XFA_ATTRIBUTE_Server, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x824f21b7, L"embedPDF", XFA_ATTRIBUTE_EmbedPDF, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x8340ea66, L"oddOrEven", XFA_ATTRIBUTE_OddOrEven, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)XFA_ATTRIBUTEENUM_Any},
-    {0x836d4d7c, L"tabDefault", XFA_ATTRIBUTE_TabDefault,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x8855805f, L"contains", XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Datasets, (void*)XFA_ATTRIBUTEENUM_Data},
-    {0x8a692521, L"rightInset", XFA_ATTRIBUTE_RightInset,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x8af2e657, L"maxChars", XFA_ATTRIBUTE_MaxChars, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x8b90e1f2, L"open", XFA_ATTRIBUTE_Open, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_UserControl},
-    {0x8c99377e, L"relation", XFA_ATTRIBUTE_Relation, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x8d181d61, L"wideNarrowRatio", XFA_ATTRIBUTE_WideNarrowRatio,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"3:1"},
-    {0x8e1c2921, L"relevant", XFA_ATTRIBUTE_Relevant, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x8e29d794, L"signatureType", XFA_ATTRIBUTE_SignatureType,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Filter},
-    {0x8ec6204c, L"lineThroughPeriod", XFA_ATTRIBUTE_LineThroughPeriod,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_All},
-    {0x8ed182d1, L"shape", XFA_ATTRIBUTE_Shape, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Square},
-    {0x8fa01790, L"tabStops", XFA_ATTRIBUTE_TabStops, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0x8fc36c0a, L"outputBelow", XFA_ATTRIBUTE_OutputBelow,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Config,
-     (void*)XFA_ATTRIBUTEENUM_Warn},
-    {0x9041d4b0, L"short", XFA_ATTRIBUTE_Short, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0x907c7719, L"fontVerticalScale", XFA_ATTRIBUTE_FontVerticalScale,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"100%"},
-    {0x94446dcc, L"thickness", XFA_ATTRIBUTE_Thickness,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 8)},
-    {0x957fa006, L"commitOn", XFA_ATTRIBUTE_CommitOn, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Select},
-    {0x982bd892, L"remainCharacterCount", XFA_ATTRIBUTE_RemainCharacterCount,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)3},
-    {0x98fd4d81, L"keyAgreement", XFA_ATTRIBUTE_KeyAgreement,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x99800d7a, L"errorCorrectionLevel", XFA_ATTRIBUTE_ErrorCorrectionLevel,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0x9a63da3d, L"upsMode", XFA_ATTRIBUTE_UpsMode, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_UsCarrier},
-    {0x9cc17d75, L"mergeMode", XFA_ATTRIBUTE_MergeMode, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_ConsumeData},
-    {0x9d833d75, L"circular", XFA_ATTRIBUTE_Circular, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0x9d8ee204, L"psName", XFA_ATTRIBUTE_PsName, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Config, (void*)NULL},
-    {0x9dcc3ab3, L"trailer", XFA_ATTRIBUTE_Trailer, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xa0933954, L"unicodeRange", XFA_ATTRIBUTE_UnicodeRange,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Config, (void*)NULL},
-    {0xa1b0d2f5, L"executeType", XFA_ATTRIBUTE_ExecuteType,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Import},
-    {0xa25a883d, L"duplexImposition", XFA_ATTRIBUTE_DuplexImposition,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_LongEdge},
-    {0xa42ca1b7, L"trayIn", XFA_ATTRIBUTE_TrayIn, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0xa433f001, L"bindingNode", XFA_ATTRIBUTE_BindingNode,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_UNKNOWN, (void*)0},
-    {0xa5340ff5, L"bofAction", XFA_ATTRIBUTE_BofAction, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_SourceSet, (void*)XFA_ATTRIBUTEENUM_MoveFirst},
-    {0xa5b410cf, L"save", XFA_ATTRIBUTE_Save, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0xa6118c89, L"targetType", XFA_ATTRIBUTE_TargetType,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0xa66404cb, L"keyEncipherment", XFA_ATTRIBUTE_KeyEncipherment,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xa6710262, L"credentialServerPolicy",
-     XFA_ATTRIBUTE_CredentialServerPolicy, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {0xa686975b, L"size", XFA_ATTRIBUTE_Size, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 6)},
-    {0xa85e74f3, L"initialNumber", XFA_ATTRIBUTE_InitialNumber,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)1},
-    {0xabef37e3, L"slope", XFA_ATTRIBUTE_Slope, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Backslash},
-    {0xabfa6c4f, L"cSpace", XFA_ATTRIBUTE_CSpace, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)L"SRGB"},
-    {0xac06e2b0, L"colSpan", XFA_ATTRIBUTE_ColSpan, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)1},
-    {0xadc4c77b, L"binding", XFA_ATTRIBUTE_Binding, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xaf754613, L"checksum", XFA_ATTRIBUTE_Checksum, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xb045fbc5, L"charEncoding", XFA_ATTRIBUTE_CharEncoding,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)L"UTF-8"},
-    {0xb0e5485d, L"bind", XFA_ATTRIBUTE_Bind, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet, (void*)NULL},
-    {0xb12128b7, L"textEntry", XFA_ATTRIBUTE_TextEntry,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0xb373a862, L"archive", XFA_ATTRIBUTE_Archive, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xb598a1f7, L"uuid", XFA_ATTRIBUTE_Uuid, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_XDP, (void*)NULL},
-    {0xb5e49bf2, L"posture", XFA_ATTRIBUTE_Posture, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Normal},
-    {0xb6b44172, L"after", XFA_ATTRIBUTE_After, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0xb716467b, L"orphans", XFA_ATTRIBUTE_Orphans, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0xbc0c4695, L"qualifiedName", XFA_ATTRIBUTE_QualifiedName,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_UNKNOWN, (void*)NULL},
-    {0xbc254332, L"usehref", XFA_ATTRIBUTE_Usehref, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xbc8fa350, L"locale", XFA_ATTRIBUTE_Locale, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xbd6e1d88, L"weight", XFA_ATTRIBUTE_Weight, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Normal},
-    {0xbd96a0e9, L"underlinePeriod", XFA_ATTRIBUTE_UnderlinePeriod,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_All},
-    {0xbde9abda, L"data", XFA_ATTRIBUTE_Data, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Link},
-    {0xbe52dfbf, L"desc", XFA_ATTRIBUTE_Desc, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet, (void*)NULL},
-    {0xbe9ba472, L"numbered", XFA_ATTRIBUTE_Numbered, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)1},
-    {0xc035c6b1, L"dataColumnCount", XFA_ATTRIBUTE_DataColumnCount,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xc0ec9fa4, L"overline", XFA_ATTRIBUTE_Overline, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0xc2ba0923, L"urlPolicy", XFA_ATTRIBUTE_UrlPolicy, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xc2bd40fd, L"anchorType", XFA_ATTRIBUTE_AnchorType,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_TopLeft},
-    {0xc39a88bd, L"labelRef", XFA_ATTRIBUTE_LabelRef, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xc3c1442f, L"bookendLeader", XFA_ATTRIBUTE_BookendLeader,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xc4547a08, L"maxLength", XFA_ATTRIBUTE_MaxLength,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*) - 1},
-    {0xc4fed09b, L"accessKey", XFA_ATTRIBUTE_AccessKey, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xc5762157, L"cursorLocation", XFA_ATTRIBUTE_CursorLocation,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_SourceSet,
-     (void*)XFA_ATTRIBUTEENUM_Client},
-    {0xc860f30a, L"delayedOpen", XFA_ATTRIBUTE_DelayedOpen,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_SourceSet, (void*)NULL},
-    {0xc8da4da7, L"target", XFA_ATTRIBUTE_Target, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xca5dc27c, L"dataEncipherment", XFA_ATTRIBUTE_DataEncipherment,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xcb150479, L"afterTarget", XFA_ATTRIBUTE_AfterTarget,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xcbcaf66d, L"leader", XFA_ATTRIBUTE_Leader, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xcca7897e, L"picker", XFA_ATTRIBUTE_Picker, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Host},
-    {0xcd7f7b54, L"from", XFA_ATTRIBUTE_From, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Config, (void*)NULL},
-    {0xcea5e62c, L"baseProfile", XFA_ATTRIBUTE_BaseProfile,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Full},
-    {0xd171b240, L"aspect", XFA_ATTRIBUTE_Aspect, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)XFA_ATTRIBUTEENUM_Fit},
-    {0xd3c84d25, L"rowColumnRatio", XFA_ATTRIBUTE_RowColumnRatio,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xd4b01921, L"lineHeight", XFA_ATTRIBUTE_LineHeight,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 1)},
-    {0xd4cc53f8, L"highlight", XFA_ATTRIBUTE_Highlight, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Inverted},
-    {0xd50f903a, L"valueRef", XFA_ATTRIBUTE_ValueRef, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xd52482e0, L"maxEntries", XFA_ATTRIBUTE_MaxEntries,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Config, (void*)5},
-    {0xd57c513c, L"dataLength", XFA_ATTRIBUTE_DataLength,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xd6128d8d, L"activity", XFA_ATTRIBUTE_Activity, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Click},
-    {0xd6a39990, L"input", XFA_ATTRIBUTE_Input, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_ConnectionSet, (void*)NULL},
-    {0xd6e27f1d, L"value", XFA_ATTRIBUTE_Value, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet |
-         XFA_XDPPACKET_Template | XFA_XDPPACKET_Datasets |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xd70798c2, L"blankOrNotBlank", XFA_ATTRIBUTE_BlankOrNotBlank,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Any},
-    {0xd861f8af, L"addRevocationInfo", XFA_ATTRIBUTE_AddRevocationInfo,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xd8f982bf, L"genericFamily", XFA_ATTRIBUTE_GenericFamily,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Config,
-     (void*)XFA_ATTRIBUTEENUM_Serif},
-    {0xd996fa9b, L"hand", XFA_ATTRIBUTE_Hand, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Even},
-    {0xdb55fec5, L"href", XFA_ATTRIBUTE_Href, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xdc75676c, L"textEncoding", XFA_ATTRIBUTE_TextEncoding,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xde7f92ba, L"leadDigits", XFA_ATTRIBUTE_LeadDigits,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*) - 1},
-    {0xe11a2cbc, L"permissions", XFA_ATTRIBUTE_Permissions,
-     XFA_ATTRIBUTETYPE_Integer, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)2},
-    {0xe18b5659, L"spaceAbove", XFA_ATTRIBUTE_SpaceAbove,
-     XFA_ATTRIBUTETYPE_Measure, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0xe1a26b56, L"codeBase", XFA_ATTRIBUTE_CodeBase, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xe349d044, L"stock", XFA_ATTRIBUTE_Stock, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xe372ae97, L"isNull", XFA_ATTRIBUTE_IsNull, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Datasets, (void*)0},
-    {0xe4c3a5e5, L"restoreState", XFA_ATTRIBUTE_RestoreState,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Manual},
-    {0xe5c96d6a, L"excludeAllCaps", XFA_ATTRIBUTE_ExcludeAllCaps,
-     XFA_ATTRIBUTETYPE_Boolean, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)0},
-    {0xe64b1129, L"formatTest", XFA_ATTRIBUTE_FormatTest,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Warning},
-    {0xe6f99487, L"hScrollPolicy", XFA_ATTRIBUTE_HScrollPolicy,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0xe8dddf50, L"join", XFA_ATTRIBUTE_Join, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Square},
-    {0xe8f118a8, L"keyCertSign", XFA_ATTRIBUTE_KeyCertSign,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xe948b9a8, L"radius", XFA_ATTRIBUTE_Radius, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0xe996b2fe, L"sourceAbove", XFA_ATTRIBUTE_SourceAbove,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Config,
-     (void*)XFA_ATTRIBUTEENUM_Warn},
-    {0xea7090a0, L"override", XFA_ATTRIBUTE_Override, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xeb091003, L"classId", XFA_ATTRIBUTE_ClassId, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xeb511b54, L"disable", XFA_ATTRIBUTE_Disable, XFA_ATTRIBUTETYPE_Boolean,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)0},
-    {0xeda9017a, L"scope", XFA_ATTRIBUTE_Scope, XFA_ATTRIBUTETYPE_NOTSURE,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xf197844d, L"match", XFA_ATTRIBUTE_Match, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Once},
-    {0xf2009339, L"placement", XFA_ATTRIBUTE_Placement, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Left},
-    {0xf4ffce73, L"before", XFA_ATTRIBUTE_Before, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_Auto},
-    {0xf531b059, L"writingScript", XFA_ATTRIBUTE_WritingScript,
-     XFA_ATTRIBUTETYPE_Enum, XFA_XDPPACKET_Config,
-     (void*)XFA_ATTRIBUTEENUM_Asterisk},
-    {0xf575ca75, L"endChar", XFA_ATTRIBUTE_EndChar, XFA_ATTRIBUTETYPE_Cdata,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, (void*)NULL},
-    {0xf6b47749, L"lock", XFA_ATTRIBUTE_Lock, XFA_ATTRIBUTETYPE_Integer,
-     XFA_XDPPACKET_Config, (void*)0},
-    {0xf6b4afb0, L"long", XFA_ATTRIBUTE_Long, XFA_ATTRIBUTETYPE_Measure,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)(g_XFAMeasurementData + 0)},
-    {0xf6b59543, L"intact", XFA_ATTRIBUTE_Intact, XFA_ATTRIBUTETYPE_Enum,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {0xf889e747, L"xdpContent", XFA_ATTRIBUTE_XdpContent,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-    {0xfea53ec6, L"decipherOnly", XFA_ATTRIBUTE_DecipherOnly,
-     XFA_ATTRIBUTETYPE_Cdata, XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     (void*)NULL},
-};
-const int32_t g_iXFAAttributeCount =
-    sizeof(g_XFAAttributeData) / sizeof(XFA_ATTRIBUTEINFO);
-const XFA_NOTSUREATTRIBUTE g_XFANotsureAttributes[] = {
-    {XFA_ELEMENT_SubformSet, XFA_ATTRIBUTE_Relation, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Ordered},
-    {XFA_ELEMENT_NumberPattern, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Numeric},
-    {XFA_ELEMENT_KeyUsage, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_LabelPrinter, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Zpl},
-    {XFA_ELEMENT_CalendarSymbols, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Gregorian},
-    {XFA_ELEMENT_Barcode, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Cdata,
-     (void*)NULL},
-    {XFA_ELEMENT_Barcode, XFA_ATTRIBUTE_Checksum, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {XFA_ELEMENT_TimePattern, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Med},
-    {XFA_ELEMENT_BatchOutput, XFA_ATTRIBUTE_Format, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {XFA_ELEMENT_SubjectDNs, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Issuers, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_EncryptionMethods, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Pattern, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_CrossHatch},
-    {XFA_ELEMENT_Compress, XFA_ATTRIBUTE_Scope, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_ImageOnly},
-    {XFA_ELEMENT_Image, XFA_ATTRIBUTE_TransferEncoding, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Base64},
-    {XFA_ELEMENT_TimeStamp, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Subform, XFA_ATTRIBUTE_Scope, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Name},
-    {XFA_ELEMENT_Handler, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Record, XFA_ATTRIBUTE_Max, XFA_ATTRIBUTETYPE_Integer,
-     (void*)0},
-    {XFA_ELEMENT_Command, XFA_ATTRIBUTE_Timeout, XFA_ATTRIBUTETYPE_Integer,
-     (void*)30},
-    {XFA_ELEMENT_DigestMethods, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_PageSet, XFA_ATTRIBUTE_Relation, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_OrderedOccurrence},
-    {XFA_ELEMENT_Equate, XFA_ATTRIBUTE_From, XFA_ATTRIBUTETYPE_Cdata,
-     (void*)NULL},
-    {XFA_ELEMENT_Equate, XFA_ATTRIBUTE_To, XFA_ATTRIBUTETYPE_Cdata,
-     (void*)NULL},
-    {XFA_ELEMENT_Traverse, XFA_ATTRIBUTE_Operation, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Next},
-    {XFA_ELEMENT_Encodings, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Signing, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Oids, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Signature, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_PDF1_3},
-    {XFA_ELEMENT_ExData, XFA_ATTRIBUTE_TransferEncoding, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {XFA_ELEMENT_Linear, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_ToRight},
-    {XFA_ELEMENT_CurrencySymbol, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Symbol},
-    {XFA_ELEMENT_EquateRange, XFA_ATTRIBUTE_From, XFA_ATTRIBUTETYPE_Cdata,
-     (void*)NULL},
-    {XFA_ELEMENT_EquateRange, XFA_ATTRIBUTE_To, XFA_ATTRIBUTETYPE_Cdata,
-     (void*)NULL},
-    {XFA_ELEMENT_SignData, XFA_ATTRIBUTE_Operation, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Sign},
-    {XFA_ELEMENT_DatePattern, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Med},
-    {XFA_ELEMENT_Bind, XFA_ATTRIBUTE_TransferEncoding, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_None},
-    {XFA_ELEMENT_Reasons, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_AppearanceFilter, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Form, XFA_ATTRIBUTE_Checksum, XFA_ATTRIBUTETYPE_Cdata,
-     (void*)NULL},
-    {XFA_ELEMENT_Value, XFA_ATTRIBUTE_Override, XFA_ATTRIBUTETYPE_Boolean,
-     (void*)0},
-    {XFA_ELEMENT_Calculate, XFA_ATTRIBUTE_Override, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Error},
-    {XFA_ELEMENT_Connect, XFA_ATTRIBUTE_Timeout, XFA_ATTRIBUTETYPE_Integer,
-     (void*)15},
-    {XFA_ELEMENT_Submit, XFA_ATTRIBUTE_Format, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Xdp},
-    {XFA_ELEMENT_Radial, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_ToEdge},
-    {XFA_ELEMENT_LockDocument, XFA_ATTRIBUTE_Type, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Optional},
-    {XFA_ELEMENT_Occur, XFA_ATTRIBUTE_Max, XFA_ATTRIBUTETYPE_Integer, (void*)1},
-    {XFA_ELEMENT_NumberSymbol, XFA_ATTRIBUTE_Name, XFA_ATTRIBUTETYPE_Enum,
-     (void*)XFA_ATTRIBUTEENUM_Decimal},
-};
-const int32_t g_iXFANotsureCount =
-    sizeof(g_XFANotsureAttributes) / sizeof(XFA_NOTSUREATTRIBUTE);
-const XFA_ELEMENTINFO g_XFAElementData[] = {
-    {0x23ee3, L"ps", XFA_ELEMENT_Ps, XFA_XDPPACKET_Config, XFA_OBJECTTYPE_Node},
-    {0x25363, L"to", XFA_ELEMENT_To, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x2587e, L"ui", XFA_ELEMENT_Ui,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x1c648b, L"recordSet", XFA_ELEMENT_RecordSet, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_Node},
-    {0x171428f, L"subsetBelow", XFA_ELEMENT_SubsetBelow, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x1a0776a, L"subformSet", XFA_ELEMENT_SubformSet,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x2340d70, L"adobeExtensionLevel", XFA_ELEMENT_AdobeExtensionLevel,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x2c1c7f1, L"typeface", XFA_ELEMENT_Typeface, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_Node},
-    {0x5518c25, L"break", XFA_ELEMENT_Break,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x5fff523, L"fontInfo", XFA_ELEMENT_FontInfo, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x653a227, L"numberPattern", XFA_ELEMENT_NumberPattern,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ContentNode},
-    {0x65b4a05, L"dynamicRender", XFA_ELEMENT_DynamicRender,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x7e4362e, L"printScaling", XFA_ELEMENT_PrintScaling, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x7fe6d3a, L"checkButton", XFA_ELEMENT_CheckButton,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x80cf58f, L"datePatterns", XFA_ELEMENT_DatePatterns,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0x811929d, L"sourceSet", XFA_ELEMENT_SourceSet, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_ModelNode},
-    {0x9f9d612, L"amd", XFA_ELEMENT_Amd, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x9f9efb6, L"arc", XFA_ELEMENT_Arc,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xa48835e, L"day", XFA_ELEMENT_Day, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xa6328b8, L"era", XFA_ELEMENT_Era, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xae6a0a0, L"jog", XFA_ELEMENT_Jog, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xb1b3d22, L"log", XFA_ELEMENT_Log, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xb35439e, L"map", XFA_ELEMENT_Map,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_SourceSet, XFA_OBJECTTYPE_Node},
-    {0xb355301, L"mdp", XFA_ELEMENT_Mdp,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xb420438, L"breakBefore", XFA_ELEMENT_BreakBefore,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xb6a091c, L"oid", XFA_ELEMENT_Oid,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0xb84389f, L"pcl", XFA_ELEMENT_Pcl, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xb843dba, L"pdf", XFA_ELEMENT_Pdf, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xbb8df5d, L"ref", XFA_ELEMENT_Ref,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0xc080cd0, L"uri", XFA_ELEMENT_Uri,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_ConnectionSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0xc56afbf, L"xdc", XFA_ELEMENT_Xdc,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Xdc, XFA_OBJECTTYPE_ModelNode},
-    {0xc56afcc, L"xdp", XFA_ELEMENT_Xdp, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xc56b9ff, L"xfa", XFA_ELEMENT_Xfa, XFA_XDPPACKET_XDP,
-     XFA_OBJECTTYPE_ModelNode},
-    {0xc56fcb7, L"xsl", XFA_ELEMENT_Xsl, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xc8b89d6, L"zpl", XFA_ELEMENT_Zpl, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xc9bae94, L"cache", XFA_ELEMENT_Cache, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xcb016be, L"margin", XFA_ELEMENT_Margin,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xe1378fe, L"keyUsage", XFA_ELEMENT_KeyUsage,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xfe3596a, L"exclude", XFA_ELEMENT_Exclude, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x10395ac7, L"choiceList", XFA_ELEMENT_ChoiceList,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x1059ec18, L"level", XFA_ELEMENT_Level, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x10874804, L"labelPrinter", XFA_ELEMENT_LabelPrinter,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_Node},
-    {0x10c40e03, L"calendarSymbols", XFA_ELEMENT_CalendarSymbols,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0x10f1ea24, L"para", XFA_ELEMENT_Para,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x10f1ea37, L"part", XFA_ELEMENT_Part, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x1140975b, L"pdfa", XFA_ELEMENT_Pdfa, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x1154efe6, L"filter", XFA_ELEMENT_Filter,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x13f41de1, L"present", XFA_ELEMENT_Present, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x1827e6ea, L"pagination", XFA_ELEMENT_Pagination, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x18463707, L"encoding", XFA_ELEMENT_Encoding,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_NodeC},
-    {0x185e41e2, L"event", XFA_ELEMENT_Event,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x1adb142d, L"whitespace", XFA_ELEMENT_Whitespace, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x1f3f64c3, L"defaultUi", XFA_ELEMENT_DefaultUi,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x204e87cb, L"dataModel", XFA_ELEMENT_DataModel, XFA_XDPPACKET_Datasets,
-     XFA_OBJECTTYPE_ModelNode},
-    {0x2057b350, L"barcode", XFA_ELEMENT_Barcode,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x20596bad, L"timePattern", XFA_ELEMENT_TimePattern,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ContentNode},
-    {0x210b74d3, L"batchOutput", XFA_ELEMENT_BatchOutput, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x212ff0e2, L"enforce", XFA_ELEMENT_Enforce, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x21d351b4, L"currencySymbols", XFA_ELEMENT_CurrencySymbols,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0x21db83c5, L"addSilentPrint", XFA_ELEMENT_AddSilentPrint,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x22266258, L"rename", XFA_ELEMENT_Rename, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x226ca8f1, L"operation", XFA_ELEMENT_Operation,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_TextNode},
-    {0x23e27b84, L"typefaces", XFA_ELEMENT_Typefaces, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_Node},
-    {0x23f4aa75, L"subjectDNs", XFA_ELEMENT_SubjectDNs,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x240d5e8e, L"issuers", XFA_ELEMENT_Issuers,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x2457a033, L"signaturePseudoModel", XFA_ELEMENT_SignaturePseudoModel,
-     XFA_XDPPACKET_XDP, XFA_OBJECTTYPE_OrdinaryObject},
-    {0x24a52f8a, L"wsdlConnection", XFA_ELEMENT_WsdlConnection,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_Node},
-    {0x254ebd07, L"debug", XFA_ELEMENT_Debug, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x2655c66a, L"delta", XFA_ELEMENT_Delta, XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_OrdinaryObject},
-    {0x26c0daec, L"eraNames", XFA_ELEMENT_EraNames, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_Node},
-    {0x273ab03b, L"modifyAnnots", XFA_ELEMENT_ModifyAnnots,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x27875bb4, L"startNode", XFA_ELEMENT_StartNode, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x285d0dbc, L"button", XFA_ELEMENT_Button,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x28dee6e9, L"format", XFA_ELEMENT_Format,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x2a23349e, L"border", XFA_ELEMENT_Border,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x2ae67f19, L"area", XFA_ELEMENT_Area,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContainerNode},
-    {0x2c3c4c67, L"hyphenation", XFA_ELEMENT_Hyphenation,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x2d08af85, L"text", XFA_ELEMENT_Text,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x2d71b00f, L"time", XFA_ELEMENT_Time,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0x2f16a382, L"type", XFA_ELEMENT_Type, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x2fe057e9, L"overprint", XFA_ELEMENT_Overprint, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x302aee16, L"certificates", XFA_ELEMENT_Certificates,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x30b227df, L"encryptionMethods", XFA_ELEMENT_EncryptionMethods,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x32b900d1, L"setProperty", XFA_ELEMENT_SetProperty,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x337d9e45, L"printerName", XFA_ELEMENT_PrinterName, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x33edda4b, L"startPage", XFA_ELEMENT_StartPage, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x381943e4, L"pageOffset", XFA_ELEMENT_PageOffset, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x382106cd, L"dateTime", XFA_ELEMENT_DateTime,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0x386e7421, L"comb", XFA_ELEMENT_Comb,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x390acd9e, L"pattern", XFA_ELEMENT_Pattern,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x3942163e, L"ifEmpty", XFA_ELEMENT_IfEmpty, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x39944a7b, L"suppressBanner", XFA_ELEMENT_SuppressBanner,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x3b3c3dca, L"outputBin", XFA_ELEMENT_OutputBin, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x3b8a4024, L"field", XFA_ELEMENT_Field,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x3c15352f, L"agent", XFA_ELEMENT_Agent, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x3d7e8668, L"outputXSL", XFA_ELEMENT_OutputXSL, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x3e1c91c5, L"adjustData", XFA_ELEMENT_AdjustData, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x3e7a9408, L"autoSave", XFA_ELEMENT_AutoSave, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x3ecead94, L"contentArea", XFA_ELEMENT_ContentArea,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x3ef334e3, L"eventPseudoModel", XFA_ELEMENT_EventPseudoModel,
-     XFA_XDPPACKET_XDP, XFA_OBJECTTYPE_OrdinaryObject},
-    {0x3fadaec0, L"wsdlAddress", XFA_ELEMENT_WsdlAddress,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_TextNode},
-    {0x40623b5b, L"solid", XFA_ELEMENT_Solid,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x41f0bd76, L"dateTimeSymbols", XFA_ELEMENT_DateTimeSymbols,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ContentNode},
-    {0x444e7523, L"encryptionLevel", XFA_ELEMENT_EncryptionLevel,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x4523af55, L"edge", XFA_ELEMENT_Edge,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x45d5e3c1, L"stipple", XFA_ELEMENT_Stipple,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x475e4e87, L"attributes", XFA_ELEMENT_Attributes, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x487a8c87, L"versionControl", XFA_ELEMENT_VersionControl,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_Node},
-    {0x48e5248c, L"meridiem", XFA_ELEMENT_Meridiem, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x48f36719, L"exclGroup", XFA_ELEMENT_ExclGroup,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x4977356b, L"toolTip", XFA_ELEMENT_ToolTip,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0x499afecc, L"compress", XFA_ELEMENT_Compress, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x4a0c4948, L"reason", XFA_ELEMENT_Reason,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0x4bdcce13, L"execute", XFA_ELEMENT_Execute,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x4c56b216, L"contentCopy", XFA_ELEMENT_ContentCopy, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x4cc176d3, L"dateTimeEdit", XFA_ELEMENT_DateTimeEdit,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x4e1e39b6, L"config", XFA_ELEMENT_Config, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ModelNode},
-    {0x4e2d6083, L"image", XFA_ELEMENT_Image,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0x4e814150, L"#xHTML", XFA_ELEMENT_SharpxHTML,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_SourceSet |
-         XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_NodeV},
-    {0x4f2388c1, L"numberOfCopies", XFA_ELEMENT_NumberOfCopies,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x4f512e30, L"behaviorOverride", XFA_ELEMENT_BehaviorOverride,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x4fdc3454, L"timeStamp", XFA_ELEMENT_TimeStamp,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x51d90546, L"month", XFA_ELEMENT_Month, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x523437e4, L"viewerPreferences", XFA_ELEMENT_ViewerPreferences,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_Node},
-    {0x53abc1c6, L"scriptModel", XFA_ELEMENT_ScriptModel, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x54034c2f, L"decimal", XFA_ELEMENT_Decimal,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0x54202c9e, L"subform", XFA_ELEMENT_Subform,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x542c7300, L"select", XFA_ELEMENT_Select, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0x5436d198, L"window", XFA_ELEMENT_Window, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x5473b6dc, L"localeSet", XFA_ELEMENT_LocaleSet,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ModelNode},
-    {0x56ae179e, L"handler", XFA_ELEMENT_Handler,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0x5700bd5f, L"hostPseudoModel", XFA_ELEMENT_HostPseudoModel,
-     XFA_XDPPACKET_XDP, XFA_OBJECTTYPE_OrdinaryObject},
-    {0x570ce835, L"presence", XFA_ELEMENT_Presence, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x5779d65f, L"record", XFA_ELEMENT_Record, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x59c8f27d, L"embed", XFA_ELEMENT_Embed, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x5a50e9e6, L"version", XFA_ELEMENT_Version, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x5b8383df, L"command", XFA_ELEMENT_Command, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_Node},
-    {0x5c43c6c3, L"copies", XFA_ELEMENT_Copies, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x5e0c2c49, L"staple", XFA_ELEMENT_Staple, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x5e5083dd, L"submitFormat", XFA_ELEMENT_SubmitFormat,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x5e8c5d20, L"boolean", XFA_ELEMENT_Boolean,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x60490a85, L"message", XFA_ELEMENT_Message,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_Node},
-    {0x60d4c8b1, L"output", XFA_ELEMENT_Output, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x61810081, L"psMap", XFA_ELEMENT_PsMap, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x62bd904b, L"excludeNS", XFA_ELEMENT_ExcludeNS, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x669d4f77, L"assist", XFA_ELEMENT_Assist,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x67334a1c, L"picture", XFA_ELEMENT_Picture,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x67fe7334, L"traversal", XFA_ELEMENT_Traversal,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x6894589c, L"silentPrint", XFA_ELEMENT_SilentPrint, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x68a16bbd, L"webClient", XFA_ELEMENT_WebClient, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x69f115df, L"layoutPseudoModel", XFA_ELEMENT_LayoutPseudoModel,
-     XFA_XDPPACKET_XDP, XFA_OBJECTTYPE_OrdinaryObject},
-    {0x6a4bc084, L"producer", XFA_ELEMENT_Producer, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x6a9e04c9, L"corner", XFA_ELEMENT_Corner,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x6ccd7274, L"msgId", XFA_ELEMENT_MsgId, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x6e67921f, L"color", XFA_ELEMENT_Color,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x6ec217a5, L"keep", XFA_ELEMENT_Keep,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x6eef1116, L"query", XFA_ELEMENT_Query, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_Node},
-    {0x7033bfd5, L"insert", XFA_ELEMENT_Insert, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0x704af389, L"imageEdit", XFA_ELEMENT_ImageEdit,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x7233018a, L"validate", XFA_ELEMENT_Validate,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x72ba47b4, L"digestMethods", XFA_ELEMENT_DigestMethods,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x72f2aa7a, L"numberPatterns", XFA_ELEMENT_NumberPatterns,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0x74caed29, L"pageSet", XFA_ELEMENT_PageSet,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x7568e6ae, L"integer", XFA_ELEMENT_Integer,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x76182db9, L"soapAddress", XFA_ELEMENT_SoapAddress,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_TextNode},
-    {0x773146c5, L"equate", XFA_ELEMENT_Equate, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x77d449dd, L"formFieldFilling", XFA_ELEMENT_FormFieldFilling,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x7889d68a, L"pageRange", XFA_ELEMENT_PageRange, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x7baca2e3, L"update", XFA_ELEMENT_Update, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0x7ce89001, L"connectString", XFA_ELEMENT_ConnectString,
-     XFA_XDPPACKET_SourceSet, XFA_OBJECTTYPE_TextNode},
-    {0x7d9fd7c5, L"mode", XFA_ELEMENT_Mode, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x7e7e845e, L"layout", XFA_ELEMENT_Layout, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x7e845c34, L"#xml", XFA_ELEMENT_Sharpxml,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_NodeV},
-    {0x7fb341df, L"xsdConnection", XFA_ELEMENT_XsdConnection,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_Node},
-    {0x7ffb51cc, L"traverse", XFA_ELEMENT_Traverse,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x80203b5a, L"encodings", XFA_ELEMENT_Encodings,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x803550fc, L"template", XFA_ELEMENT_Template,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ModelNode},
-    {0x803d5bbc, L"acrobat", XFA_ELEMENT_Acrobat, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0x821d6569, L"validationMessaging", XFA_ELEMENT_ValidationMessaging,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_NodeV},
-    {0x830e688f, L"signing", XFA_ELEMENT_Signing,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x83a550d2, L"dataWindow", XFA_ELEMENT_DataWindow, XFA_XDPPACKET_Datasets,
-     XFA_OBJECTTYPE_OrdinaryObject},
-    {0x83dab9f5, L"script", XFA_ELEMENT_Script,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x8411ebcd, L"addViewerPreferences", XFA_ELEMENT_AddViewerPreferences,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x8777642e, L"alwaysEmbed", XFA_ELEMENT_AlwaysEmbed, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x877a6b39, L"passwordEdit", XFA_ELEMENT_PasswordEdit,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x87e84c99, L"numericEdit", XFA_ELEMENT_NumericEdit,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x8852cdec, L"encryptionMethod", XFA_ELEMENT_EncryptionMethod,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_NodeC},
-    {0x891f4606, L"change", XFA_ELEMENT_Change, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x89939f36, L"pageArea", XFA_ELEMENT_PageArea,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0x8a9d6247, L"submitUrl", XFA_ELEMENT_SubmitUrl, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0x8ad8b90f, L"oids", XFA_ELEMENT_Oids,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x8b036f32, L"signature", XFA_ELEMENT_Signature,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x8b128efb, L"ADBE_JSConsole", XFA_ELEMENT_ADBE_JSConsole,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0x8bcfe96e, L"caption", XFA_ELEMENT_Caption,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x8e1c2921, L"relevant", XFA_ELEMENT_Relevant, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x8e3f0a4b, L"flipLabel", XFA_ELEMENT_FlipLabel, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0x900280b7, L"exData", XFA_ELEMENT_ExData,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0x91e80352, L"dayNames", XFA_ELEMENT_DayNames, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_Node},
-    {0x93113b11, L"soapAction", XFA_ELEMENT_SoapAction,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_TextNode},
-    {0x938b09f6, L"defaultTypeface", XFA_ELEMENT_DefaultTypeface,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_NodeV},
-    {0x95b37897, L"manifest", XFA_ELEMENT_Manifest,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x97b76b54, L"overflow", XFA_ELEMENT_Overflow,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x9a57861b, L"linear", XFA_ELEMENT_Linear,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0x9ad5a821, L"currencySymbol", XFA_ELEMENT_CurrencySymbol,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ContentNode},
-    {0x9c6471b3, L"delete", XFA_ELEMENT_Delete, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0x9deea61d, L"deltas", XFA_ELEMENT_Deltas, XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_OrdinaryObject},
-    {0x9e67de21, L"digestMethod", XFA_ELEMENT_DigestMethod,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_NodeC},
-    {0x9f3e9510, L"instanceManager", XFA_ELEMENT_InstanceManager,
-     XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xa0799892, L"equateRange", XFA_ELEMENT_EquateRange, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xa084a381, L"medium", XFA_ELEMENT_Medium,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xa1211b8b, L"textEdit", XFA_ELEMENT_TextEdit,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xa17008f0, L"templateCache", XFA_ELEMENT_TemplateCache,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_Node},
-    {0xa4f7b88f, L"compressObjectStream", XFA_ELEMENT_CompressObjectStream,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xa65f5d17, L"dataValue", XFA_ELEMENT_DataValue, XFA_XDPPACKET_Datasets,
-     XFA_OBJECTTYPE_Node},
-    {0xa6caaa89, L"accessibleContent", XFA_ELEMENT_AccessibleContent,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xa8c7d5e2, L"nodeList", XFA_ELEMENT_NodeList, XFA_XDPPACKET_XDP,
-     XFA_OBJECTTYPE_NodeList},
-    {0xa94cc00b, L"includeXDPContent", XFA_ELEMENT_IncludeXDPContent,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xa9b081a1, L"xmlConnection", XFA_ELEMENT_XmlConnection,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_Node},
-    {0xab2a3b74, L"validateApprovalSignatures",
-     XFA_ELEMENT_ValidateApprovalSignatures, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xab8c5a2b, L"signData", XFA_ELEMENT_SignData,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xabaa2ceb, L"packets", XFA_ELEMENT_Packets, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xadba359c, L"datePattern", XFA_ELEMENT_DatePattern,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ContentNode},
-    {0xae222b2b, L"duplexOption", XFA_ELEMENT_DuplexOption,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xb012effb, L"base", XFA_ELEMENT_Base, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xb0e5485d, L"bind", XFA_ELEMENT_Bind,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_Node},
-    {0xb45d61b2, L"compression", XFA_ELEMENT_Compression, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xb563f0ff, L"user", XFA_ELEMENT_User, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0xb5848ad5, L"rectangle", XFA_ELEMENT_Rectangle,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xb6dacb72, L"effectiveOutputPolicy", XFA_ELEMENT_EffectiveOutputPolicy,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_Node},
-    {0xb7d7654d, L"ADBE_JSDebugger", XFA_ELEMENT_ADBE_JSDebugger,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xbab37f73, L"acrobat7", XFA_ELEMENT_Acrobat7, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xbc70081e, L"interactive", XFA_ELEMENT_Interactive, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xbc8fa350, L"locale", XFA_ELEMENT_Locale,
-     XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0xbcd44940, L"currentPage", XFA_ELEMENT_CurrentPage, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xbde9abda, L"data", XFA_ELEMENT_Data, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xbde9abde, L"date", XFA_ELEMENT_Date,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0xbe52dfbf, L"desc", XFA_ELEMENT_Desc,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xbf4b6405, L"encrypt", XFA_ELEMENT_Encrypt,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Config | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xbfa87cce, L"draw", XFA_ELEMENT_Draw,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0xc181ff4b, L"encryption", XFA_ELEMENT_Encryption, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xc1970f40, L"meridiemNames", XFA_ELEMENT_MeridiemNames,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0xc5ad9f5e, L"messaging", XFA_ELEMENT_Messaging, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xc69549f4, L"speak", XFA_ELEMENT_Speak,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0xc7743dc7, L"dataGroup", XFA_ELEMENT_DataGroup, XFA_XDPPACKET_Datasets,
-     XFA_OBJECTTYPE_Node},
-    {0xc7eb20e9, L"common", XFA_ELEMENT_Common, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xc85d4528, L"#text", XFA_ELEMENT_Sharptext,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Config | XFA_XDPPACKET_LocaleSet |
-         XFA_XDPPACKET_ConnectionSet | XFA_XDPPACKET_SourceSet |
-         XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_NodeV},
-    {0xc861556a, L"paginationOverride", XFA_ELEMENT_PaginationOverride,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xc903dabb, L"reasons", XFA_ELEMENT_Reasons,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xc9a8127f, L"signatureProperties", XFA_ELEMENT_SignatureProperties,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xca010c2d, L"threshold", XFA_ELEMENT_Threshold, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xcb4c5e96, L"appearanceFilter", XFA_ELEMENT_AppearanceFilter,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_NodeC},
-    {0xcc92aba7, L"fill", XFA_ELEMENT_Fill,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xcd308b77, L"font", XFA_ELEMENT_Font,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Config | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_Node},
-    {0xcd309ff4, L"form", XFA_ELEMENT_Form, XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_ModelNode},
-    {0xcebcca2d, L"mediumInfo", XFA_ELEMENT_MediumInfo, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xcfe0d643, L"certificate", XFA_ELEMENT_Certificate,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_TextNode},
-    {0xd012c033, L"password", XFA_ELEMENT_Password, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_TextNode},
-    {0xd01604bd, L"runScripts", XFA_ELEMENT_RunScripts, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xd1227e6f, L"trace", XFA_ELEMENT_Trace, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xd1532876, L"float", XFA_ELEMENT_Float,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0xd17a6c30, L"renderPolicy", XFA_ELEMENT_RenderPolicy,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xd4bf6823, L"logPseudoModel", XFA_ELEMENT_LogPseudoModel,
-     XFA_XDPPACKET_XDP, XFA_OBJECTTYPE_OrdinaryObject},
-    {0xd58aa962, L"destination", XFA_ELEMENT_Destination, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xd6e27f1d, L"value", XFA_ELEMENT_Value,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xd7a14462, L"bookend", XFA_ELEMENT_Bookend,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xd8c31254, L"exObject", XFA_ELEMENT_ExObject,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xda6a8590, L"openAction", XFA_ELEMENT_OpenAction, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xdab4fb7d, L"neverEmbed", XFA_ELEMENT_NeverEmbed, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xdb98475f, L"bindItems", XFA_ELEMENT_BindItems,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xdbfbe02e, L"calculate", XFA_ELEMENT_Calculate,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xdd7676ed, L"print", XFA_ELEMENT_Print, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xdde273d7, L"extras", XFA_ELEMENT_Extras,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_Node},
-    {0xde146b34, L"proto", XFA_ELEMENT_Proto,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xdf059321, L"dSigData", XFA_ELEMENT_DSigData,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xdfccf030, L"creator", XFA_ELEMENT_Creator, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xdff78c6a, L"connect", XFA_ELEMENT_Connect,
-     XFA_XDPPACKET_SourceSet | XFA_XDPPACKET_Template | XFA_XDPPACKET_Form,
-     XFA_OBJECTTYPE_Node},
-    {0xe11a2cbc, L"permissions", XFA_ELEMENT_Permissions, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xe14c801c, L"connectionSet", XFA_ELEMENT_ConnectionSet,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_ModelNode},
-    {0xe1c83a14, L"submit", XFA_ELEMENT_Submit,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xe29821cd, L"range", XFA_ELEMENT_Range, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xe38d83c7, L"linearized", XFA_ELEMENT_Linearized, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xe3aa2578, L"packet", XFA_ELEMENT_Packet, XFA_XDPPACKET_XDP,
-     XFA_OBJECTTYPE_NodeC},
-    {0xe3aa860e, L"rootElement", XFA_ELEMENT_RootElement,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_TextNode},
-    {0xe3e553fa, L"plaintextMetadata", XFA_ELEMENT_PlaintextMetadata,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xe3e6e4f2, L"numberSymbols", XFA_ELEMENT_NumberSymbols,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0xe3f067f6, L"printHighQuality", XFA_ELEMENT_PrintHighQuality,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xe3fd078c, L"driver", XFA_ELEMENT_Driver, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xe48b34f2, L"incrementalLoad", XFA_ELEMENT_IncrementalLoad,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_NodeV},
-    {0xe550e7c2, L"subjectDN", XFA_ELEMENT_SubjectDN,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_NodeC},
-    {0xe6669a78, L"compressLogicalStructure",
-     XFA_ELEMENT_CompressLogicalStructure, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xe7a7ea02, L"incrementalMerge", XFA_ELEMENT_IncrementalMerge,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xe948530d, L"radial", XFA_ELEMENT_Radial,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xea8d6999, L"variables", XFA_ELEMENT_Variables,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContainerNode},
-    {0xeaa142c0, L"timePatterns", XFA_ELEMENT_TimePatterns,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_Node},
-    {0xeb943a71, L"effectiveInputPolicy", XFA_ELEMENT_EffectiveInputPolicy,
-     XFA_XDPPACKET_ConnectionSet, XFA_OBJECTTYPE_Node},
-    {0xef04a2bc, L"nameAttr", XFA_ELEMENT_NameAttr, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xf07222ab, L"conformance", XFA_ELEMENT_Conformance, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xf0aaaadc, L"transform", XFA_ELEMENT_Transform, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_Node},
-    {0xf1433e88, L"lockDocument", XFA_ELEMENT_LockDocument,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_ContentNode},
-    {0xf54eb997, L"breakAfter", XFA_ELEMENT_BreakAfter,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xf616da28, L"line", XFA_ELEMENT_Line,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xf616f3dc, L"list", XFA_ELEMENT_List, XFA_XDPPACKET_XDP,
-     XFA_OBJECTTYPE_OrdinaryList},
-    {0xf7055fb1, L"source", XFA_ELEMENT_Source, XFA_XDPPACKET_SourceSet,
-     XFA_OBJECTTYPE_Node},
-    {0xf7eebe1c, L"occur", XFA_ELEMENT_Occur,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-    {0xf8d10d97, L"pickTrayByPDFSize", XFA_ELEMENT_PickTrayByPDFSize,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xf8f19e3a, L"monthNames", XFA_ELEMENT_MonthNames, XFA_XDPPACKET_LocaleSet,
-     XFA_OBJECTTYPE_Node},
-    {0xf984149b, L"severity", XFA_ELEMENT_Severity, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xf9bcb037, L"groupParent", XFA_ELEMENT_GroupParent, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_NodeV},
-    {0xfbc42fff, L"documentAssembly", XFA_ELEMENT_DocumentAssembly,
-     XFA_XDPPACKET_Config, XFA_OBJECTTYPE_ContentNode},
-    {0xfc78159f, L"numberSymbol", XFA_ELEMENT_NumberSymbol,
-     XFA_XDPPACKET_LocaleSet, XFA_OBJECTTYPE_ContentNode},
-    {0xfcbd606c, L"tagged", XFA_ELEMENT_Tagged, XFA_XDPPACKET_Config,
-     XFA_OBJECTTYPE_ContentNode},
-    {0xff063802, L"items", XFA_ELEMENT_Items,
-     XFA_XDPPACKET_Template | XFA_XDPPACKET_Form, XFA_OBJECTTYPE_Node},
-};
-const int32_t g_iXFAElementCount =
-    sizeof(g_XFAElementData) / sizeof(XFA_ELEMENTINFO);
-const XFA_ELEMENTHIERARCHY g_XFAElementPropertyIndex[] = {
-    {0, 8},    {8, 0},   {8, 14},   {22, 0},   {22, 0},   {22, 6},   {28, 0},
-    {28, 0},   {28, 1},  {29, 3},   {32, 0},   {32, 0},   {32, 0},   {32, 3},
-    {35, 1},   {36, 0},  {36, 0},   {36, 2},   {38, 0},   {38, 0},   {38, 0},
-    {38, 4},   {42, 0},  {42, 0},   {42, 1},   {43, 0},   {43, 8},   {51, 19},
-    {70, 0},   {70, 0},  {70, 2},   {72, 1},   {73, 0},   {73, 2},   {75, 4},
-    {79, 1},   {80, 1},  {81, 0},   {81, 0},   {81, 3},   {84, 0},   {84, 4},
-    {88, 4},   {92, 1},  {93, 0},   {93, 4},   {97, 9},   {106, 14}, {120, 0},
-    {120, 0},  {120, 5}, {125, 0},  {125, 1},  {126, 0},  {126, 0},  {126, 0},
-    {126, 0},  {126, 0}, {126, 1},  {127, 0},  {127, 0},  {127, 0},  {127, 0},
-    {127, 0},  {127, 0}, {127, 0},  {127, 6},  {133, 1},  {134, 0},  {134, 1},
-    {135, 0},  {135, 0}, {135, 1},  {136, 2},  {138, 5},  {143, 2},  {145, 0},
-    {145, 0},  {145, 0}, {145, 0},  {145, 0},  {145, 5},  {150, 0},  {150, 0},
-    {150, 0},  {150, 0}, {150, 0},  {150, 0},  {150, 0},  {150, 2},  {152, 0},
-    {152, 0},  {152, 0}, {152, 17}, {169, 0},  {169, 1},  {170, 0},  {170, 0},
-    {170, 2},  {172, 0}, {172, 0},  {172, 1},  {173, 0},  {173, 0},  {173, 2},
-    {175, 2},  {177, 0}, {177, 0},  {177, 0},  {177, 11}, {188, 0},  {188, 0},
-    {188, 0},  {188, 0}, {188, 0},  {188, 4},  {192, 3},  {195, 0},  {195, 0},
-    {195, 0},  {195, 0}, {195, 0},  {195, 0},  {195, 9},  {204, 0},  {204, 0},
-    {204, 17}, {221, 0}, {221, 0},  {221, 0},  {221, 0},  {221, 0},  {221, 0},
-    {221, 0},  {221, 0}, {221, 0},  {221, 4},  {225, 0},  {225, 0},  {225, 0},
-    {225, 0},  {225, 2}, {227, 3},  {230, 0},  {230, 0},  {230, 2},  {232, 0},
-    {232, 1},  {233, 2}, {235, 2},  {237, 0},  {237, 0},  {237, 2},  {239, 0},
-    {239, 1},  {240, 1}, {241, 2},  {243, 0},  {243, 3},  {246, 4},  {250, 0},
-    {250, 1},  {251, 2}, {253, 0},  {253, 0},  {253, 0},  {253, 0},  {253, 0},
-    {253, 0},  {253, 0}, {253, 0},  {253, 0},  {253, 0},  {253, 2},  {255, 2},
-    {257, 0},  {257, 6}, {263, 5},  {268, 0},  {268, 0},  {268, 0},  {268, 3},
-    {271, 0},  {271, 0}, {271, 3},  {274, 4},  {278, 0},  {278, 0},  {278, 4},
-    {282, 0},  {282, 0}, {282, 5},  {287, 0},  {287, 5},  {292, 0},  {292, 0},
-    {292, 0},  {292, 1}, {293, 0},  {293, 0},  {293, 1},  {294, 0},  {294, 2},
-    {296, 0},  {296, 0}, {296, 0},  {296, 0},  {296, 1},  {297, 0},  {297, 0},
-    {297, 4},  {301, 0}, {301, 0},  {301, 0},  {301, 0},  {301, 0},  {301, 0},
-    {301, 1},  {302, 0}, {302, 2},  {304, 0},  {304, 0},  {304, 0},  {304, 0},
-    {304, 1},  {305, 4}, {309, 0},  {309, 3},  {312, 0},  {312, 0},  {312, 1},
-    {313, 0},  {313, 8}, {321, 0},  {321, 10}, {331, 0},  {331, 10}, {341, 1},
-    {342, 12}, {354, 3}, {357, 1},  {358, 0},  {358, 0},  {358, 0},  {358, 8},
-    {366, 0},  {366, 0}, {366, 0},  {366, 0},  {366, 0},  {366, 0},  {366, 7},
-    {373, 2},  {375, 0}, {375, 1},  {376, 0},  {376, 0},  {376, 0},  {376, 0},
-    {376, 0},  {376, 0}, {376, 0},  {376, 0},  {376, 13}, {389, 0},  {389, 1},
-    {390, 1},  {391, 0}, {391, 0},  {391, 3},  {394, 0},  {394, 0},  {394, 0},
-    {394, 0},  {394, 0}, {394, 4},  {398, 9},  {407, 0},  {407, 1},  {408, 0},
-    {408, 0},  {408, 0}, {408, 0},  {408, 0},  {408, 1},  {409, 0},  {409, 2},
-    {411, 0},  {411, 0}, {411, 0},  {411, 0},  {411, 2},  {413, 0},  {413, 1},
-    {414, 0},  {414, 0}, {414, 0},  {414, 7},  {421, 0},  {421, 1},  {422, 1},
-    {423, 0},  {423, 1}, {424, 1},  {425, 0},  {425, 1},  {426, 0},  {426, 0},
-    {426, 0},  {426, 0}, {426, 0},  {426, 0},
-};
-const XFA_PROPERTY g_XFAElementPropertyData[] = {
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Jog, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_BatchOutput, 1, 0},
-    {XFA_ELEMENT_OutputBin, 1, 0},
-    {XFA_ELEMENT_Compress, 1, 0},
-    {XFA_ELEMENT_Staple, 1, 0},
-    {XFA_ELEMENT_MediumInfo, 1, 0},
-    {XFA_ELEMENT_CheckButton, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_ChoiceList, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_DefaultUi, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Barcode, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Button, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_DateTimeEdit, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Picture, 1, 0},
-    {XFA_ELEMENT_ImageEdit, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_PasswordEdit, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_NumericEdit, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Signature, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_TextEdit, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_ExObject, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Break, 1, 0},
-    {XFA_ELEMENT_Overflow, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Bookend, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Occur, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_SubsetBelow, 1, 0},
-    {XFA_ELEMENT_Map, 1, 0},
-    {XFA_ELEMENT_Embed, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_DatePattern, 4, 0},
-    {XFA_ELEMENT_Edge, 1, 0},
-    {XFA_ELEMENT_Fill, 1, 0},
-    {XFA_ELEMENT_To, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Mode, 1, 0},
-    {XFA_ELEMENT_Threshold, 1, 0},
-    {XFA_ELEMENT_Script, 1, 0},
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Jog, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_BatchOutput, 1, 0},
-    {XFA_ELEMENT_PageOffset, 1, 0},
-    {XFA_ELEMENT_OutputBin, 1, 0},
-    {XFA_ELEMENT_Staple, 1, 0},
-    {XFA_ELEMENT_MediumInfo, 1, 0},
-    {XFA_ELEMENT_AdobeExtensionLevel, 1, 0},
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_Pdfa, 1, 0},
-    {XFA_ELEMENT_BatchOutput, 1, 0},
-    {XFA_ELEMENT_ViewerPreferences, 1, 0},
-    {XFA_ELEMENT_ScriptModel, 1, 0},
-    {XFA_ELEMENT_Version, 1, 0},
-    {XFA_ELEMENT_SubmitFormat, 1, 0},
-    {XFA_ELEMENT_SilentPrint, 1, 0},
-    {XFA_ELEMENT_Producer, 1, 0},
-    {XFA_ELEMENT_Compression, 1, 0},
-    {XFA_ELEMENT_Interactive, 1, 0},
-    {XFA_ELEMENT_Encryption, 1, 0},
-    {XFA_ELEMENT_RenderPolicy, 1, 0},
-    {XFA_ELEMENT_OpenAction, 1, 0},
-    {XFA_ELEMENT_Creator, 1, 0},
-    {XFA_ELEMENT_Linearized, 1, 0},
-    {XFA_ELEMENT_Tagged, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Xsl, 1, 0},
-    {XFA_ELEMENT_Packets, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Debug, 1, 0},
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_BatchOutput, 1, 0},
-    {XFA_ELEMENT_FlipLabel, 1, 0},
-    {XFA_ELEMENT_TemplateCache, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_BatchOutput, 1, 0},
-    {XFA_ELEMENT_FlipLabel, 1, 0},
-    {XFA_ELEMENT_EraNames, 1, 0},
-    {XFA_ELEMENT_DayNames, 2, 0},
-    {XFA_ELEMENT_MeridiemNames, 1, 0},
-    {XFA_ELEMENT_MonthNames, 2, 0},
-    {XFA_ELEMENT_Hyphenation, 1, 0},
-    {XFA_ELEMENT_Amd, 1, 0},
-    {XFA_ELEMENT_Part, 1, 0},
-    {XFA_ELEMENT_IncludeXDPContent, 1, 0},
-    {XFA_ELEMENT_Conformance, 1, 0},
-    {XFA_ELEMENT_Mdp, 1, 0},
-    {XFA_ELEMENT_Certificates, 1, 0},
-    {XFA_ELEMENT_TimeStamp, 1, 0},
-    {XFA_ELEMENT_Handler, 1, 0},
-    {XFA_ELEMENT_DigestMethods, 1, 0},
-    {XFA_ELEMENT_Encodings, 1, 0},
-    {XFA_ELEMENT_Reasons, 1, 0},
-    {XFA_ELEMENT_AppearanceFilter, 1, 0},
-    {XFA_ELEMENT_LockDocument, 1, 0},
-    {XFA_ELEMENT_Xdp, 1, 0},
-    {XFA_ELEMENT_Cache, 1, 0},
-    {XFA_ELEMENT_Pagination, 1, 0},
-    {XFA_ELEMENT_Overprint, 1, 0},
-    {XFA_ELEMENT_BehaviorOverride, 1, 0},
-    {XFA_ELEMENT_Copies, 1, 0},
-    {XFA_ELEMENT_Output, 1, 0},
-    {XFA_ELEMENT_Validate, 1, 0},
-    {XFA_ELEMENT_Layout, 1, 0},
-    {XFA_ELEMENT_Script, 1, 0},
-    {XFA_ELEMENT_Common, 1, 0},
-    {XFA_ELEMENT_PaginationOverride, 1, 0},
-    {XFA_ELEMENT_Destination, 1, 0},
-    {XFA_ELEMENT_IncrementalMerge, 1, 0},
-    {XFA_ELEMENT_Execute, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Script, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_SignData, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Submit, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_CurrencySymbol, 3, 0},
-    {XFA_ELEMENT_Operation, 1, 0},
-    {XFA_ELEMENT_WsdlAddress, 1, 0},
-    {XFA_ELEMENT_SoapAddress, 1, 0},
-    {XFA_ELEMENT_SoapAction, 1, 0},
-    {XFA_ELEMENT_EffectiveOutputPolicy, 1, 0},
-    {XFA_ELEMENT_EffectiveInputPolicy, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Era, 2, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Picture, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Edge, 4, 0},
-    {XFA_ELEMENT_Corner, 4, 0},
-    {XFA_ELEMENT_Fill, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_KeyUsage, 1, 0},
-    {XFA_ELEMENT_SubjectDNs, 1, 0},
-    {XFA_ELEMENT_Issuers, 1, 0},
-    {XFA_ELEMENT_Signing, 1, 0},
-    {XFA_ELEMENT_Oids, 1, 0},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Ui, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Para, 1, 0},
-    {XFA_ELEMENT_Format, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Assist, 1, 0},
-    {XFA_ELEMENT_Traversal, 1, 0},
-    {XFA_ELEMENT_Keep, 1, 0},
-    {XFA_ELEMENT_Validate, 1, 0},
-    {XFA_ELEMENT_Caption, 1, 0},
-    {XFA_ELEMENT_Bind, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Font, 1, 0},
-    {XFA_ELEMENT_Value, 1, 0},
-    {XFA_ELEMENT_Calculate, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Items, 2, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Para, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Assist, 1, 0},
-    {XFA_ELEMENT_Traversal, 1, 0},
-    {XFA_ELEMENT_Validate, 1, 0},
-    {XFA_ELEMENT_Caption, 1, 0},
-    {XFA_ELEMENT_Bind, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Calculate, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Comb, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Present, 1, 0},
-    {XFA_ELEMENT_Acrobat, 1, 0},
-    {XFA_ELEMENT_Trace, 1, 0},
-    {XFA_ELEMENT_PrintScaling, 1, 0},
-    {XFA_ELEMENT_Enforce, 1, 0},
-    {XFA_ELEMENT_NumberOfCopies, 1, 0},
-    {XFA_ELEMENT_PageRange, 1, 0},
-    {XFA_ELEMENT_AddViewerPreferences, 1, 0},
-    {XFA_ELEMENT_ADBE_JSConsole, 1, 0},
-    {XFA_ELEMENT_DuplexOption, 1, 0},
-    {XFA_ELEMENT_ADBE_JSDebugger, 1, 0},
-    {XFA_ELEMENT_PickTrayByPDFSize, 1, 0},
-    {XFA_ELEMENT_Break, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Para, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Assist, 1, 0},
-    {XFA_ELEMENT_Traversal, 1, 0},
-    {XFA_ELEMENT_Keep, 1, 0},
-    {XFA_ELEMENT_Validate, 1, 0},
-    {XFA_ELEMENT_PageSet, 1, 0},
-    {XFA_ELEMENT_Overflow, 1, 0},
-    {XFA_ELEMENT_Bind, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Bookend, 1, 0},
-    {XFA_ELEMENT_Calculate, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Variables, 1, 0},
-    {XFA_ELEMENT_Occur, 1, 0},
-    {XFA_ELEMENT_Query, 1, 0},
-    {XFA_ELEMENT_Insert, 1, 0},
-    {XFA_ELEMENT_Update, 1, 0},
-    {XFA_ELEMENT_Delete, 1, 0},
-    {XFA_ELEMENT_MsgId, 1, 0},
-    {XFA_ELEMENT_Severity, 1, 0},
-    {XFA_ELEMENT_To, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Type, 1, 0},
-    {XFA_ELEMENT_ToolTip, 1, 0},
-    {XFA_ELEMENT_Speak, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_AddSilentPrint, 1, 0},
-    {XFA_ELEMENT_PrinterName, 1, 0},
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_RecordSet, 1, 0},
-    {XFA_ELEMENT_Select, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Message, 1, 0},
-    {XFA_ELEMENT_Picture, 1, 0},
-    {XFA_ELEMENT_Script, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_NumberPattern, 4, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Occur, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_RootElement, 1, 0},
-    {XFA_ELEMENT_Script, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Xsl, 1, 0},
-    {XFA_ELEMENT_StartPage, 1, 0},
-    {XFA_ELEMENT_Relevant, 1, 0},
-    {XFA_ELEMENT_Base, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_AutoSave, 1, 0},
-    {XFA_ELEMENT_Validate, 1, 0},
-    {XFA_ELEMENT_ValidateApprovalSignatures, 1, 0},
-    {XFA_ELEMENT_Acrobat7, 1, 0},
-    {XFA_ELEMENT_Common, 1, 0},
-    {XFA_ELEMENT_Exclude, 1, 0},
-    {XFA_ELEMENT_CurrentPage, 1, 0},
-    {XFA_ELEMENT_RunScripts, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Comb, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Medium, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Occur, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Filter, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Manifest, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Para, 1, 0},
-    {XFA_ELEMENT_Font, 1, 0},
-    {XFA_ELEMENT_Value, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Day, 7, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Occur, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Comb, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Filter, 1, 0},
-    {XFA_ELEMENT_Manifest, 1, 0},
-    {XFA_ELEMENT_Picture, 1, 0},
-    {XFA_ELEMENT_Level, 1, 0},
-    {XFA_ELEMENT_Type, 1, 0},
-    {XFA_ELEMENT_CompressObjectStream, 1, 0},
-    {XFA_ELEMENT_CompressLogicalStructure, 1, 0},
-    {XFA_ELEMENT_Edge, 4, 0},
-    {XFA_ELEMENT_Corner, 4, 0},
-    {XFA_ELEMENT_Fill, 1, 0},
-    {XFA_ELEMENT_DynamicRender, 1, 0},
-    {XFA_ELEMENT_DatePatterns, 1, 0},
-    {XFA_ELEMENT_CalendarSymbols, 1, 0},
-    {XFA_ELEMENT_CurrencySymbols, 1, 0},
-    {XFA_ELEMENT_Typefaces, 1, 0},
-    {XFA_ELEMENT_DateTimeSymbols, 1, 0},
-    {XFA_ELEMENT_NumberPatterns, 1, 0},
-    {XFA_ELEMENT_NumberSymbols, 1, 0},
-    {XFA_ELEMENT_TimePatterns, 1, 0},
-    {XFA_ELEMENT_Uri, 1, 0},
-    {XFA_ELEMENT_Xsl, 1, 0},
-    {XFA_ELEMENT_StartNode, 1, 0},
-    {XFA_ELEMENT_OutputXSL, 1, 0},
-    {XFA_ELEMENT_AdjustData, 1, 0},
-    {XFA_ELEMENT_Attributes, 1, 0},
-    {XFA_ELEMENT_Window, 1, 0},
-    {XFA_ELEMENT_Record, 1, 0},
-    {XFA_ELEMENT_Range, 1, 0},
-    {XFA_ELEMENT_IncrementalLoad, 1, 0},
-    {XFA_ELEMENT_Text, 1, 0},
-    {XFA_ELEMENT_Time, 1, 0},
-    {XFA_ELEMENT_DateTime, 1, 0},
-    {XFA_ELEMENT_Image, 1, 0},
-    {XFA_ELEMENT_Decimal, 1, 0},
-    {XFA_ELEMENT_Boolean, 1, 0},
-    {XFA_ELEMENT_Integer, 1, 0},
-    {XFA_ELEMENT_ExData, 1, 0},
-    {XFA_ELEMENT_Date, 1, 0},
-    {XFA_ELEMENT_Float, 1, 0},
-    {XFA_ELEMENT_Certificate, 1, 0},
-    {XFA_ELEMENT_Ui, 1, 0},
-    {XFA_ELEMENT_Margin, 1, 0},
-    {XFA_ELEMENT_Para, 1, 0},
-    {XFA_ELEMENT_Border, 1, 0},
-    {XFA_ELEMENT_Assist, 1, 0},
-    {XFA_ELEMENT_Traversal, 1, 0},
-    {XFA_ELEMENT_Keep, 1, 0},
-    {XFA_ELEMENT_Caption, 1, 0},
-    {XFA_ELEMENT_Desc, 1, 0},
-    {XFA_ELEMENT_Font, 1, 0},
-    {XFA_ELEMENT_Value, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_EncryptionLevel, 1, 0},
-    {XFA_ELEMENT_Encrypt, 1, 0},
-    {XFA_ELEMENT_Permissions, 1, 0},
-    {XFA_ELEMENT_Meridiem, 2, 0},
-    {XFA_ELEMENT_SuppressBanner, 1, 0},
-    {XFA_ELEMENT_VersionControl, 1, 0},
-    {XFA_ELEMENT_LocaleSet, 1, 0},
-    {XFA_ELEMENT_Template, 1, 0},
-    {XFA_ELEMENT_ValidationMessaging, 1, 0},
-    {XFA_ELEMENT_Locale, 1, 0},
-    {XFA_ELEMENT_Data, 1, 0},
-    {XFA_ELEMENT_Messaging, 1, 0},
-    {XFA_ELEMENT_Pattern, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Solid, 1,
-     XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf},
-    {XFA_ELEMENT_Stipple, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Linear, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Radial, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Fill, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Map, 1, 0},
-    {XFA_ELEMENT_Arc, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Text, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Time, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_DateTime, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Image, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Decimal, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Boolean, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Integer, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_ExData, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Rectangle, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Date, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Float, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Line, 1, XFA_PROPERTYFLAG_OneOf},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Destination, 1, 0},
-    {XFA_ELEMENT_Message, 1, 0},
-    {XFA_ELEMENT_Script, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Picture, 1, 0},
-    {XFA_ELEMENT_ConnectString, 1, 0},
-    {XFA_ELEMENT_User, 1, 0},
-    {XFA_ELEMENT_Password, 1, 0},
-    {XFA_ELEMENT_ModifyAnnots, 1, 0},
-    {XFA_ELEMENT_ContentCopy, 1, 0},
-    {XFA_ELEMENT_FormFieldFilling, 1, 0},
-    {XFA_ELEMENT_Change, 1, 0},
-    {XFA_ELEMENT_AccessibleContent, 1, 0},
-    {XFA_ELEMENT_Print, 1, 0},
-    {XFA_ELEMENT_PlaintextMetadata, 1, 0},
-    {XFA_ELEMENT_PrintHighQuality, 1, 0},
-    {XFA_ELEMENT_DocumentAssembly, 1, 0},
-    {XFA_ELEMENT_Encrypt, 1, 0},
-    {XFA_ELEMENT_NumberSymbol, 5, 0},
-    {XFA_ELEMENT_FontInfo, 1, 0},
-    {XFA_ELEMENT_Xdc, 1, 0},
-    {XFA_ELEMENT_Color, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_TimePattern, 4, 0},
-    {XFA_ELEMENT_Whitespace, 1, 0},
-    {XFA_ELEMENT_Rename, 1, 0},
-    {XFA_ELEMENT_IfEmpty, 1, 0},
-    {XFA_ELEMENT_Presence, 1, 0},
-    {XFA_ELEMENT_Picture, 1, 0},
-    {XFA_ELEMENT_NameAttr, 1, 0},
-    {XFA_ELEMENT_GroupParent, 1, 0},
-    {XFA_ELEMENT_Script, 1, 0},
-    {XFA_ELEMENT_Edge, 1, 0},
-    {XFA_ELEMENT_Connect, 1, 0},
-    {XFA_ELEMENT_Extras, 1, 0},
-    {XFA_ELEMENT_Month, 12, 0},
-};
-const XFA_ELEMENTHIERARCHY g_XFAElementChildrenIndex[] = {
-    {0, 0},   {0, 0},   {0, 0},   {0, 1},    {1, 0},   {1, 4},    {5, 0},
-    {5, 0},   {5, 0},   {5, 3},   {8, 0},    {8, 0},   {8, 0},    {8, 0},
-    {8, 0},   {8, 1},   {9, 0},   {9, 0},    {9, 0},   {9, 0},    {9, 0},
-    {9, 0},   {9, 2},   {11, 0},  {11, 0},   {11, 0},  {11, 0},   {11, 0},
-    {11, 0},  {11, 0},  {11, 0},  {11, 0},   {11, 0},  {11, 0},   {11, 0},
-    {11, 0},  {11, 0},  {11, 0},  {11, 0},   {11, 0},  {11, 0},   {11, 0},
-    {11, 0},  {11, 0},  {11, 0},  {11, 0},   {11, 0},  {11, 8},   {19, 0},
-    {19, 0},  {19, 0},  {19, 0},  {19, 0},   {19, 0},  {19, 0},   {19, 0},
-    {19, 0},  {19, 0},  {19, 0},  {19, 0},   {19, 0},  {19, 0},   {19, 1},
-    {20, 1},  {21, 1},  {22, 0},  {22, 0},   {22, 0},  {22, 0},   {22, 0},
-    {22, 0},  {22, 0},  {22, 0},  {22, 0},   {22, 0},  {22, 7},   {29, 0},
-    {29, 0},  {29, 0},  {29, 0},  {29, 0},   {29, 0},  {29, 1},   {30, 1},
-    {31, 0},  {31, 0},  {31, 0},  {31, 0},   {31, 0},  {31, 0},   {31, 0},
-    {31, 0},  {31, 0},  {31, 4},  {35, 2},   {37, 0},  {37, 0},   {37, 0},
-    {37, 0},  {37, 0},  {37, 0},  {37, 0},   {37, 0},  {37, 0},   {37, 0},
-    {37, 0},  {37, 0},  {37, 0},  {37, 0},   {37, 4},  {41, 0},   {41, 0},
-    {41, 0},  {41, 0},  {41, 0},  {41, 0},   {41, 2},  {43, 0},   {43, 0},
-    {43, 0},  {43, 0},  {43, 0},  {43, 0},   {43, 0},  {43, 0},   {43, 0},
-    {43, 13}, {56, 0},  {56, 0},  {56, 1},   {57, 0},  {57, 0},   {57, 0},
-    {57, 0},  {57, 0},  {57, 0},  {57, 0},   {57, 0},  {57, 0},   {57, 0},
-    {57, 0},  {57, 1},  {58, 0},  {58, 1},   {59, 0},  {59, 0},   {59, 0},
-    {59, 1},  {60, 0},  {60, 0},  {60, 0},   {60, 0},  {60, 0},   {60, 0},
-    {60, 0},  {60, 0},  {60, 1},  {61, 0},   {61, 0},  {61, 0},   {61, 1},
-    {62, 0},  {62, 2},  {64, 0},  {64, 0},   {64, 0},  {64, 0},   {64, 0},
-    {64, 0},  {64, 0},  {64, 0},  {64, 0},   {64, 0},  {64, 0},   {64, 0},
-    {64, 1},  {65, 1},  {66, 1},  {67, 0},   {67, 1},  {68, 0},   {68, 0},
-    {68, 0},  {68, 0},  {68, 0},  {68, 0},   {68, 0},  {68, 0},   {68, 6},
-    {74, 0},  {74, 1},  {75, 0},  {75, 0},   {75, 0},  {75, 0},   {75, 0},
-    {75, 0},  {75, 0},  {75, 0},  {75, 0},   {75, 1},  {76, 0},   {76, 0},
-    {76, 0},  {76, 0},  {76, 0},  {76, 0},   {76, 0},  {76, 0},   {76, 0},
-    {76, 0},  {76, 0},  {76, 0},  {76, 0},   {76, 0},  {76, 0},   {76, 0},
-    {76, 0},  {76, 0},  {76, 0},  {76, 0},   {76, 0},  {76, 0},   {76, 0},
-    {76, 0},  {76, 0},  {76, 0},  {76, 0},   {76, 0},  {76, 0},   {76, 0},
-    {76, 0},  {76, 0},  {76, 0},  {76, 2},   {78, 0},  {78, 0},   {78, 0},
-    {78, 1},  {79, 0},  {79, 0},  {79, 1},   {80, 0},  {80, 0},   {80, 1},
-    {81, 0},  {81, 0},  {81, 1},  {82, 0},   {82, 0},  {82, 0},   {82, 0},
-    {82, 0},  {82, 0},  {82, 0},  {82, 0},   {82, 0},  {82, 0},   {82, 1},
-    {83, 0},  {83, 0},  {83, 0},  {83, 0},   {83, 0},  {83, 0},   {83, 11},
-    {94, 0},  {94, 0},  {94, 0},  {94, 0},   {94, 0},  {94, 11},  {105, 106},
-    {211, 0}, {211, 0}, {211, 1}, {212, 0},  {212, 3}, {215, 1},  {216, 0},
-    {216, 0}, {216, 0}, {216, 0}, {216, 0},  {216, 0}, {216, 0},  {216, 0},
-    {216, 0}, {216, 0}, {216, 0}, {216, 0},  {216, 0}, {216, 12}, {228, 0},
-    {228, 0}, {228, 0}, {228, 0}, {228, 0},  {228, 0}, {228, 0},  {228, 0},
-    {228, 0}, {228, 2}, {230, 0}, {230, 0},  {230, 0}, {230, 0},  {230, 0},
-    {230, 0}, {230, 0}, {230, 0}, {230, 10},
-};
-const FX_WORD g_XFAElementChildrenData[] = {
-    XFA_ELEMENT_Extras,
-    XFA_ELEMENT_SubformSet,
-    XFA_ELEMENT_BreakBefore,
-    XFA_ELEMENT_Subform,
-    XFA_ELEMENT_BreakAfter,
-    XFA_ELEMENT_AlwaysEmbed,
-    XFA_ELEMENT_DefaultTypeface,
-    XFA_ELEMENT_NeverEmbed,
-    XFA_ELEMENT_Source,
-    XFA_ELEMENT_Equate,
-    XFA_ELEMENT_EquateRange,
-    XFA_ELEMENT_Ps,
-    XFA_ELEMENT_Pcl,
-    XFA_ELEMENT_Pdf,
-    XFA_ELEMENT_Zpl,
-    XFA_ELEMENT_LabelPrinter,
-    XFA_ELEMENT_WebClient,
-    XFA_ELEMENT_SubmitUrl,
-    XFA_ELEMENT_Driver,
-    XFA_ELEMENT_Typeface,
-    XFA_ELEMENT_SubjectDN,
-    XFA_ELEMENT_Certificate,
-    XFA_ELEMENT_SubformSet,
-    XFA_ELEMENT_Area,
-    XFA_ELEMENT_Field,
-    XFA_ELEMENT_ExclGroup,
-    XFA_ELEMENT_Subform,
-    XFA_ELEMENT_Draw,
-    XFA_ELEMENT_ExObject,
-    XFA_ELEMENT_EncryptionMethod,
-    XFA_ELEMENT_Ref,
-    XFA_ELEMENT_Event,
-    XFA_ELEMENT_SetProperty,
-    XFA_ELEMENT_BindItems,
-    XFA_ELEMENT_Connect,
-    XFA_ELEMENT_Pdf,
-    XFA_ELEMENT_Destination,
-    XFA_ELEMENT_Event,
-    XFA_ELEMENT_SetProperty,
-    XFA_ELEMENT_Field,
-    XFA_ELEMENT_Connect,
-    XFA_ELEMENT_Agent,
-    XFA_ELEMENT_PsMap,
-    XFA_ELEMENT_SubformSet,
-    XFA_ELEMENT_BreakBefore,
-    XFA_ELEMENT_Event,
-    XFA_ELEMENT_Area,
-    XFA_ELEMENT_SetProperty,
-    XFA_ELEMENT_Field,
-    XFA_ELEMENT_ExclGroup,
-    XFA_ELEMENT_Subform,
-    XFA_ELEMENT_Draw,
-    XFA_ELEMENT_ExObject,
-    XFA_ELEMENT_Proto,
-    XFA_ELEMENT_Connect,
-    XFA_ELEMENT_BreakAfter,
-    XFA_ELEMENT_Locale,
-    XFA_ELEMENT_Text,
-    XFA_ELEMENT_Font,
-    XFA_ELEMENT_Traverse,
-    XFA_ELEMENT_Map,
-    XFA_ELEMENT_DigestMethod,
-    XFA_ELEMENT_PageSet,
-    XFA_ELEMENT_PageArea,
-    XFA_ELEMENT_Encoding,
-    XFA_ELEMENT_Subform,
-    XFA_ELEMENT_SubmitUrl,
-    XFA_ELEMENT_Certificate,
-    XFA_ELEMENT_Area,
-    XFA_ELEMENT_Field,
-    XFA_ELEMENT_ContentArea,
-    XFA_ELEMENT_ExclGroup,
-    XFA_ELEMENT_Subform,
-    XFA_ELEMENT_Draw,
-    XFA_ELEMENT_Oid,
-    XFA_ELEMENT_Ref,
-    XFA_ELEMENT_ExcludeNS,
-    XFA_ELEMENT_Transform,
-    XFA_ELEMENT_SetProperty,
-    XFA_ELEMENT_Message,
-    XFA_ELEMENT_Log,
-    XFA_ELEMENT_Reason,
-    XFA_ELEMENT_Area,
-    XFA_ELEMENT_Text,
-    XFA_ELEMENT_Time,
-    XFA_ELEMENT_DateTime,
-    XFA_ELEMENT_Image,
-    XFA_ELEMENT_Decimal,
-    XFA_ELEMENT_Boolean,
-    XFA_ELEMENT_Integer,
-    XFA_ELEMENT_ExData,
-    XFA_ELEMENT_Date,
-    XFA_ELEMENT_Float,
-    XFA_ELEMENT_ExObject,
-    XFA_ELEMENT_Text,
-    XFA_ELEMENT_Time,
-    XFA_ELEMENT_DateTime,
-    XFA_ELEMENT_Image,
-    XFA_ELEMENT_Decimal,
-    XFA_ELEMENT_Boolean,
-    XFA_ELEMENT_Integer,
-    XFA_ELEMENT_ExData,
-    XFA_ELEMENT_Date,
-    XFA_ELEMENT_Float,
-    XFA_ELEMENT_Extras,
-    XFA_ELEMENT_Ui,
-    XFA_ELEMENT_SubformSet,
-    XFA_ELEMENT_Break,
-    XFA_ELEMENT_CheckButton,
-    XFA_ELEMENT_Arc,
-    XFA_ELEMENT_Mdp,
-    XFA_ELEMENT_BreakBefore,
-    XFA_ELEMENT_Oid,
-    XFA_ELEMENT_Ref,
-    XFA_ELEMENT_Margin,
-    XFA_ELEMENT_KeyUsage,
-    XFA_ELEMENT_ChoiceList,
-    XFA_ELEMENT_Para,
-    XFA_ELEMENT_Filter,
-    XFA_ELEMENT_Encoding,
-    XFA_ELEMENT_Event,
-    XFA_ELEMENT_DefaultUi,
-    XFA_ELEMENT_Barcode,
-    XFA_ELEMENT_SubjectDNs,
-    XFA_ELEMENT_Issuers,
-    XFA_ELEMENT_Button,
-    XFA_ELEMENT_Format,
-    XFA_ELEMENT_Border,
-    XFA_ELEMENT_Area,
-    XFA_ELEMENT_Hyphenation,
-    XFA_ELEMENT_Text,
-    XFA_ELEMENT_Time,
-    XFA_ELEMENT_Certificates,
-    XFA_ELEMENT_SetProperty,
-    XFA_ELEMENT_DateTime,
-    XFA_ELEMENT_Comb,
-    XFA_ELEMENT_Pattern,
-    XFA_ELEMENT_Field,
-    XFA_ELEMENT_ContentArea,
-    XFA_ELEMENT_Solid,
-    XFA_ELEMENT_Edge,
-    XFA_ELEMENT_Stipple,
-    XFA_ELEMENT_ExclGroup,
-    XFA_ELEMENT_ToolTip,
-    XFA_ELEMENT_Reason,
-    XFA_ELEMENT_Execute,
-    XFA_ELEMENT_DateTimeEdit,
-    XFA_ELEMENT_Image,
-    XFA_ELEMENT_TimeStamp,
-    XFA_ELEMENT_Decimal,
-    XFA_ELEMENT_Subform,
-    XFA_ELEMENT_Handler,
-    XFA_ELEMENT_Boolean,
-    XFA_ELEMENT_Message,
-    XFA_ELEMENT_Assist,
-    XFA_ELEMENT_Picture,
-    XFA_ELEMENT_Traversal,
-    XFA_ELEMENT_Corner,
-    XFA_ELEMENT_Color,
-    XFA_ELEMENT_Keep,
-    XFA_ELEMENT_ImageEdit,
-    XFA_ELEMENT_Validate,
-    XFA_ELEMENT_DigestMethods,
-    XFA_ELEMENT_PageSet,
-    XFA_ELEMENT_Integer,
-    XFA_ELEMENT_Traverse,
-    XFA_ELEMENT_Encodings,
-    XFA_ELEMENT_Signing,
-    XFA_ELEMENT_Script,
-    XFA_ELEMENT_PasswordEdit,
-    XFA_ELEMENT_NumericEdit,
-    XFA_ELEMENT_PageArea,
-    XFA_ELEMENT_Oids,
-    XFA_ELEMENT_Signature,
-    XFA_ELEMENT_Caption,
-    XFA_ELEMENT_ExData,
-    XFA_ELEMENT_Manifest,
-    XFA_ELEMENT_Overflow,
-    XFA_ELEMENT_Linear,
-    XFA_ELEMENT_DigestMethod,
-    XFA_ELEMENT_Medium,
-    XFA_ELEMENT_TextEdit,
-    XFA_ELEMENT_SignData,
-    XFA_ELEMENT_Rectangle,
-    XFA_ELEMENT_Date,
-    XFA_ELEMENT_Desc,
-    XFA_ELEMENT_Encrypt,
-    XFA_ELEMENT_Draw,
-    XFA_ELEMENT_Speak,
-    XFA_ELEMENT_Reasons,
-    XFA_ELEMENT_AppearanceFilter,
-    XFA_ELEMENT_Fill,
-    XFA_ELEMENT_Font,
-    XFA_ELEMENT_Certificate,
-    XFA_ELEMENT_Float,
-    XFA_ELEMENT_Value,
-    XFA_ELEMENT_Bookend,
-    XFA_ELEMENT_ExObject,
-    XFA_ELEMENT_BindItems,
-    XFA_ELEMENT_Calculate,
-    XFA_ELEMENT_Extras,
-    XFA_ELEMENT_Connect,
-    XFA_ELEMENT_Submit,
-    XFA_ELEMENT_SubjectDN,
-    XFA_ELEMENT_Radial,
-    XFA_ELEMENT_Variables,
-    XFA_ELEMENT_LockDocument,
-    XFA_ELEMENT_BreakAfter,
-    XFA_ELEMENT_Line,
-    XFA_ELEMENT_Occur,
-    XFA_ELEMENT_Items,
-    XFA_ELEMENT_Extras,
-    XFA_ELEMENT_WsdlConnection,
-    XFA_ELEMENT_XsdConnection,
-    XFA_ELEMENT_XmlConnection,
-    XFA_ELEMENT_SignData,
-    XFA_ELEMENT_Text,
-    XFA_ELEMENT_Time,
-    XFA_ELEMENT_DateTime,
-    XFA_ELEMENT_Image,
-    XFA_ELEMENT_Decimal,
-    XFA_ELEMENT_Boolean,
-    XFA_ELEMENT_Integer,
-    XFA_ELEMENT_Script,
-    XFA_ELEMENT_ExData,
-    XFA_ELEMENT_Manifest,
-    XFA_ELEMENT_Date,
-    XFA_ELEMENT_Float,
-    XFA_ELEMENT_Command,
-    XFA_ELEMENT_Bind,
-    XFA_ELEMENT_Text,
-    XFA_ELEMENT_Time,
-    XFA_ELEMENT_DateTime,
-    XFA_ELEMENT_Image,
-    XFA_ELEMENT_Decimal,
-    XFA_ELEMENT_Boolean,
-    XFA_ELEMENT_Integer,
-    XFA_ELEMENT_ExData,
-    XFA_ELEMENT_Date,
-    XFA_ELEMENT_Float,
-};
-const XFA_ELEMENTHIERARCHY g_XFAElementAttributeIndex[] = {
-    {0, 3},    {3, 2},    {5, 3},    {8, 10},   {18, 2},   {20, 6},   {26, 2},
-    {28, 1},   {29, 13},  {42, 2},   {44, 1},   {45, 2},   {47, 2},   {49, 7},
-    {56, 0},   {56, 4},   {60, 2},   {62, 7},   {69, 0},   {69, 0},   {69, 2},
-    {71, 2},   {73, 8},   {81, 5},   {86, 8},   {94, 4},   {98, 3},   {101, 3},
-    {104, 3},  {107, 6},  {113, 2},  {115, 2},  {117, 2},  {119, 2},  {121, 3},
-    {124, 2},  {126, 7},  {133, 13}, {146, 2},  {148, 6},  {154, 2},  {156, 3},
-    {159, 1},  {160, 17}, {177, 2},  {179, 2},  {181, 6},  {187, 2},  {189, 2},
-    {191, 3},  {194, 7},  {201, 2},  {203, 3},  {206, 0},  {206, 21}, {227, 1},
-    {228, 3},  {231, 2},  {233, 0},  {233, 2},  {235, 2},  {237, 6},  {243, 0},
-    {243, 4},  {247, 4},  {251, 0},  {251, 2},  {253, 2},  {255, 0},  {255, 0},
-    {255, 2},  {257, 2},  {259, 4},  {263, 3},  {266, 7},  {273, 10}, {283, 9},
-    {292, 6},  {298, 4},  {302, 2},  {304, 2},  {306, 6},  {312, 4},  {316, 3},
-    {319, 2},  {321, 2},  {323, 4},  {327, 4},  {331, 4},  {335, 4},  {339, 2},
-    {341, 2},  {343, 2},  {345, 22}, {367, 3},  {370, 2},  {372, 2},  {374, 2},
-    {376, 9},  {385, 0},  {385, 4},  {389, 3},  {392, 0},  {392, 2},  {394, 7},
-    {401, 4},  {405, 2},  {407, 4},  {411, 0},  {411, 21}, {432, 4},  {436, 3},
-    {439, 4},  {443, 6},  {449, 2},  {451, 5},  {456, 2},  {458, 8},  {466, 1},
-    {467, 2},  {469, 2},  {471, 5},  {476, 0},  {476, 2},  {478, 2},  {480, 6},
-    {486, 26}, {512, 4},  {516, 2},  {518, 2},  {520, 4},  {524, 0},  {524, 2},
-    {526, 2},  {528, 2},  {530, 2},  {532, 5},  {537, 2},  {539, 3},  {542, 2},
-    {544, 4},  {548, 5},  {553, 2},  {555, 0},  {555, 2},  {557, 4},  {561, 5},
-    {566, 3},  {569, 2},  {571, 3},  {574, 0},  {574, 2},  {576, 9},  {585, 2},
-    {587, 5},  {592, 6},  {598, 5},  {603, 4},  {607, 4},  {611, 8},  {619, 4},
-    {623, 0},  {623, 7},  {630, 4},  {634, 4},  {638, 5},  {643, 2},  {645, 2},
-    {647, 4},  {651, 4},  {655, 2},  {657, 2},  {659, 1},  {660, 2},  {662, 5},
-    {667, 4},  {671, 3},  {674, 2},  {676, 2},  {678, 4},  {682, 0},  {682, 9},
-    {691, 2},  {693, 2},  {695, 5},  {700, 4},  {704, 3},  {707, 2},  {709, 10},
-    {719, 2},  {721, 4},  {725, 4},  {729, 2},  {731, 6},  {737, 2},  {739, 2},
-    {741, 9},  {750, 1},  {751, 4},  {755, 3},  {758, 5},  {763, 6},  {769, 4},
-    {773, 1},  {774, 4},  {778, 0},  {778, 3},  {781, 1},  {782, 5},  {787, 10},
-    {797, 7},  {804, 3},  {807, 2},  {809, 5},  {814, 2},  {816, 0},  {816, 2},
-    {818, 2},  {820, 2},  {822, 6},  {828, 2},  {830, 1},  {831, 2},  {833, 2},
-    {835, 8},  {843, 2},  {845, 4},  {849, 4},  {853, 4},  {857, 2},  {859, 2},
-    {861, 2},  {863, 3},  {866, 2},  {868, 2},  {870, 4},  {874, 3},  {877, 5},
-    {882, 20}, {902, 2},  {904, 0},  {904, 2},  {906, 6},  {912, 1},  {913, 2},
-    {915, 1},  {916, 2},  {918, 4},  {922, 2},  {924, 2},  {926, 4},  {930, 4},
-    {934, 20}, {954, 1},  {955, 2},  {957, 4},  {961, 4},  {965, 2},  {967, 2},
-    {969, 4},  {973, 2},  {975, 0},  {975, 2},  {977, 5},  {982, 5},  {987, 8},
-    {995, 2},  {997, 2},  {999, 4},  {1003, 4}, {1007, 2}, {1009, 4}, {1013, 0},
-    {1013, 1}, {1014, 2}, {1016, 9}, {1025, 2}, {1027, 0}, {1027, 8}, {1035, 2},
-    {1037, 2}, {1039, 0}, {1039, 4}, {1043, 2}, {1045, 0}, {1045, 2}, {1047, 3},
-    {1050, 2}, {1052, 5}, {1057, 2}, {1059, 2}, {1061, 4}, {1065, 3}, {1068, 0},
-    {1068, 4}, {1072, 2}, {1074, 2}, {1076, 3}, {1079, 4}, {1083, 8}, {1091, 5},
-    {1096, 0}, {1096, 4}, {1100, 6}, {1106, 2}, {1108, 1}, {1109, 2}, {1111, 2},
-    {1113, 2}, {1115, 1}, {1116, 2}, {1118, 7},
-};
-const uint8_t g_XFAElementAttributeData[] = {
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Max,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_EofAction,
-    XFA_ATTRIBUTE_CursorType,
-    XFA_ATTRIBUTE_LockType,
-    XFA_ATTRIBUTE_BofAction,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_CursorLocation,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Relation,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_BeforeTarget,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_OverflowTarget,
-    XFA_ATTRIBUTE_OverflowLeader,
-    XFA_ATTRIBUTE_OverflowTrailer,
-    XFA_ATTRIBUTE_StartNew,
-    XFA_ATTRIBUTE_BookendTrailer,
-    XFA_ATTRIBUTE_After,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_BookendLeader,
-    XFA_ATTRIBUTE_AfterTarget,
-    XFA_ATTRIBUTE_Before,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_AllowNeutral,
-    XFA_ATTRIBUTE_Mark,
-    XFA_ATTRIBUTE_Shape,
-    XFA_ATTRIBUTE_Size,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_StartAngle,
-    XFA_ATTRIBUTE_SweepAngle,
-    XFA_ATTRIBUTE_Circular,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Hand,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Bind,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_From,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_SignatureType,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Permissions,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_StartNew,
-    XFA_ATTRIBUTE_Trailer,
-    XFA_ATTRIBUTE_TargetType,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Target,
-    XFA_ATTRIBUTE_Leader,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_TimeStamp,
-    XFA_ATTRIBUTE_Uuid,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_LeftInset,
-    XFA_ATTRIBUTE_BottomInset,
-    XFA_ATTRIBUTE_TopInset,
-    XFA_ATTRIBUTE_RightInset,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_NonRepudiation,
-    XFA_ATTRIBUTE_EncipherOnly,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_DigitalSignature,
-    XFA_ATTRIBUTE_CrlSign,
-    XFA_ATTRIBUTE_KeyAgreement,
-    XFA_ATTRIBUTE_KeyEncipherment,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_DataEncipherment,
-    XFA_ATTRIBUTE_KeyCertSign,
-    XFA_ATTRIBUTE_DecipherOnly,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Open,
-    XFA_ATTRIBUTE_CommitOn,
-    XFA_ATTRIBUTE_TextEntry,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_HAlign,
-    XFA_ATTRIBUTE_TextIndent,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Widows,
-    XFA_ATTRIBUTE_MarginRight,
-    XFA_ATTRIBUTE_MarginLeft,
-    XFA_ATTRIBUTE_RadixOffset,
-    XFA_ATTRIBUTE_Preserve,
-    XFA_ATTRIBUTE_SpaceBelow,
-    XFA_ATTRIBUTE_VAlign,
-    XFA_ATTRIBUTE_TabDefault,
-    XFA_ATTRIBUTE_TabStops,
-    XFA_ATTRIBUTE_Orphans,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_LineHeight,
-    XFA_ATTRIBUTE_SpaceAbove,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Version,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_AddRevocationInfo,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Listen,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Activity,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_DataRowCount,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_DataPrep,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_TextLocation,
-    XFA_ATTRIBUTE_ModuleWidth,
-    XFA_ATTRIBUTE_PrintCheckDigit,
-    XFA_ATTRIBUTE_ModuleHeight,
-    XFA_ATTRIBUTE_StartChar,
-    XFA_ATTRIBUTE_Truncate,
-    XFA_ATTRIBUTE_WideNarrowRatio,
-    XFA_ATTRIBUTE_ErrorCorrectionLevel,
-    XFA_ATTRIBUTE_UpsMode,
-    XFA_ATTRIBUTE_Checksum,
-    XFA_ATTRIBUTE_CharEncoding,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_DataColumnCount,
-    XFA_ATTRIBUTE_RowColumnRatio,
-    XFA_ATTRIBUTE_DataLength,
-    XFA_ATTRIBUTE_EndChar,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Format,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Output,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Input,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_DataDescription,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Highlight,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Break,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Hand,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Level,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_ColSpan,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_WordCharacterCount,
-    XFA_ATTRIBUTE_Hyphenate,
-    XFA_ATTRIBUTE_ExcludeInitialCap,
-    XFA_ATTRIBUTE_PushCharacterCount,
-    XFA_ATTRIBUTE_RemainCharacterCount,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_ExcludeAllCaps,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Rid,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_MaxChars,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Url,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_CredentialServerPolicy,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_UrlPolicy,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Connection,
-    XFA_ATTRIBUTE_Target,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_NumberOfCells,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_H,
-    XFA_ATTRIBUTE_W,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_HAlign,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Access,
-    XFA_ATTRIBUTE_Rotate,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_VAlign,
-    XFA_ATTRIBUTE_MaxH,
-    XFA_ATTRIBUTE_MaxW,
-    XFA_ATTRIBUTE_MinH,
-    XFA_ATTRIBUTE_MinW,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_ColSpan,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Locale,
-    XFA_ATTRIBUTE_AnchorType,
-    XFA_ATTRIBUTE_AccessKey,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_H,
-    XFA_ATTRIBUTE_W,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Cap,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Stroke,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_Thickness,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Rate,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_SourceBelow,
-    XFA_ATTRIBUTE_OutputBelow,
-    XFA_ATTRIBUTE_SourceAbove,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_H,
-    XFA_ATTRIBUTE_W,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_HAlign,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Access,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_VAlign,
-    XFA_ATTRIBUTE_MaxH,
-    XFA_ATTRIBUTE_MaxW,
-    XFA_ATTRIBUTE_MinH,
-    XFA_ATTRIBUTE_MinW,
-    XFA_ATTRIBUTE_Layout,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_ColSpan,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_AnchorType,
-    XFA_ATTRIBUTE_AccessKey,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Rid,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Scope,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Connection,
-    XFA_ATTRIBUTE_RunAt,
-    XFA_ATTRIBUTE_ExecuteType,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Picker,
-    XFA_ATTRIBUTE_HScrollPolicy,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_ContentType,
-    XFA_ATTRIBUTE_TransferEncoding,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Aspect,
-    XFA_ATTRIBUTE_Href,
-    XFA_ATTRIBUTE_Value,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Server,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_FracDigits,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_LeadDigits,
-    XFA_ATTRIBUTE_H,
-    XFA_ATTRIBUTE_W,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_HAlign,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_AllowMacro,
-    XFA_ATTRIBUTE_ColumnWidths,
-    XFA_ATTRIBUTE_Access,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_VAlign,
-    XFA_ATTRIBUTE_MaxH,
-    XFA_ATTRIBUTE_MaxW,
-    XFA_ATTRIBUTE_MinH,
-    XFA_ATTRIBUTE_MinW,
-    XFA_ATTRIBUTE_Layout,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_MergeMode,
-    XFA_ATTRIBUTE_ColSpan,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Locale,
-    XFA_ATTRIBUTE_AnchorType,
-    XFA_ATTRIBUTE_RestoreState,
-    XFA_ATTRIBUTE_Scope,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Timeout,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Mode,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Role,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Stroke,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_Inverted,
-    XFA_ATTRIBUTE_Thickness,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Join,
-    XFA_ATTRIBUTE_Radius,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_CSpace,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Value,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Next,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Previous,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Intact,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_CommandType,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Data,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_ScriptTest,
-    XFA_ATTRIBUTE_NullTest,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_FormatTest,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Relation,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_DuplexImposition,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_To,
-    XFA_ATTRIBUTE_Force,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_From,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Value,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_DataDescription,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Operation,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_BaseProfile,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_ContentType,
-    XFA_ATTRIBUTE_RunAt,
-    XFA_ATTRIBUTE_Binding,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_PasswordChar,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_HScrollPolicy,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_HScrollPolicy,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_PagePosition,
-    XFA_ATTRIBUTE_OddOrEven,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_InitialNumber,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Numbered,
-    XFA_ATTRIBUTE_BlankOrNotBlank,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Reserve,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Placement,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Rid,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_ContentType,
-    XFA_ATTRIBUTE_TransferEncoding,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_MaxLength,
-    XFA_ATTRIBUTE_Href,
-    XFA_ATTRIBUTE_Abbr,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_WritingScript,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Action,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Trailer,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Target,
-    XFA_ATTRIBUTE_Leader,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_To,
-    XFA_ATTRIBUTE_UnicodeRange,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_From,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_TrayOut,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Orientation,
-    XFA_ATTRIBUTE_ImagingBBox,
-    XFA_ATTRIBUTE_Short,
-    XFA_ATTRIBUTE_TrayIn,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Stock,
-    XFA_ATTRIBUTE_Long,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_VScrollPolicy,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_AllowRichText,
-    XFA_ATTRIBUTE_MultiLine,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_HScrollPolicy,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_MaxEntries,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_ContentType,
-    XFA_ATTRIBUTE_Contains,
-    XFA_ATTRIBUTE_Value,
-    XFA_ATTRIBUTE_IsNull,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_DataDescription,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Operation,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Target,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_ContentType,
-    XFA_ATTRIBUTE_TransferEncoding,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Match,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Hand,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_H,
-    XFA_ATTRIBUTE_W,
-    XFA_ATTRIBUTE_X,
-    XFA_ATTRIBUTE_Y,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_HAlign,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Rotate,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_VAlign,
-    XFA_ATTRIBUTE_MaxH,
-    XFA_ATTRIBUTE_MaxW,
-    XFA_ATTRIBUTE_MinH,
-    XFA_ATTRIBUTE_MinW,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_ColSpan,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Locale,
-    XFA_ATTRIBUTE_AnchorType,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Rid,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Priority,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Disable,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Value,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_LineThrough,
-    XFA_ATTRIBUTE_Typeface,
-    XFA_ATTRIBUTE_FontHorizontalScale,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_KerningMode,
-    XFA_ATTRIBUTE_Underline,
-    XFA_ATTRIBUTE_BaselineShift,
-    XFA_ATTRIBUTE_OverlinePeriod,
-    XFA_ATTRIBUTE_LetterSpacing,
-    XFA_ATTRIBUTE_LineThroughPeriod,
-    XFA_ATTRIBUTE_FontVerticalScale,
-    XFA_ATTRIBUTE_PsName,
-    XFA_ATTRIBUTE_Size,
-    XFA_ATTRIBUTE_Posture,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Weight,
-    XFA_ATTRIBUTE_UnderlinePeriod,
-    XFA_ATTRIBUTE_Overline,
-    XFA_ATTRIBUTE_GenericFamily,
-    XFA_ATTRIBUTE_Checksum,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Relevant,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Override,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Trailer,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Leader,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_CodeType,
-    XFA_ATTRIBUTE_Archive,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_CodeBase,
-    XFA_ATTRIBUTE_ClassId,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Connection,
-    XFA_ATTRIBUTE_LabelRef,
-    XFA_ATTRIBUTE_ValueRef,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Override,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Value,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Timeout,
-    XFA_ATTRIBUTE_Connection,
-    XFA_ATTRIBUTE_Usage,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_DelayedOpen,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Format,
-    XFA_ATTRIBUTE_EmbedPDF,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Target,
-    XFA_ATTRIBUTE_TextEncoding,
-    XFA_ATTRIBUTE_XdpContent,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Delimiter,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_StartNew,
-    XFA_ATTRIBUTE_Trailer,
-    XFA_ATTRIBUTE_TargetType,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Target,
-    XFA_ATTRIBUTE_Leader,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Slope,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Hand,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Max,
-    XFA_ATTRIBUTE_Min,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Initial,
-    XFA_ATTRIBUTE_Usehref,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Abbr,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Desc,
-    XFA_ATTRIBUTE_Lock,
-    XFA_ATTRIBUTE_Id,
-    XFA_ATTRIBUTE_Name,
-    XFA_ATTRIBUTE_Ref,
-    XFA_ATTRIBUTE_Use,
-    XFA_ATTRIBUTE_Presence,
-    XFA_ATTRIBUTE_Save,
-    XFA_ATTRIBUTE_Usehref,
-};
-const XFA_PACKETINFO g_XFAPacketData[] = {
-    {0x0, NULL, XFA_XDPPACKET_USER, NULL,
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTMANY},
-    {0x811929d, L"sourceSet", XFA_XDPPACKET_SourceSet,
-     L"http://www.xfa.org/schema/xfa-source-set/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0xb843dba, L"pdf", XFA_XDPPACKET_Pdf, L"http://ns.adobe.com/xdp/pdf/",
-     XFA_XDPPACKET_FLAGS_COMPLETEMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0xc56afbf, L"xdc", XFA_XDPPACKET_Xdc, L"http://www.xfa.org/schema/xdc/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0xc56afcc, L"xdp", XFA_XDPPACKET_XDP, L"http://ns.adobe.com/xdp/",
-     XFA_XDPPACKET_FLAGS_COMPLETEMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0x132a8fbc, L"xmpmeta", XFA_XDPPACKET_Xmpmeta,
-     L"http://ns.adobe.com/xmpmeta/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTMANY},
-    {0x48d004a8, L"xfdf", XFA_XDPPACKET_Xfdf, L"http://ns.adobe.com/xfdf/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0x4e1e39b6, L"config", XFA_XDPPACKET_Config,
-     L"http://www.xfa.org/schema/xci/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0x5473b6dc, L"localeSet", XFA_XDPPACKET_LocaleSet,
-     L"http://www.xfa.org/schema/xfa-locale-set/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0x6038580a, L"stylesheet", XFA_XDPPACKET_Stylesheet,
-     L"http://www.w3.org/1999/XSL/Transform",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTMANY},
-    {0x803550fc, L"template", XFA_XDPPACKET_Template,
-     L"http://www.xfa.org/schema/xfa-template/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0x8b036f32, L"signature", XFA_XDPPACKET_Signature,
-     L"http://www.w3.org/2000/09/xmldsig#",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0x99b95079, L"datasets", XFA_XDPPACKET_Datasets,
-     L"http://www.xfa.org/schema/xfa-data/",
-     XFA_XDPPACKET_FLAGS_PREFIXMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0xcd309ff4, L"form", XFA_XDPPACKET_Form,
-     L"http://www.xfa.org/schema/xfa-form/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-    {0xe14c801c, L"connectionSet", XFA_XDPPACKET_ConnectionSet,
-     L"http://www.xfa.org/schema/xfa-connection-set/",
-     XFA_XDPPACKET_FLAGS_NOMATCH | XFA_XDPPACKET_FLAGS_SUPPORTONE},
-};
-const int32_t g_iXFAPacketCount =
-    sizeof(g_XFAPacketData) / sizeof(XFA_PACKETINFO);
-const XFA_SCRIPTHIERARCHY g_XFAScriptIndex[] = {
-    {0, 0, 0, 2, 316},      {0, 0, 2, 2, 316},       {0, 0, 4, 2, 316},
-    {0, 0, 6, 8, 316},      {0, 0, 14, 4, 316},      {0, 0, 18, 5, 317},
-    {0, 0, 23, 2, 316},     {0, 0, 25, 1, 316},      {0, 0, 26, 12, 316},
-    {0, 0, 38, 2, 316},     {0, 0, 40, 1, 316},      {0, 0, 41, 3, 316},
-    {0, 0, 44, 2, 316},     {0, 0, 46, 6, 316},      {0, 0, 52, 0, 316},
-    {0, 0, 52, 2, 319},     {0, 0, 54, 2, 316},      {0, 0, 56, 6, 316},
-    {0, 0, 62, 0, 316},     {0, 0, 62, 0, 316},      {0, 0, 62, 2, 316},
-    {0, 0, 64, 2, 316},     {0, 0, 66, 6, 316},      {0, 0, 72, 4, 316},
-    {0, 0, 76, 7, 316},     {0, 0, 83, 2, 320},      {0, 0, 85, 3, 316},
-    {0, 0, 88, 3, 316},     {0, 0, 91, 2, 320},      {0, 0, 93, 6, 320},
-    {0, 0, 99, 4, 316},     {0, 0, 103, 2, 316},     {0, 0, 105, 3, 319},
-    {0, 0, 108, 4, 316},    {0, 0, 112, 3, 316},     {0, 0, 115, 2, 316},
-    {0, 0, 117, 6, 316},    {0, 0, 123, 12, 316},    {0, 0, 135, 2, 316},
-    {0, 0, 137, 5, 316},    {0, 0, 142, 2, 316},     {0, 0, 144, 3, 316},
-    {0, 0, 147, 1, 316},    {0, 0, 148, 14, 316},    {0, 0, 162, 2, 316},
-    {0, 0, 164, 2, 316},    {0, 0, 166, 3, 316},     {0, 0, 169, 2, 316},
-    {0, 0, 171, 2, 316},    {0, 0, 173, 2, 316},     {0, 0, 175, 4, 316},
-    {0, 0, 179, 2, 316},    {0, 0, 181, 2, 316},     {0, 0, 183, 0, 319},
-    {0, 0, 183, 20, 316},   {0, 0, 203, 1, 316},     {0, 0, 204, 3, 316},
-    {0, 0, 207, 2, 316},    {0, 0, 209, 0, 316},     {0, 0, 209, 2, 316},
-    {0, 0, 211, 2, 316},    {0, 0, 213, 4, 320},     {0, 0, 217, 0, 316},
-    {0, 0, 217, 1, 316},    {0, 0, 218, 3, 316},     {0, 4, 221, 0, 312},
-    {4, 1, 221, 1, 316},    {5, 0, 222, 2, 316},     {5, 1, 224, 3, -1},
-    {6, 0, 227, 0, 316},    {6, 0, 227, 2, 316},     {6, 0, 229, 2, 316},
-    {6, 0, 231, 3, 316},    {6, 0, 234, 2, 316},     {6, 0, 236, 6, 316},
-    {6, 0, 242, 10, 317},   {6, 0, 252, 9, 316},     {6, 0, 261, 5, 318},
-    {6, 0, 266, 4, 318},    {6, 0, 270, 2, 316},     {6, 0, 272, 2, 316},
-    {6, 0, 274, 5, 316},    {6, 0, 279, 3, 316},     {6, 0, 282, 2, 316},
-    {6, 0, 284, 2, 316},    {6, 0, 286, 2, 316},     {6, 0, 288, 2, 316},
-    {6, 0, 290, 4, 316},    {6, 0, 294, 3, 316},     {6, 0, 297, 3, 316},
-    {6, 0, 300, 2, 316},    {6, 0, 302, 2, 316},     {6, 0, 304, 2, 316},
-    {6, 13, 306, 36, 317},  {19, 0, 342, 3, 316},    {19, 0, 345, 2, 316},
-    {19, 0, 347, 2, 316},   {19, 0, 349, 2, 316},    {19, 0, 351, 7, 317},
-    {19, 2, 358, 16, 312},  {21, 0, 374, 2, 320},    {21, 0, 376, 2, 316},
-    {21, 0, 378, 0, 316},   {21, 0, 378, 2, 316},    {21, 0, 380, 6, 316},
-    {21, 0, 386, 3, 316},   {21, 0, 389, 2, 316},    {21, 0, 391, 4, 316},
-    {21, 0, 395, 0, 316},   {21, 5, 395, 30, 316},   {26, 0, 425, 2, 320},
-    {26, 0, 427, 3, 316},   {26, 0, 430, 2, 320},    {26, 0, 432, 5, 316},
-    {26, 0, 437, 2, 316},   {26, 0, 439, 3, 316},    {26, 0, 442, 2, 316},
-    {26, 0, 444, 8, 316},   {26, 0, 452, 1, 316},    {26, 0, 453, 2, 316},
-    {26, 0, 455, 2, 316},   {26, 0, 457, 4, 316},    {26, 0, 461, 0, 316},
-    {26, 0, 461, 2, 316},   {26, 0, 463, 2, 316},    {26, 0, 465, 6, 318},
-    {26, 5, 471, 31, 317},  {31, 0, 502, 2, 320},    {31, 0, 504, 2, 316},
-    {31, 0, 506, 2, 316},   {31, 0, 508, 4, 320},    {31, 16, 512, 14, 312},
-    {47, 0, 526, 2, 316},   {47, 0, 528, 2, 316},    {47, 0, 530, 2, 316},
-    {47, 0, 532, 2, 316},   {47, 0, 534, 3, 316},    {47, 0, 537, 2, 316},
-    {47, 0, 539, 3, 316},   {47, 0, 542, 3, 316},    {47, 0, 545, 4, 318},
-    {47, 0, 549, 4, 316},   {47, 0, 553, 2, 316},    {47, 0, 555, 0, 316},
-    {47, 0, 555, 2, 316},   {47, 0, 557, 3, 316},    {47, 0, 560, 6, 316},
-    {47, 0, 566, 2, 316},   {47, 0, 568, 2, 316},    {47, 0, 570, 3, 316},
-    {47, 19, 573, 1, 312},  {66, 0, 574, 2, 316},    {66, 0, 576, 8, 316},
-    {66, 0, 584, 2, 316},   {66, 0, 586, 4, 316},    {66, 0, 590, 5, 316},
-    {66, 0, 595, 3, 316},   {66, 0, 598, 2, 320},    {66, 0, 600, 3, 316},
-    {66, 0, 603, 7, 316},   {66, 0, 610, 3, 316},    {66, 0, 613, 0, 316},
-    {66, 0, 613, 4, 317},   {66, 0, 617, 4, 318},    {66, 0, 621, 2, 320},
-    {66, 0, 623, 5, 316},   {66, 0, 628, 2, 316},    {66, 0, 630, 2, 316},
-    {66, 0, 632, 2, 320},   {66, 0, 634, 2, 320},    {66, 0, 636, 4, 316},
-    {66, 0, 640, 2, 316},   {66, 0, 642, 1, 316},    {66, 0, 643, 1, 316},
-    {66, 0, 644, 4, 316},   {66, 0, 648, 3, 316},    {66, 7, 651, 2, 319},
-    {73, 0, 653, 2, 316},   {73, 0, 655, 2, 316},    {73, 0, 657, 3, 316},
-    {73, 4, 660, 4, 312},   {77, 0, 664, 10, 316},   {77, 0, 674, 2, 316},
-    {77, 0, 676, 4, 316},   {77, 0, 680, 4, 316},    {77, 0, 684, 3, 316},
-    {77, 0, 687, 2, 316},   {77, 0, 689, 2, 316},    {77, 0, 691, 8, 317},
-    {77, 0, 699, 3, 316},   {77, 0, 702, 3, 316},    {77, 0, 705, 2, 316},
-    {77, 0, 707, 2, 316},   {77, 0, 709, 5, 316},    {77, 0, 714, 4, 316},
-    {77, 0, 718, 2, 316},   {77, 0, 720, 8, 318},    {77, 0, 728, 1, 316},
-    {77, 0, 729, 2, 320},   {77, 0, 731, 3, 316},    {77, 1, 734, 4, 316},
-    {78, 0, 738, 5, 316},   {78, 0, 743, 3, 316},    {78, 0, 746, 1, 316},
-    {78, 0, 747, 2, 320},   {78, 0, 749, 0, 313},    {78, 0, 749, 2, 316},
-    {78, 5, 751, 3, 316},   {83, 0, 754, 5, 316},    {83, 0, 759, 7, 316},
-    {83, 0, 766, 6, 316},   {83, 0, 772, 3, 316},    {83, 0, 775, 2, 316},
-    {83, 0, 777, 5, 316},   {83, 0, 782, 2, 316},    {83, 0, 784, 0, 314},
-    {83, 0, 784, 2, 316},   {83, 0, 786, 1, 316},    {83, 0, 787, 2, 316},
-    {83, 0, 789, 5, 316},   {83, 0, 794, 2, 316},    {83, 0, 796, 1, 316},
-    {83, 0, 797, 2, 316},   {83, 0, 799, 2, 316},    {83, 0, 801, 6, 316},
-    {83, 0, 807, 2, 316},   {83, 0, 809, 2, 320},    {83, 0, 811, 3, 316},
-    {83, 0, 814, 4, 316},   {83, 0, 818, 2, 316},    {83, 0, 820, 2, 316},
-    {83, 0, 822, 2, 316},   {83, 0, 824, 2, 316},    {83, 0, 826, 2, 316},
-    {83, 0, 828, 2, 316},   {83, 0, 830, 4, 318},    {83, 1, 834, 2, 316},
-    {84, 0, 836, 5, 316},   {84, 0, 841, 20, 317},   {84, 0, 861, 2, 316},
-    {84, 0, 863, 0, 316},   {84, 0, 863, 2, 316},    {84, 0, 865, 4, 320},
-    {84, 0, 869, 0, 316},   {84, 0, 869, 2, 316},    {84, 0, 871, 1, 316},
-    {84, 0, 872, 2, 316},   {84, 0, 874, 3, 316},    {84, 0, 877, 2, 316},
-    {84, 0, 879, 2, 316},   {84, 0, 881, 4, 316},    {84, 0, 885, 3, 316},
-    {84, 0, 888, 17, 316},  {84, 6, 905, 1, 319},    {90, 0, 906, 2, 316},
-    {90, 0, 908, 2, 320},   {90, 0, 910, 2, 320},    {90, 0, 912, 2, 316},
-    {90, 0, 914, 2, 316},   {90, 0, 916, 4, 318},    {90, 0, 920, 2, 316},
-    {90, 5, 922, 0, 312},   {95, 0, 922, 2, 316},    {95, 0, 924, 4, 316},
-    {95, 0, 928, 4, 316},   {95, 0, 932, 6, 316},    {95, 0, 938, 2, 316},
-    {95, 0, 940, 4, 316},   {95, 0, 944, 3, 316},    {95, 0, 947, 3, 316},
-    {95, 0, 950, 2, 316},   {95, 0, 952, 3, 316},    {95, 0, 955, 0, 316},
-    {95, 0, 955, 0, 316},   {95, 0, 955, 2, 316},    {95, 0, 957, 7, 316},
-    {95, 0, 964, 2, 316},   {95, 0, 966, 0, 319},    {95, 0, 966, 7, 316},
-    {95, 0, 973, 2, 316},   {95, 0, 975, 2, 316},    {95, 3, 977, 1, 316},
-    {98, 0, 978, 2, 320},   {98, 0, 980, 4, 316},    {98, 0, 984, 0, 316},
-    {98, 0, 984, 2, 316},   {98, 0, 986, 2, 316},    {98, 0, 988, 4, 316},
-    {98, 0, 992, 1, 316},   {98, 0, 993, 2, 316},    {98, 0, 995, 2, 316},
-    {98, 0, 997, 3, 316},   {98, 0, 1000, 2, 317},   {98, 0, 1002, 0, 316},
-    {98, 0, 1002, 4, 316},  {98, 0, 1006, 4, 316},   {98, 0, 1010, 2, 316},
-    {98, 0, 1012, 3, 316},  {98, 0, 1015, 4, 316},   {98, 0, 1019, 7, 316},
-    {98, 0, 1026, 4, 316},  {98, 0, 1030, 1, 313},   {98, 17, 1031, 3, 316},
-    {115, 0, 1034, 5, 316}, {115, 0, 1039, 2, 316},  {115, 0, 1041, 1, 316},
-    {115, 0, 1042, 4, 316}, {115, 0, 1046, 2, 316},  {115, 0, 1048, 2, 316},
-    {115, 0, 1050, 1, 316}, {115, 0, 1051, 2, 316},  {115, 0, 1053, 5, 316},
-    {115, 0, 1058, 1, -1},  {115, 4, 1059, 1, 312},  {119, 1, 1060, 0, 313},
-    {120, 2, 1060, 8, 312}, {122, 11, 1068, 6, 315}, {133, 2, 1074, 0, 316},
-    {135, 0, 1074, 0, 316}, {135, 3, 1074, 2, 316},  {138, 0, 1076, 2, 316},
-};
-const XFA_METHODINFO g_SomMethodData[] = {
-    {0x3c752495, L"verify", (XFA_METHOD_CALLBACK)&CScript_SignaturePseudoModel::
-                                Script_SignaturePseudoModel_Verify},
-    {0xa68635f1, L"sign", (XFA_METHOD_CALLBACK)&CScript_SignaturePseudoModel::
-                              Script_SignaturePseudoModel_Sign},
-    {0xa7f2c5e6, L"enumerate",
-     (XFA_METHOD_CALLBACK)&CScript_SignaturePseudoModel::
-         Script_SignaturePseudoModel_Enumerate},
-    {0xd8ed1467, L"clear", (XFA_METHOD_CALLBACK)&CScript_SignaturePseudoModel::
-                               Script_SignaturePseudoModel_Clear},
-    {0x4bdcce13, L"execute",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_WsdlConnection_Execute},
-    {0x1c296ba4, L"restore",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Delta_Restore},
-    {0x7d123a9, L"clearItems",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_ClearItems},
-    {0xfb0b007, L"execEvent",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_ExecEvent},
-    {0x6716ce97, L"execInitialize",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_ExecInitialize},
-    {0x7bb919c2, L"deleteItem",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_DeleteItem},
-    {0x9f053d5e, L"getSaveItem",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_GetSaveItem},
-    {0xbbd32747, L"boundItem",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_BoundItem},
-    {0xc492d950, L"getItemState",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_GetItemState},
-    {0xc6013cd3, L"execCalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_ExecCalculate},
-    {0xd8930d0e, L"setItems",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_SetItems},
-    {0xe0f15045, L"getDisplayItem",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_GetDisplayItem},
-    {0xe23acddc, L"setItemState",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_SetItemState},
-    {0xe2dfb2f8, L"addItem",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_AddItem},
-    {0xef8ce48f, L"execValidate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Field_ExecValidate},
-    {0x461079ef, L"emit", (XFA_METHOD_CALLBACK)&CScript_EventPseudoModel::
-                              Script_EventPseudoModel_Emit},
-    {0xfec90c63, L"reset", (XFA_METHOD_CALLBACK)&CScript_EventPseudoModel::
-                               Script_EventPseudoModel_Reset},
-    {0xfb0b007, L"execEvent",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ExclGroup_ExecEvent},
-    {0x3d832221, L"selectedMember",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ExclGroup_SelectedMember},
-    {0x6716ce97, L"execInitialize",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ExclGroup_ExecInitialize},
-    {0xc6013cd3, L"execCalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ExclGroup_ExecCalculate},
-    {0xef8ce48f, L"execValidate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ExclGroup_ExecValidate},
-    {0xfb0b007, L"execEvent",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Subform_ExecEvent},
-    {0x6716ce97, L"execInitialize",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Subform_ExecInitialize},
-    {0xc6013cd3, L"execCalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Subform_ExecCalculate},
-    {0xd9b9b1f1, L"getInvalidObjects",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Subform_GetInvalidObjects},
-    {0xef8ce48f, L"execValidate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Subform_ExecValidate},
-    {0xa366b7c, L"exportData", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                   Script_HostPseudoModel_ExportData},
-    {0x16cc226c, L"gotoURL", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                 Script_HostPseudoModel_GotoURL},
-    {0x1e0722f5, L"pageDown", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_PageDown},
-    {0x3e66cb2c, L"setFocus", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_SetFocus},
-    {0x4ac9faae, L"openList", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_OpenList},
-    {0x7b89714f, L"response", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_Response},
-    {0x7fd9fd58, L"documentInBatch",
-     (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_DocumentInBatch},
-    {0xaf1d019d, L"resetData", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                   Script_HostPseudoModel_ResetData},
-    {0xb07be13c, L"beep", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                              Script_HostPseudoModel_Beep},
-    {0xb1882ca0, L"getFocus", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_GetFocus},
-    {0xbf4ba9ee, L"messageBox", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                    Script_HostPseudoModel_MessageBox},
-    {0xd6d4dbc1, L"documentCountInBatch",
-     (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_DocumentCountInBatch},
-    {0xdd7676ed, L"print", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                               Script_HostPseudoModel_Print},
-    {0xe2f863d0, L"currentDateTime",
-     (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_CurrentDateTime},
-    {0xf995d0f5, L"importData", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                    Script_HostPseudoModel_ImportData},
-    {0xfeb96b62, L"pageUp", (XFA_METHOD_CALLBACK)&CScript_HostPseudoModel::
-                                Script_HostPseudoModel_PageUp},
-    {0x68, L"h", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                     Script_LayoutPseudoModel_H},
-    {0x77, L"w", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                     Script_LayoutPseudoModel_W},
-    {0x78, L"x", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                     Script_LayoutPseudoModel_X},
-    {0x79, L"y", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                     Script_LayoutPseudoModel_Y},
-    {0x5460206, L"pageCount", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                                  Script_LayoutPseudoModel_PageCount},
-    {0x5eb5b0f, L"pageSpan", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                                 Script_LayoutPseudoModel_PageSpan},
-    {0x10f1b1bd, L"page", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                              Script_LayoutPseudoModel_Page},
-    {0x1c1e6318, L"pageContent",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_PageContent},
-    {0x1c1f4a5c, L"absPageCount",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_AbsPageCount},
-    {0x1ec47db5, L"absPageCountInBatch",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_AbsPageCountInBatch},
-    {0x2e4ecbdb, L"sheetCountInBatch",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_SheetCountInBatch},
-    {0x2fcff4b5, L"relayout", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                                  Script_LayoutPseudoModel_Relayout},
-    {0x3bf1c2a5, L"absPageSpan",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_AbsPageSpan},
-    {0x5775c2cc, L"absPageInBatch",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_AbsPageInBatch},
-    {0x8c5feb32, L"sheetInBatch",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_SheetInBatch},
-    {0x8f3a8379, L"sheet", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                               Script_LayoutPseudoModel_Sheet},
-    {0x96f3c4cb, L"relayoutPageArea",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_RelayoutPageArea},
-    {0xd2a4a542, L"sheetCount",
-     (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-         Script_LayoutPseudoModel_SheetCount},
-    {0xe74f0653, L"absPage", (XFA_METHOD_CALLBACK)&CScript_LayoutPseudoModel::
-                                 Script_LayoutPseudoModel_AbsPage},
-    {0x44c352ad, L"formNodes",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_FormNodes},
-    {0x45efb847, L"remerge",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_Remerge},
-    {0x6716ce97, L"execInitialize",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_ExecInitialize},
-    {0x712c6afa, L"createNode",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_CreateNode},
-    {0xa8a35e25, L"recalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_Recalculate},
-    {0xc6013cd3, L"execCalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_ExecCalculate},
-    {0xef8ce48f, L"execValidate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Template_ExecValidate},
-    {0x4cc1c0f9, L"moveCurrentRecord",
-     (XFA_METHOD_CALLBACK)&CScript_DataWindow::
-         Script_DataWindow_MoveCurrentRecord},
-    {0x5779d65f, L"record",
-     (XFA_METHOD_CALLBACK)&CScript_DataWindow::Script_DataWindow_Record},
-    {0x8a476498, L"gotoRecord",
-     (XFA_METHOD_CALLBACK)&CScript_DataWindow::Script_DataWindow_GotoRecord},
-    {0xaac241c8, L"isRecordGroup",
-     (XFA_METHOD_CALLBACK)&CScript_DataWindow::Script_DataWindow_IsRecordGroup},
-    {0x1c6f4277, L"evaluate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Manifest_Evaluate},
-    {0x2afec2cc, L"moveInstance",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_InstanceManager_MoveInstance},
-    {0x2bf94a63, L"removeInstance",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_InstanceManager_RemoveInstance},
-    {0x303adaf4, L"setInstances",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_InstanceManager_SetInstances},
-    {0x4d76b89e, L"addInstance",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_InstanceManager_AddInstance},
-    {0xc660dc8a, L"insertInstance",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_InstanceManager_InsertInstance},
-    {0xddfd1ea1, L"metadata",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Desc_Metadata},
-    {0x44c352ad, L"formNodes",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Form_FormNodes},
-    {0x45efb847, L"remerge",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Form_Remerge},
-    {0x6716ce97, L"execInitialize",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Form_ExecInitialize},
-    {0xa8a35e25, L"recalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Form_Recalculate},
-    {0xc6013cd3, L"execCalculate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Form_ExecCalculate},
-    {0xef8ce48f, L"execValidate",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Form_ExecValidate},
-    {0x60490a85, L"message", (XFA_METHOD_CALLBACK)&CScript_LogPseudoModel::
-                                 Script_LogPseudoModel_Message},
-    {0x60ecfcc9, L"traceDeactivate",
-     (XFA_METHOD_CALLBACK)&CScript_LogPseudoModel::
-         Script_LogPseudoModel_TraceDeactivate},
-    {0x86a0f4c0, L"traceActivate",
-     (XFA_METHOD_CALLBACK)&CScript_LogPseudoModel::
-         Script_LogPseudoModel_TraceActivate},
-    {0x93eac39a, L"traceEnabled", (XFA_METHOD_CALLBACK)&CScript_LogPseudoModel::
-                                      Script_LogPseudoModel_TraceEnabled},
-    {0xd1227e6f, L"trace",
-     (XFA_METHOD_CALLBACK)&CScript_LogPseudoModel::Script_LogPseudoModel_Trace},
-    {0x36c0ee14, L"getAttribute",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Packet_GetAttribute},
-    {0x5468e2a0, L"setAttribute",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Packet_SetAttribute},
-    {0xadc48de2, L"removeAttribute",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Packet_RemoveAttribute},
-    {0x3848b3f, L"next", (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Next},
-    {0x14e25bc8, L"cancelBatch",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_CancelBatch},
-    {0x3ce05d68, L"first",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_First},
-    {0x649e1e65, L"updateBatch",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_UpdateBatch},
-    {0x6a3405dd, L"previous",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Previous},
-    {0x74818fb3, L"isBOF",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_IsBOF},
-    {0x74d07a76, L"isEOF",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_IsEOF},
-    {0x7613cb66, L"cancel",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Cancel},
-    {0x7baca2e3, L"update",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Update},
-    {0x8b90e1f2, L"open", (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Open},
-    {0x9c6471b3, L"delete",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Delete},
-    {0xa7315093, L"addNew",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_AddNew},
-    {0xa7ce5f8d, L"requery",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Requery},
-    {0xc7368674, L"resync",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Resync},
-    {0xd9f47f36, L"close",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Close},
-    {0xf54481d4, L"last", (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_Last},
-    {0xf7965460, L"hasDataChanged",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_Source_HasDataChanged},
-    {0x6275f6af, L"item",
-     (XFA_METHOD_CALLBACK)&CXFA_NodeList::Script_ListClass_Item},
-    {0x7033bfd5, L"insert",
-     (XFA_METHOD_CALLBACK)&CXFA_NodeList::Script_ListClass_Insert},
-    {0x9cab7cae, L"remove",
-     (XFA_METHOD_CALLBACK)&CXFA_NodeList::Script_ListClass_Remove},
-    {0xda12e518, L"append",
-     (XFA_METHOD_CALLBACK)&CXFA_NodeList::Script_ListClass_Append},
-    {0xd892a054, L"namedItem",
-     (XFA_METHOD_CALLBACK)&CXFA_NodeList::Script_TreelistClass_NamedItem},
-    {0xba2dd386, L"resolveNode",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_TreeClass_ResolveNode},
-    {0xe509e2b9, L"resolveNodes",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_TreeClass_ResolveNodes},
-    {0x1bca1ebd, L"applyXSL",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_ApplyXSL},
-    {0x36c0ee14, L"getAttribute",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_GetAttribute},
-    {0x5468e2a0, L"setAttribute",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_SetAttribute},
-    {0x5ee00996, L"setElement",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_SetElement},
-    {0x92dada4f, L"saveFilteredXML",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_SaveFilteredXML},
-    {0x9c456500, L"saveXML",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_SaveXML},
-    {0xabd3200a, L"getElement",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_GetElement},
-    {0xb269c60d, L"isPropertySpecified",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_IsPropertySpecified},
-    {0xb528be91, L"loadXML",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_LoadXML},
-    {0xd9f46591, L"clone",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_Clone},
-    {0xe006a76b, L"assignNode",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_NodeClass_AssignNode},
-    {0x7303fcea, L"getDelta",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ContainerClass_GetDelta},
-    {0xe7742c9d, L"getDeltas",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ContainerClass_GetDeltas},
-    {0x30ff6aad, L"clearErrorList",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ModelClass_ClearErrorList},
-    {0x712c6afa, L"createNode",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ModelClass_CreateNode},
-    {0x83a6411d, L"isCompatibleNS",
-     (XFA_METHOD_CALLBACK)&CXFA_Node::Script_ModelClass_IsCompatibleNS},
-};
-const int32_t g_iSomMethodCount =
-    sizeof(g_SomMethodData) / sizeof(XFA_METHODINFO);
-const XFA_SCRIPTATTRIBUTEINFO g_SomAttributeData[] = {
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xb3543a6, L"max",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Max, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x45a6daf8, L"eofAction",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_EofAction, XFA_SCRIPT_Basic},
-    {0x5ec958c0, L"cursorType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CursorType, XFA_SCRIPT_Basic},
-    {0x79975f2b, L"lockType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LockType, XFA_SCRIPT_Basic},
-    {0xa5340ff5, L"bofAction",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BofAction, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc5762157, L"cursorLocation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CursorLocation, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1ee2d24d, L"instanceIndex",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_InstanceIndex, -1,
-     XFA_SCRIPT_Basic},
-    {0x8c99377e, L"relation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relation, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0x3106c3a, L"beforeTarget",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BeforeTarget, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x13a08bdb, L"overflowTarget",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_OverflowTarget, XFA_SCRIPT_Basic},
-    {0x169134a1, L"overflowLeader",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_OverflowLeader, XFA_SCRIPT_Basic},
-    {0x20914367, L"overflowTrailer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_OverflowTrailer, XFA_SCRIPT_Basic},
-    {0x453eaf38, L"startNew",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_StartNew, XFA_SCRIPT_Basic},
-    {0x64110ab5, L"bookendTrailer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BookendTrailer, XFA_SCRIPT_Basic},
-    {0xb6b44172, L"after",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_After, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc3c1442f, L"bookendLeader",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BookendLeader, XFA_SCRIPT_Basic},
-    {0xcb150479, L"afterTarget",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AfterTarget, XFA_SCRIPT_Basic},
-    {0xf4ffce73, L"before",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Before, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue_Read, -1,
-     XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x47cfa43a, L"allowNeutral",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AllowNeutral, XFA_SCRIPT_Basic},
-    {0x7c2fd80b, L"mark",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Mark, XFA_SCRIPT_Basic},
-    {0x8ed182d1, L"shape",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Shape, XFA_SCRIPT_Basic},
-    {0xa686975b, L"size",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Size, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x5c054755, L"startAngle",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_StartAngle, XFA_SCRIPT_Basic},
-    {0x74788f8b, L"sweepAngle",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_SweepAngle, XFA_SCRIPT_Basic},
-    {0x9d833d75, L"circular",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Circular, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd996fa9b, L"hand",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Hand, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xb0e5485d, L"bind",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Bind, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xcd7f7b54, L"from",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_From, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x8e29d794, L"signatureType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_SignatureType, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe11a2cbc, L"permissions",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Permissions, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x453eaf38, L"startNew",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_StartNew, XFA_SCRIPT_Basic},
-    {0x9dcc3ab3, L"trailer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Trailer, XFA_SCRIPT_Basic},
-    {0xa6118c89, L"targetType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TargetType, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Target, XFA_SCRIPT_Basic},
-    {0xcbcaf66d, L"leader",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Leader, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x2d574d58, L"this", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Xfa_This,
-     -1, XFA_SCRIPT_Object},
-    {0x4fdc3454, L"timeStamp",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TimeStamp, XFA_SCRIPT_Basic},
-    {0xb598a1f7, L"uuid",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Uuid, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xcfea02e, L"leftInset",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LeftInset, XFA_SCRIPT_Basic},
-    {0x1356caf8, L"bottomInset",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BottomInset, XFA_SCRIPT_Basic},
-    {0x25764436, L"topInset",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TopInset, XFA_SCRIPT_Basic},
-    {0x8a692521, L"rightInset",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RightInset, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1e459b8f, L"nonRepudiation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_NonRepudiation, XFA_SCRIPT_Basic},
-    {0x2bb3f470, L"encipherOnly",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_EncipherOnly, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0x5f760b50, L"digitalSignature",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DigitalSignature, XFA_SCRIPT_Basic},
-    {0x69aa2292, L"crlSign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CrlSign, XFA_SCRIPT_Basic},
-    {0x98fd4d81, L"keyAgreement",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_KeyAgreement, XFA_SCRIPT_Basic},
-    {0xa66404cb, L"keyEncipherment",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_KeyEncipherment, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xca5dc27c, L"dataEncipherment",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataEncipherment, XFA_SCRIPT_Basic},
-    {0xe8f118a8, L"keyCertSign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_KeyCertSign, XFA_SCRIPT_Basic},
-    {0xfea53ec6, L"decipherOnly",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DecipherOnly, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x8b90e1f2, L"open",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Open, XFA_SCRIPT_Basic},
-    {0x957fa006, L"commitOn",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CommitOn, XFA_SCRIPT_Basic},
-    {0xb12128b7, L"textEntry",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TextEntry, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0x2282c73, L"hAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HAlign, XFA_SCRIPT_Basic},
-    {0x8d4f1c7, L"textIndent",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TextIndent, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2a82d99c, L"marginRight",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MarginRight, XFA_SCRIPT_Basic},
-    {0x534729c9, L"marginLeft",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MarginLeft, XFA_SCRIPT_Basic},
-    {0x5739d1ff, L"radixOffset",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RadixOffset, XFA_SCRIPT_Basic},
-    {0x577682ac, L"preserve",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Preserve, XFA_SCRIPT_Basic},
-    {0x731e0665, L"spaceBelow",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_SpaceBelow, XFA_SCRIPT_Basic},
-    {0x7a7cc341, L"vAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_VAlign, XFA_SCRIPT_Basic},
-    {0x836d4d7c, L"tabDefault",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TabDefault, XFA_SCRIPT_Basic},
-    {0x8fa01790, L"tabStops",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TabStops, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd4b01921, L"lineHeight",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LineHeight, XFA_SCRIPT_Basic},
-    {0xe18b5659, L"spaceAbove",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_SpaceAbove, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd861f8af, L"addRevocationInfo",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AddRevocationInfo, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6128d8d, L"activity",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Activity, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x43e349b, L"dataRowCount",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataRowCount, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x28e17e91, L"dataPrep",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataPrep, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0x3650557e, L"textLocation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TextLocation, XFA_SCRIPT_Basic},
-    {0x3b582286, L"moduleWidth",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ModuleWidth, XFA_SCRIPT_Basic},
-    {0x52666f1c, L"printCheckDigit",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_PrintCheckDigit, XFA_SCRIPT_Basic},
-    {0x5404d6df, L"moduleHeight",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ModuleHeight, XFA_SCRIPT_Basic},
-    {0x5ab23b6c, L"startChar",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_StartChar, XFA_SCRIPT_Basic},
-    {0x7c732a66, L"truncate",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Truncate, XFA_SCRIPT_Basic},
-    {0x8d181d61, L"wideNarrowRatio",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_WideNarrowRatio, XFA_SCRIPT_Basic},
-    {0x99800d7a, L"errorCorrectionLevel",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ErrorCorrectionLevel, XFA_SCRIPT_Basic},
-    {0x9a63da3d, L"upsMode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_UpsMode, XFA_SCRIPT_Basic},
-    {0xaf754613, L"checksum",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Checksum, XFA_SCRIPT_Basic},
-    {0xb045fbc5, L"charEncoding",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CharEncoding, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc035c6b1, L"dataColumnCount",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataColumnCount, XFA_SCRIPT_Basic},
-    {0xd3c84d25, L"rowColumnRatio",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RowColumnRatio, XFA_SCRIPT_Basic},
-    {0xd57c513c, L"dataLength",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataLength, XFA_SCRIPT_Basic},
-    {0xf575ca75, L"endChar",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_EndChar, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0x28dee6e9, L"format",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Format, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x60d4c8b1, L"output",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Output, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6a39990, L"input",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Input, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x2b5df51e, L"dataDescription",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataDescription, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x6c0d9600, L"currentValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Delta_CurrentValue, -1,
-     XFA_SCRIPT_Basic},
-    {0x942643f0, L"savedValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Delta_SavedValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Delta_Target, -1,
-     XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd4cc53f8, L"highlight",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Highlight, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x5518c25, L"break",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Break, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd996fa9b, L"hand",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Hand, XFA_SCRIPT_Basic},
-    {0x78, L"x", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_X, XFA_SCRIPT_Basic},
-    {0x79, L"y", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Y, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1059ec18, L"level",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_Integer,
-     XFA_ATTRIBUTE_Level, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xac06e2b0, L"colSpan",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ColSpan, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x21aed, L"id",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Id, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f105f72, L"wordCharacterCount",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_WordCharacterCount, XFA_SCRIPT_Basic},
-    {0x3d123c26, L"hyphenate",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Hyphenate, XFA_SCRIPT_Basic},
-    {0x66539c48, L"excludeInitialCap",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ExcludeInitialCap, XFA_SCRIPT_Basic},
-    {0x6a95c976, L"pushCharacterCount",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_PushCharacterCount, XFA_SCRIPT_Basic},
-    {0x982bd892, L"remainCharacterCount",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RemainCharacterCount, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe5c96d6a, L"excludeAllCaps",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ExcludeAllCaps, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x8af2e657, L"maxChars",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxChars, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc080cd3, L"url",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Url, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa6710262, L"credentialServerPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CredentialServerPolicy, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc2ba0923, L"urlPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_UrlPolicy, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x47d03490, L"connection",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Connection, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Target, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x78bff531, L"numberOfCells",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_Integer,
-     XFA_ATTRIBUTE_NumberOfCells, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x68, L"h", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_H, XFA_SCRIPT_Basic},
-    {0x77, L"w", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_W, XFA_SCRIPT_Basic},
-    {0x78, L"x", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_X, XFA_SCRIPT_Basic},
-    {0x79, L"y", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Y, XFA_SCRIPT_Basic},
-    {0x2282c73, L"hAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HAlign, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1abbd7e0, L"dataNode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DataNode, -1,
-     XFA_SCRIPT_Object},
-    {0x25839852, L"access",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Access, XFA_SCRIPT_Basic},
-    {0x2ee7678f, L"rotate",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Rotate, XFA_SCRIPT_Basic},
-    {0x3b1ddd06, L"fillColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_FillColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x54c399e3, L"formattedValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Field_FormattedValue, -1,
-     XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x5a3b375d, L"borderColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_BorderColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x5e936ed6, L"fontColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_FontColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x6826c408, L"parentSubform",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Field_ParentSubform, -1,
-     XFA_SCRIPT_Basic},
-    {0x79b67434, L"mandatoryMessage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_MandatoryMessage, -1,
-     XFA_SCRIPT_Basic},
-    {0x7a7cc341, L"vAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_VAlign, XFA_SCRIPT_Basic},
-    {0x7c2ff6ae, L"maxH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxH, XFA_SCRIPT_Basic},
-    {0x7c2ff6bd, L"maxW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxW, XFA_SCRIPT_Basic},
-    {0x7d02356c, L"minH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinH, XFA_SCRIPT_Basic},
-    {0x7d02357b, L"minW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinW, XFA_SCRIPT_Basic},
-    {0x85fd6faf, L"mandatory",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_Mandatory, -1,
-     XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0x964fb42e, L"formatMessage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Field_FormatMessage, -1,
-     XFA_SCRIPT_Basic},
-    {0xa03cf627, L"rawValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xa60dd202, L"length",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Field_Length, -1,
-     XFA_SCRIPT_Basic},
-    {0xac06e2b0, L"colSpan",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ColSpan, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbc8fa350, L"locale",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Locale, XFA_SCRIPT_Basic},
-    {0xc2bd40fd, L"anchorType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AnchorType, XFA_SCRIPT_Basic},
-    {0xc4fed09b, L"accessKey",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AccessKey, XFA_SCRIPT_Basic},
-    {0xcabfa3d0, L"validationMessage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_ValidationMessage, -1,
-     XFA_SCRIPT_Basic},
-    {0xdcecd663, L"editValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Field_EditValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xe07e5061, L"selectedIndex",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Field_SelectedIndex, -1,
-     XFA_SCRIPT_Basic},
-    {0xf65e34be, L"borderWidth",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_BorderWidth, -1,
-     XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x68, L"h", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_H, XFA_SCRIPT_Basic},
-    {0x77, L"w", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_W, XFA_SCRIPT_Basic},
-    {0x78, L"x", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_X, XFA_SCRIPT_Basic},
-    {0x79, L"y", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Y, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd843798, L"fullText", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                 Script_EventPseudoModel_FullText,
-     -1, XFA_SCRIPT_Basic},
-    {0x1b6d1cf5, L"reenter", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                 Script_EventPseudoModel_Reenter,
-     -1, XFA_SCRIPT_Basic},
-    {0x1e6ffa9a, L"prevContentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_PrevContentType,
-     -1, XFA_SCRIPT_Basic},
-    {0x25a3c206, L"soapFaultString",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_SoapFaultString,
-     -1, XFA_SCRIPT_Basic},
-    {0x2e00c007, L"newContentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_NewContentType,
-     -1, XFA_SCRIPT_Basic},
-    {0x4570500f, L"modifier",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_Modifier,
-     -1, XFA_SCRIPT_Basic},
-    {0x50e2e33b, L"selEnd", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                Script_EventPseudoModel_SelEnd,
-     -1, XFA_SCRIPT_Basic},
-    {0x57de87c2, L"prevText",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_PrevText,
-     -1, XFA_SCRIPT_Basic},
-    {0x6ea04e0a, L"soapFaultCode",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_SoapFaultCode,
-     -1, XFA_SCRIPT_Basic},
-    {0x6f6556cf, L"newText", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                 Script_EventPseudoModel_NewText,
-     -1, XFA_SCRIPT_Basic},
-    {0x891f4606, L"change", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                Script_EventPseudoModel_Change,
-     -1, XFA_SCRIPT_Basic},
-    {0x8fa3c19e, L"shift", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                               Script_EventPseudoModel_Shift,
-     -1, XFA_SCRIPT_Basic},
-    {0xa9d9b2e1, L"keyDown", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                 Script_EventPseudoModel_KeyDown,
-     -1, XFA_SCRIPT_Basic},
-    {0xbfc89db2, L"selStart",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_SelStart,
-     -1, XFA_SCRIPT_Basic},
-    {0xc32a5812, L"commitKey",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-         Script_EventPseudoModel_CommitKey,
-     -1, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target", (XFA_ATTRIBUTE_CALLBACK)&CScript_EventPseudoModel::
-                                Script_EventPseudoModel_Target,
-     -1, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xa2e3514, L"cap",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Cap, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x5392ea58, L"stroke",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Stroke, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x94446dcc, L"thickness",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Thickness, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1ec8ab2c, L"rate",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Rate, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x7b29630a, L"sourceBelow",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_SourceBelow, XFA_SCRIPT_Basic},
-    {0x8fc36c0a, L"outputBelow",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_OutputBelow, XFA_SCRIPT_Basic},
-    {0xe996b2fe, L"sourceAbove",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_SourceAbove, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x68, L"h", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_H, XFA_SCRIPT_Basic},
-    {0x77, L"w", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_W, XFA_SCRIPT_Basic},
-    {0x78, L"x", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_X, XFA_SCRIPT_Basic},
-    {0x79, L"y", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Y, XFA_SCRIPT_Basic},
-    {0x2282c73, L"hAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HAlign, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xf23332f, L"errorText",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_ExclGroup_ErrorText, -1,
-     XFA_SCRIPT_Basic},
-    {0x1abbd7e0, L"dataNode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DataNode, -1,
-     XFA_SCRIPT_Object},
-    {0x25839852, L"access",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Access, XFA_SCRIPT_Basic},
-    {0x3b1ddd06, L"fillColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_FillColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x5a3b375d, L"borderColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_BorderColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x79b67434, L"mandatoryMessage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_MandatoryMessage, -1,
-     XFA_SCRIPT_Basic},
-    {0x7a7cc341, L"vAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_VAlign, XFA_SCRIPT_Basic},
-    {0x7c2ff6ae, L"maxH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxH, XFA_SCRIPT_Basic},
-    {0x7c2ff6bd, L"maxW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxW, XFA_SCRIPT_Basic},
-    {0x7d02356c, L"minH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinH, XFA_SCRIPT_Basic},
-    {0x7d02357b, L"minW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinW, XFA_SCRIPT_Basic},
-    {0x7e7e845e, L"layout",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Layout, XFA_SCRIPT_Basic},
-    {0x846599f8, L"transient",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_ExclGroup_Transient, -1,
-     XFA_SCRIPT_Basic},
-    {0x85fd6faf, L"mandatory",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_Mandatory, -1,
-     XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xa03cf627, L"rawValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_ExclGroup_DefaultAndRawValue,
-     -1, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_ExclGroup_DefaultAndRawValue,
-     -1, XFA_SCRIPT_Basic},
-    {0xac06e2b0, L"colSpan",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ColSpan, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc2bd40fd, L"anchorType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AnchorType, XFA_SCRIPT_Basic},
-    {0xc4fed09b, L"accessKey",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AccessKey, XFA_SCRIPT_Basic},
-    {0xcabfa3d0, L"validationMessage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_ValidationMessage, -1,
-     XFA_SCRIPT_Basic},
-    {0xf65e34be, L"borderWidth",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_BorderWidth, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xeda9017a, L"scope",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Scope, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x47d03490, L"connection",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Connection, XFA_SCRIPT_Basic},
-    {0x6cfa828a, L"runAt",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RunAt, XFA_SCRIPT_Basic},
-    {0xa1b0d2f5, L"executeType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ExecuteType, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe6f99487, L"hScrollPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HScrollPolicy, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x42fed1fd, L"contentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ContentType, XFA_SCRIPT_Basic},
-    {0x54fa722c, L"transferEncoding",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TransferEncoding, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue_Read, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd171b240, L"aspect",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Aspect, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue_Read, -1,
-     XFA_SCRIPT_Basic},
-    {0xdb55fec5, L"href",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Href, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Value, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0x7f6fd3d7, L"server",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Server, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x4b8bc840, L"fracDigits",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_FracDigits, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xde7f92ba, L"leadDigits",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LeadDigits, XFA_SCRIPT_Basic},
-    {0x68, L"h", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_H, XFA_SCRIPT_Basic},
-    {0x77, L"w", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_W, XFA_SCRIPT_Basic},
-    {0x78, L"x", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_X, XFA_SCRIPT_Basic},
-    {0x79, L"y", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Y, XFA_SCRIPT_Basic},
-    {0x2282c73, L"hAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HAlign, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1414d431, L"allowMacro",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AllowMacro, XFA_SCRIPT_Basic},
-    {0x1517dfa1, L"columnWidths",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ColumnWidths, XFA_SCRIPT_Basic},
-    {0x1abbd7e0, L"dataNode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DataNode, -1,
-     XFA_SCRIPT_Object},
-    {0x1ee2d24d, L"instanceIndex",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_InstanceIndex, -1,
-     XFA_SCRIPT_Basic},
-    {0x25839852, L"access",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Access, XFA_SCRIPT_Basic},
-    {0x3b1ddd06, L"fillColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_FillColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x5a3b375d, L"borderColor",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_BorderColor, -1,
-     XFA_SCRIPT_Basic},
-    {0x7a7cc341, L"vAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_VAlign, XFA_SCRIPT_Basic},
-    {0x7c2ff6ae, L"maxH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxH, XFA_SCRIPT_Basic},
-    {0x7c2ff6bd, L"maxW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxW, XFA_SCRIPT_Basic},
-    {0x7d02356c, L"minH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinH, XFA_SCRIPT_Basic},
-    {0x7d02357b, L"minW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinW, XFA_SCRIPT_Basic},
-    {0x7e7e845e, L"layout",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Layout, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0x9cc17d75, L"mergeMode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MergeMode, XFA_SCRIPT_Basic},
-    {0x9f3e9510, L"instanceManager",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Subform_InstanceManager, -1,
-     XFA_SCRIPT_Object},
-    {0xac06e2b0, L"colSpan",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ColSpan, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbc8fa350, L"locale",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Subform_Locale, -1,
-     XFA_SCRIPT_Basic},
-    {0xc2bd40fd, L"anchorType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AnchorType, XFA_SCRIPT_Basic},
-    {0xcabfa3d0, L"validationMessage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_ValidationMessage, -1,
-     XFA_SCRIPT_Basic},
-    {0xe4c3a5e5, L"restoreState",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RestoreState, XFA_SCRIPT_Basic},
-    {0xeda9017a, L"scope",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Scope, XFA_SCRIPT_Basic},
-    {0xf65e34be, L"borderWidth",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_BorderWidth, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0x5a50e9e6, L"version",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Handler_Version, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x4107ed, L"foxitAppType",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_FoxitAppType,
-     -1, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                             Script_HostPseudoModel_Name,
-     -1, XFA_SCRIPT_Basic},
-    {0x66c1ae9, L"validationsEnabled",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_ValidationsEnabled,
-     -1, XFA_SCRIPT_Basic},
-    {0x14d04502, L"title", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                               Script_HostPseudoModel_Title,
-     -1, XFA_SCRIPT_Basic},
-    {0x193afe8b, L"foxitName",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_FoxitName,
-     -1, XFA_SCRIPT_Basic},
-    {0x392ae445, L"platform", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_Platform,
-     -1, XFA_SCRIPT_Basic},
-    {0x5a50e9e6, L"version", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                                 Script_HostPseudoModel_Version,
-     -1, XFA_SCRIPT_Basic},
-    {0x66cb1eed, L"variation",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_Variation,
-     -1, XFA_SCRIPT_Basic},
-    {0x7717cbc4, L"language", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_Language,
-     -1, XFA_SCRIPT_Basic},
-    {0x86698963, L"appType", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                                 Script_HostPseudoModel_AppType,
-     -1, XFA_SCRIPT_Basic},
-    {0x94ff9e8d, L"calculationsEnabled",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_CalculationsEnabled,
-     -1, XFA_SCRIPT_Basic},
-    {0xbcd44940, L"currentPage",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_CurrentPage,
-     -1, XFA_SCRIPT_Basic},
-    {0xd4286870, L"foxitVersion",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-         Script_HostPseudoModel_FoxitVersion,
-     -1, XFA_SCRIPT_Basic},
-    {0xd592b920, L"numPages", (XFA_ATTRIBUTE_CALLBACK)&CScript_HostPseudoModel::
-                                  Script_HostPseudoModel_NumPages,
-     -1, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x24d85167, L"timeout",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Timeout, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x7d9fd7c5, L"mode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Mode, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x7d9fd7c5, L"mode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_SubmitFormat_Mode, -1,
-     XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2038c9b2, L"role",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Role, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xfcef86b5, L"ready", (XFA_ATTRIBUTE_CALLBACK)&CScript_LayoutPseudoModel::
-                               Script_LayoutPseudoModel_Ready,
-     -1, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x5392ea58, L"stroke",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Stroke, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x7b95e661, L"inverted",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Inverted, XFA_SCRIPT_Basic},
-    {0x94446dcc, L"thickness",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Thickness, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe8dddf50, L"join",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Join, XFA_SCRIPT_Basic},
-    {0xe948b9a8, L"radius",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Radius, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xabfa6c4f, L"cSpace",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CSpace, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Value, XFA_SCRIPT_Basic},
-    {0x3848b3f, L"next",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Next, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x6a3405dd, L"previous",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Previous, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xf6b59543, L"intact",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Intact, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x268b7ec1, L"commandType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CommandType, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbde9abda, L"data",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Data, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x5b707a35, L"scriptTest",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ScriptTest, XFA_SCRIPT_Basic},
-    {0x6b6ddcfb, L"nullTest",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_NullTest, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xe64b1129, L"formatTest",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_FormatTest, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x8c99377e, L"relation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relation, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x25363, L"to",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_To, XFA_SCRIPT_Basic},
-    {0x66642f8f, L"force",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Force, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xcd7f7b54, L"from",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_From, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Value, XFA_SCRIPT_Basic},
-    {0x2b5df51e, L"dataDescription",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataDescription, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x226ca8f1, L"operation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Operation, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xfb67185, L"recordsBefore", (XFA_ATTRIBUTE_CALLBACK)&CScript_DataWindow::
-                                      Script_DataWindow_RecordsBefore,
-     -1, XFA_SCRIPT_Basic},
-    {0x21d5dfcb, L"currentRecordNumber",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_DataWindow::
-         Script_DataWindow_CurrentRecordNumber,
-     -1, XFA_SCRIPT_Basic},
-    {0x312af044, L"recordsAfter", (XFA_ATTRIBUTE_CALLBACK)&CScript_DataWindow::
-                                      Script_DataWindow_RecordsAfter,
-     -1, XFA_SCRIPT_Basic},
-    {0x6aab37cb, L"isDefined",
-     (XFA_ATTRIBUTE_CALLBACK)&CScript_DataWindow::Script_DataWindow_IsDefined,
-     -1, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x42fed1fd, L"contentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ContentType, XFA_SCRIPT_Basic},
-    {0x6cfa828a, L"runAt",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_RunAt, XFA_SCRIPT_Basic},
-    {0xa021b738, L"stateless",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Script_Stateless, -1,
-     XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xadc4c77b, L"binding",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Binding, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x7a0cc471, L"passwordChar",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_PasswordChar, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe6f99487, L"hScrollPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HScrollPolicy, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe6f99487, L"hScrollPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HScrollPolicy, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x14a32d52, L"pagePosition",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_PagePosition, XFA_SCRIPT_Basic},
-    {0x8340ea66, L"oddOrEven",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_OddOrEven, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xa85e74f3, L"initialNumber",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_InitialNumber, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe9ba472, L"numbered",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Numbered, XFA_SCRIPT_Basic},
-    {0xd70798c2, L"blankOrNotBlank",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BlankOrNotBlank, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x34ae103c, L"reserve",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Reserve, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xf2009339, L"placement",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Placement, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x42fed1fd, L"contentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ContentType, XFA_SCRIPT_Basic},
-    {0x54fa722c, L"transferEncoding",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TransferEncoding, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc4547a08, L"maxLength",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxLength, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xdb55fec5, L"href",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Href, XFA_SCRIPT_Basic},
-    {0x29418bb7, L"abbr",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Abbr, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf531b059, L"writingScript",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_WritingScript, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1b8dce3e, L"action",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Action, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x9dcc3ab3, L"trailer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Trailer, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Target, XFA_SCRIPT_Basic},
-    {0xcbcaf66d, L"leader",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Leader, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xb3543a6, L"max",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_InstanceManager_Max, -1,
-     XFA_SCRIPT_Basic},
-    {0xb356ca4, L"min",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_InstanceManager_Min, -1,
-     XFA_SCRIPT_Basic},
-    {0x6f544d49, L"count",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_InstanceManager_Count, -1,
-     XFA_SCRIPT_Basic},
-    {0x25363, L"to",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_To, XFA_SCRIPT_Basic},
-    {0xa0933954, L"unicodeRange",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_UnicodeRange, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xcd7f7b54, L"from",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_From, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x4ef3d02c, L"orientation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Orientation, XFA_SCRIPT_Basic},
-    {0x65e30c67, L"imagingBBox",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ImagingBBox, XFA_SCRIPT_Basic},
-    {0x9041d4b0, L"short",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Short, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe349d044, L"stock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Stock, XFA_SCRIPT_Basic},
-    {0xf6b4afb0, L"long",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Long, XFA_SCRIPT_Basic},
-    {0x5ce6195, L"vScrollPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_VScrollPolicy, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x1ef3a64a, L"allowRichText",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AllowRichText, XFA_SCRIPT_Basic},
-    {0x5a32e493, L"multiLine",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MultiLine, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe6f99487, L"hScrollPolicy",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HScrollPolicy, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xd52482e0, L"maxEntries",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxEntries, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x42fed1fd, L"contentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ContentType, XFA_SCRIPT_Basic},
-    {0x8855805f, L"contains",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Contains, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xe372ae97, L"isNull",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_IsNull, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x2b5df51e, L"dataDescription",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DataDescription, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x226ca8f1, L"operation",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Operation, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Target, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x42fed1fd, L"contentType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ContentType, XFA_SCRIPT_Basic},
-    {0x54fa722c, L"transferEncoding",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TransferEncoding, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xf197844d, L"match",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Match, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd996fa9b, L"hand",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Hand, XFA_SCRIPT_Basic},
-    {0x21aed, L"id",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Id, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x28dee6e9, L"format",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Encrypt_Format, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x68, L"h", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_H, XFA_SCRIPT_Basic},
-    {0x77, L"w", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_W, XFA_SCRIPT_Basic},
-    {0x78, L"x", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_X, XFA_SCRIPT_Basic},
-    {0x79, L"y", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Y, XFA_SCRIPT_Basic},
-    {0x2282c73, L"hAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_HAlign, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2ee7678f, L"rotate",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Rotate, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0x7a7cc341, L"vAlign",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_VAlign, XFA_SCRIPT_Basic},
-    {0x7c2ff6ae, L"maxH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxH, XFA_SCRIPT_Basic},
-    {0x7c2ff6bd, L"maxW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MaxW, XFA_SCRIPT_Basic},
-    {0x7d02356c, L"minH",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinH, XFA_SCRIPT_Basic},
-    {0x7d02357b, L"minW",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_MinW, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xa03cf627, L"rawValue",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xac06e2b0, L"colSpan",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ColSpan, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbc8fa350, L"locale",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Locale, XFA_SCRIPT_Basic},
-    {0xc2bd40fd, L"anchorType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_AnchorType, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x39cdb0a2, L"priority",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Priority, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xeb511b54, L"disable",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Disable, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Value, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x21aed, L"id",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Id, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xcb0ac9, L"lineThrough",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LineThrough, XFA_SCRIPT_Basic},
-    {0x2c1c7f1, L"typeface",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Typeface, XFA_SCRIPT_Basic},
-    {0x8c74ae9, L"fontHorizontalScale",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_FontHorizontalScale, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2cd79033, L"kerningMode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_KerningMode, XFA_SCRIPT_Basic},
-    {0x3a0273a6, L"underline",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Underline, XFA_SCRIPT_Basic},
-    {0x4873c601, L"baselineShift",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_BaselineShift, XFA_SCRIPT_Basic},
-    {0x4b319767, L"overlinePeriod",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_OverlinePeriod, XFA_SCRIPT_Basic},
-    {0x79543055, L"letterSpacing",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LetterSpacing, XFA_SCRIPT_Basic},
-    {0x8ec6204c, L"lineThroughPeriod",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LineThroughPeriod, XFA_SCRIPT_Basic},
-    {0x907c7719, L"fontVerticalScale",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_FontVerticalScale, XFA_SCRIPT_Basic},
-    {0xa686975b, L"size",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Size, XFA_SCRIPT_Basic},
-    {0xb5e49bf2, L"posture",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Posture, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbd6e1d88, L"weight",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Weight, XFA_SCRIPT_Basic},
-    {0xbd96a0e9, L"underlinePeriod",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_UnderlinePeriod, XFA_SCRIPT_Basic},
-    {0xc0ec9fa4, L"overline",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Overline, XFA_SCRIPT_Basic},
-    {0xaf754613, L"checksum",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Form_Checksum, -1,
-     XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x8e1c2921, L"relevant",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Relevant, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xea7090a0, L"override",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Override, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x9dcc3ab3, L"trailer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Trailer, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xcbcaf66d, L"leader",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Leader, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x60a61edd, L"codeType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CodeType, XFA_SCRIPT_Basic},
-    {0xb373a862, L"archive",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Archive, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xe1a26b56, L"codeBase",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_CodeBase, XFA_SCRIPT_Basic},
-    {0xeb091003, L"classId",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ClassId, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x47d03490, L"connection",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Connection, XFA_SCRIPT_Basic},
-    {0xc39a88bd, L"labelRef",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_LabelRef, XFA_SCRIPT_Basic},
-    {0xd50f903a, L"valueRef",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_ValueRef, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xea7090a0, L"override",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Override, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Extras_Type, -1,
-     XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x24d85167, L"timeout",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Timeout, XFA_SCRIPT_Basic},
-    {0x47d03490, L"connection",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Connection, XFA_SCRIPT_Basic},
-    {0x552d9ad5, L"usage",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usage, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc860f30a, L"delayedOpen",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_DelayedOpen, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x28dee6e9, L"format",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Format, XFA_SCRIPT_Basic},
-    {0x824f21b7, L"embedPDF",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_EmbedPDF, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Target, XFA_SCRIPT_Basic},
-    {0xdc75676c, L"textEncoding",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TextEncoding, XFA_SCRIPT_Basic},
-    {0xf889e747, L"xdpContent",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_XdpContent, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x97be91b, L"content",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Packet_Content, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x4156ee3f, L"delimiter",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Delimiter, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0x21aed, L"id",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Id, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x21aed, L"id",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Id, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x2f16a382, L"type",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Type, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x453eaf38, L"startNew",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_StartNew, XFA_SCRIPT_Basic},
-    {0x9dcc3ab3, L"trailer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Trailer, XFA_SCRIPT_Basic},
-    {0xa6118c89, L"targetType",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_TargetType, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xc8da4da7, L"target",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Target, XFA_SCRIPT_Basic},
-    {0xcbcaf66d, L"leader",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Leader, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xabef37e3, L"slope",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Slope, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xd996fa9b, L"hand",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Hand, XFA_SCRIPT_Basic},
-    {0xa60dd202, L"length",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_NodeList::Script_ListClass_Length, -1,
-     XFA_SCRIPT_Basic},
-    {0x20146, L"db", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Source_Db, -1,
-     XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xb3543a6, L"max", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Occur_Max,
-     -1, XFA_SCRIPT_Basic},
-    {0xb356ca4, L"min", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Occur_Min,
-     -1, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x7d0b5fca, L"initial",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Initial, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x29418bb7, L"abbr",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Abbr, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0xbe52dfbf, L"desc",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Desc, XFA_SCRIPT_Basic},
-    {0xf6b47749, L"lock",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_BOOL,
-     XFA_ATTRIBUTE_Lock, XFA_SCRIPT_Basic},
-    {0xbb8df5d, L"ref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Ref, XFA_SCRIPT_Basic},
-    {0xc0811ed, L"use",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Use, XFA_SCRIPT_Basic},
-    {0x570ce835, L"presence",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Presence, XFA_SCRIPT_Basic},
-    {0xa5b410cf, L"save",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Save, XFA_SCRIPT_Basic},
-    {0xbc254332, L"usehref",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Usehref, XFA_SCRIPT_Basic},
-    {0xb2c80857, L"className",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Object::Script_ObjectClass_ClassName, -1,
-     XFA_SCRIPT_Basic},
-    {0xa60dd202, L"length",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_NodeList::Script_ListClass_Length, -1,
-     XFA_SCRIPT_Basic},
-    {0x31b19c1, L"name",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Name, XFA_SCRIPT_Basic},
-    {0x9f9d0f9, L"all",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_All, -1,
-     XFA_SCRIPT_Object},
-    {0x4df15659, L"nodes",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_Nodes, -1,
-     XFA_SCRIPT_Object},
-    {0x78a8d6cf, L"classAll",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_ClassAll, -1,
-     XFA_SCRIPT_Object},
-    {0xcad6d8ca, L"parent",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_Parent, -1,
-     XFA_SCRIPT_Object},
-    {0xd5679c78, L"index",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_Index, -1,
-     XFA_SCRIPT_Basic},
-    {0xdb5b4bce, L"classIndex",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_ClassIndex, -1,
-     XFA_SCRIPT_Basic},
-    {0xe4989adf, L"somExpression",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_TreeClass_SomExpression, -1,
-     XFA_SCRIPT_Basic},
-    {0x21aed, L"id",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Attribute_String,
-     XFA_ATTRIBUTE_Id, XFA_SCRIPT_Basic},
-    {0x234a1, L"ns", (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_NodeClass_Ns,
-     -1, XFA_SCRIPT_Basic},
-    {0x50d1a9d1, L"model",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_NodeClass_Model, -1,
-     XFA_SCRIPT_Object},
-    {0xacb4823f, L"isContainer",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_NodeClass_IsContainer, -1,
-     XFA_SCRIPT_Basic},
-    {0xe372ae97, L"isNull",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_NodeClass_IsNull, -1,
-     XFA_SCRIPT_Basic},
-    {0xfe612a5b, L"oneOfChild",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_NodeClass_OneOfChild, -1,
-     XFA_SCRIPT_Object},
-    {0x97c1c65, L"context",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_ModelClass_Context, -1,
-     XFA_SCRIPT_Object},
-    {0x58be2870, L"aliasNode",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_ModelClass_AliasNode, -1,
-     XFA_SCRIPT_Object},
-    {0xa52682bd, L"{default}",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-    {0xd6e27f1d, L"value",
-     (XFA_ATTRIBUTE_CALLBACK)&CXFA_Node::Script_Som_DefaultValue, -1,
-     XFA_SCRIPT_Basic},
-};
-const int32_t g_iSomAttributeCount =
-    sizeof(g_SomAttributeData) / sizeof(XFA_ATTRIBUTEINFO);
diff --git a/xfa/src/fxfa/parser/xfa_basic_data.h b/xfa/src/fxfa/parser/xfa_basic_data.h
deleted file mode 100644
index 4ccdd1c7c8..0000000000
--- a/xfa/src/fxfa/parser/xfa_basic_data.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2016 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_BASIC_DATA_H_
-#define XFA_SRC_FXFA_PARSER_XFA_BASIC_DATA_H_
-
-#include "xfa/include/fxfa/fxfa_basic.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-
-extern const XFA_PACKETINFO g_XFAPacketData[];
-extern const int32_t g_iXFAPacketCount;
-
-extern const XFA_ATTRIBUTEENUMINFO g_XFAEnumData[];
-extern const int32_t g_iXFAEnumCount;
-
-extern const XFA_ATTRIBUTEINFO g_XFAAttributeData[];
-extern const int32_t g_iXFAAttributeCount;
-
-extern const XFA_NOTSUREATTRIBUTE g_XFANotsureAttributes[];
-extern const int32_t g_iXFANotsureCount;
-
-extern const XFA_ELEMENTINFO g_XFAElementData[];
-extern const int32_t g_iXFAElementCount;
-
-extern const XFA_ELEMENTHIERARCHY g_XFAElementChildrenIndex[];
-extern const FX_WORD g_XFAElementChildrenData[];
-
-extern const XFA_ELEMENTHIERARCHY g_XFAElementAttributeIndex[];
-extern const uint8_t g_XFAElementAttributeData[];
-
-extern const XFA_ELEMENTHIERARCHY g_XFAElementPropertyIndex[];
-extern const XFA_PROPERTY g_XFAElementPropertyData[];
-
-extern const XFA_SCRIPTHIERARCHY g_XFAScriptIndex[];
-
-extern const XFA_NOTSUREATTRIBUTE g_XFANotsureAttributes[];
-extern const int32_t g_iXFANotsureCount;
-
-extern const XFA_METHODINFO g_SomMethodData[];
-extern const int32_t g_iSomMethodCount;
-
-extern const XFA_SCRIPTATTRIBUTEINFO g_SomAttributeData[];
-extern const int32_t g_iSomAttributeCount;
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_BASIC_DATA_H_
diff --git a/xfa/src/fxfa/parser/xfa_basic_imp.cpp b/xfa/src/fxfa/parser/xfa_basic_imp.cpp
deleted file mode 100644
index a0aa56d8be..0000000000
--- a/xfa/src/fxfa/parser/xfa_basic_imp.cpp
+++ /dev/null
@@ -1,612 +0,0 @@
-// 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/src/fxfa/parser/xfa_basic_imp.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fgas/crt/fgas_algorithm.h"
-#include "xfa/src/fgas/crt/fgas_codepage.h"
-#include "xfa/src/fgas/crt/fgas_system.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_data.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-const XFA_PACKETINFO* XFA_GetPacketByName(const CFX_WideStringC& wsName) {
-  int32_t iLength = wsName.GetLength();
-  if (iLength == 0) {
-    return NULL;
-  }
-  uint32_t uHash = FX_HashCode_String_GetW(wsName.GetPtr(), iLength);
-  int32_t iStart = 0, iEnd = g_iXFAPacketCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_PACKETINFO* pInfo = g_XFAPacketData + iMid;
-    if (uHash == pInfo->uHash) {
-      return pInfo;
-    } else if (uHash < pInfo->uHash) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-
-const XFA_PACKETINFO* XFA_GetPacketByID(FX_DWORD dwPacket) {
-  int32_t iStart = 0, iEnd = g_iXFAPacketCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    FX_DWORD dwFind = (g_XFAPacketData + iMid)->eName;
-    if (dwPacket == dwFind) {
-      return g_XFAPacketData + iMid;
-    } else if (dwPacket < dwFind) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-
-const XFA_PACKETINFO* XFA_GetPacketByIndex(XFA_PACKET ePacket) {
-  return g_XFAPacketData + ePacket;
-}
-
-const XFA_ATTRIBUTEENUMINFO* XFA_GetAttributeEnumByName(
-    const CFX_WideStringC& wsName) {
-  int32_t iLength = wsName.GetLength();
-  if (iLength == 0) {
-    return NULL;
-  }
-  uint32_t uHash = FX_HashCode_String_GetW(wsName.GetPtr(), iLength);
-  int32_t iStart = 0, iEnd = g_iXFAEnumCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_ATTRIBUTEENUMINFO* pInfo = g_XFAEnumData + iMid;
-    if (uHash == pInfo->uHash) {
-      return pInfo;
-    } else if (uHash < pInfo->uHash) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-const XFA_ATTRIBUTEENUMINFO* XFA_GetAttributeEnumByID(XFA_ATTRIBUTEENUM eName) {
-  return g_XFAEnumData + eName;
-}
-int32_t XFA_GetAttributeCount() {
-  return g_iXFAAttributeCount;
-}
-const XFA_ATTRIBUTEINFO* XFA_GetAttributeByName(const CFX_WideStringC& wsName) {
-  int32_t iLength = wsName.GetLength();
-  if (iLength == 0) {
-    return NULL;
-  }
-  uint32_t uHash = FX_HashCode_String_GetW(wsName.GetPtr(), iLength);
-  int32_t iStart = 0, iEnd = g_iXFAAttributeCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_ATTRIBUTEINFO* pInfo = g_XFAAttributeData + iMid;
-    if (uHash == pInfo->uHash) {
-      return pInfo;
-    } else if (uHash < pInfo->uHash) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-const XFA_ATTRIBUTEINFO* XFA_GetAttributeByID(XFA_ATTRIBUTE eName) {
-  return (eName < g_iXFAAttributeCount) ? (g_XFAAttributeData + eName) : NULL;
-}
-FX_BOOL XFA_GetAttributeDefaultValue(void*& pValue,
-                                     XFA_ELEMENT eElement,
-                                     XFA_ATTRIBUTE eAttribute,
-                                     XFA_ATTRIBUTETYPE eType,
-                                     FX_DWORD dwPacket) {
-  const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
-  if (pInfo == NULL) {
-    return FALSE;
-  }
-  if (dwPacket && (dwPacket & pInfo->dwPackets) == 0) {
-    return FALSE;
-  }
-  if (pInfo->eType == eType) {
-    pValue = pInfo->pDefValue;
-    return TRUE;
-  } else if (pInfo->eType == XFA_ATTRIBUTETYPE_NOTSURE) {
-    const XFA_NOTSUREATTRIBUTE* pAttr =
-        XFA_GetNotsureAttribute(eElement, eAttribute, eType);
-    if (pAttr) {
-      pValue = pAttr->pValue;
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-XFA_ATTRIBUTEENUM XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT eElement,
-                                                    XFA_ATTRIBUTE eAttribute,
-                                                    FX_DWORD dwPacket) {
-  void* pValue;
-  if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
-                                   XFA_ATTRIBUTETYPE_Enum, dwPacket)) {
-    return (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
-  }
-  return XFA_ATTRIBUTEENUM_Unknown;
-}
-CFX_WideStringC XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT eElement,
-                                                   XFA_ATTRIBUTE eAttribute,
-                                                   FX_DWORD dwPacket) {
-  void* pValue;
-  if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
-                                   XFA_ATTRIBUTETYPE_Cdata, dwPacket)) {
-    return (const FX_WCHAR*)pValue;
-  }
-  return NULL;
-}
-FX_BOOL XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT eElement,
-                                             XFA_ATTRIBUTE eAttribute,
-                                             FX_DWORD dwPacket) {
-  void* pValue;
-  if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
-                                   XFA_ATTRIBUTETYPE_Boolean, dwPacket)) {
-    return (FX_BOOL)(uintptr_t)pValue;
-  }
-  return FALSE;
-}
-int32_t XFA_GetAttributeDefaultValue_Integer(XFA_ELEMENT eElement,
-                                             XFA_ATTRIBUTE eAttribute,
-                                             FX_DWORD dwPacket) {
-  void* pValue;
-  if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
-                                   XFA_ATTRIBUTETYPE_Integer, dwPacket)) {
-    return (int32_t)(uintptr_t)pValue;
-  }
-  return 0;
-}
-CXFA_Measurement XFA_GetAttributeDefaultValue_Measure(XFA_ELEMENT eElement,
-                                                      XFA_ATTRIBUTE eAttribute,
-                                                      FX_DWORD dwPacket) {
-  void* pValue;
-  if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
-                                   XFA_ATTRIBUTETYPE_Measure, dwPacket)) {
-    return *(CXFA_Measurement*)pValue;
-  }
-  return CXFA_Measurement();
-}
-int32_t XFA_GetElementCount() {
-  return g_iXFAElementCount;
-}
-const XFA_ELEMENTINFO* XFA_GetElementByName(const CFX_WideStringC& wsName) {
-  int32_t iLength = wsName.GetLength();
-  if (iLength == 0) {
-    return NULL;
-  }
-  uint32_t uHash = FX_HashCode_String_GetW(wsName.GetPtr(), iLength);
-  int32_t iStart = 0, iEnd = g_iXFAElementCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_ELEMENTINFO* pInfo = g_XFAElementData + iMid;
-    if (uHash == pInfo->uHash) {
-      return pInfo;
-    } else if (uHash < pInfo->uHash) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-const XFA_ELEMENTINFO* XFA_GetElementByID(XFA_ELEMENT eName) {
-  return (eName < g_iXFAElementCount) ? (g_XFAElementData + eName) : NULL;
-}
-const FX_WORD* XFA_GetElementChildren(XFA_ELEMENT eElement, int32_t& iCount) {
-  if (eElement >= g_iXFAElementCount) {
-    return NULL;
-  }
-  const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementChildrenIndex + eElement;
-  iCount = pElement->wCount;
-  return g_XFAElementChildrenData + pElement->wStart;
-}
-const uint8_t* XFA_GetElementAttributes(XFA_ELEMENT eElement, int32_t& iCount) {
-  if (eElement >= g_iXFAElementCount) {
-    return NULL;
-  }
-  const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementAttributeIndex + eElement;
-  iCount = pElement->wCount;
-  return g_XFAElementAttributeData + pElement->wStart;
-}
-const XFA_ATTRIBUTEINFO* XFA_GetAttributeOfElement(XFA_ELEMENT eElement,
-                                                   XFA_ATTRIBUTE eAttribute,
-                                                   FX_DWORD dwPacket) {
-  int32_t iCount = 0;
-  const uint8_t* pAttr = XFA_GetElementAttributes(eElement, iCount);
-  if (pAttr == NULL || iCount < 1) {
-    return NULL;
-  }
-  CFX_DSPATemplate<uint8_t> search;
-  int32_t index = search.Lookup(eAttribute, pAttr, iCount);
-  if (index < 0) {
-    return NULL;
-  }
-  const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
-  ASSERT(pInfo);
-  if (dwPacket == XFA_XDPPACKET_UNKNOWN)
-    return pInfo;
-  return (dwPacket & pInfo->dwPackets) ? pInfo : NULL;
-}
-const XFA_ELEMENTINFO* XFA_GetChildOfElement(XFA_ELEMENT eElement,
-                                             XFA_ELEMENT eChild,
-                                             FX_DWORD dwPacket) {
-  int32_t iCount = 0;
-  const FX_WORD* pChild = XFA_GetElementChildren(eElement, iCount);
-  if (pChild == NULL || iCount < 1) {
-    return NULL;
-  }
-  CFX_DSPATemplate<FX_WORD> search;
-  int32_t index = search.Lookup(eChild, pChild, iCount);
-  if (index < 0) {
-    return NULL;
-  }
-  const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eChild);
-  ASSERT(pInfo);
-  if (dwPacket == XFA_XDPPACKET_UNKNOWN)
-    return pInfo;
-  return (dwPacket & pInfo->dwPackets) ? pInfo : NULL;
-}
-const XFA_PROPERTY* XFA_GetElementProperties(XFA_ELEMENT eElement,
-                                             int32_t& iCount) {
-  if (eElement >= g_iXFAElementCount) {
-    return NULL;
-  }
-  const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementPropertyIndex + eElement;
-  iCount = pElement->wCount;
-  return g_XFAElementPropertyData + pElement->wStart;
-}
-const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_ELEMENT eElement,
-                                             XFA_ELEMENT eProperty,
-                                             FX_DWORD dwPacket) {
-  int32_t iCount = 0;
-  const XFA_PROPERTY* pProperty = XFA_GetElementProperties(eElement, iCount);
-  if (pProperty == NULL || iCount < 1) {
-    return NULL;
-  }
-  int32_t iStart = 0, iEnd = iCount - 1, iMid;
-  do {
-    iMid = (iStart + iEnd) / 2;
-    XFA_ELEMENT eName = (XFA_ELEMENT)pProperty[iMid].eName;
-    if (eProperty == eName) {
-      break;
-    } else if (eProperty < eName) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  if (iStart > iEnd) {
-    return NULL;
-  }
-  const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eProperty);
-  ASSERT(pInfo);
-  if (dwPacket == XFA_XDPPACKET_UNKNOWN)
-    return pProperty + iMid;
-  return (dwPacket & pInfo->dwPackets) ? (pProperty + iMid) : NULL;
-}
-const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(XFA_ELEMENT eElement,
-                                                    XFA_ATTRIBUTE eAttribute,
-                                                    XFA_ATTRIBUTETYPE eType) {
-  int32_t iStart = 0, iEnd = g_iXFANotsureCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_NOTSUREATTRIBUTE* pAttr = g_XFANotsureAttributes + iMid;
-    if (eElement == pAttr->eElement) {
-      if (pAttr->eAttribute == eAttribute) {
-        if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
-          return pAttr;
-        }
-        return NULL;
-      } else {
-        int32_t iBefore = iMid - 1;
-        if (iBefore >= 0) {
-          pAttr = g_XFANotsureAttributes + iBefore;
-          while (eElement == pAttr->eElement) {
-            if (pAttr->eAttribute == eAttribute) {
-              if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
-                return pAttr;
-              }
-              return NULL;
-            }
-            iBefore--;
-            if (iBefore < 0) {
-              break;
-            }
-            pAttr = g_XFANotsureAttributes + iBefore;
-          }
-        }
-        int32_t iAfter = iMid + 1;
-        if (iAfter <= g_iXFANotsureCount - 1) {
-          pAttr = g_XFANotsureAttributes + iAfter;
-          while (eElement == pAttr->eElement) {
-            if (pAttr->eAttribute == eAttribute) {
-              if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
-                return pAttr;
-              }
-              return NULL;
-            }
-            iAfter++;
-            if (iAfter > g_iXFANotsureCount - 1) {
-              break;
-            }
-            pAttr = g_XFANotsureAttributes + iAfter;
-          }
-        }
-        return NULL;
-      }
-    } else if (eElement < pAttr->eElement) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-int32_t XFA_GetMethodCount() {
-  return g_iSomMethodCount;
-}
-const XFA_METHODINFO* XFA_GetMethodByName(XFA_ELEMENT eElement,
-                                          const CFX_WideStringC& wsMethodName) {
-  int32_t iLength = wsMethodName.GetLength();
-  if (iLength == 0) {
-    return NULL;
-  }
-  int32_t iElementIndex = eElement;
-  while (iElementIndex != -1) {
-    XFA_LPCSCRIPTHIERARCHY scriptIndex = g_XFAScriptIndex + iElementIndex;
-    int32_t icount = scriptIndex->wMethodCount;
-    if (icount == 0) {
-      iElementIndex = scriptIndex->wParentIndex;
-      continue;
-    }
-    uint32_t uHash = FX_HashCode_String_GetW(wsMethodName.GetPtr(), iLength);
-    int32_t iStart = scriptIndex->wMethodStart, iEnd = iStart + icount - 1;
-    do {
-      int32_t iMid = (iStart + iEnd) / 2;
-      const XFA_METHODINFO* pInfo = g_SomMethodData + iMid;
-      if (uHash == pInfo->uHash) {
-        return pInfo;
-      } else if (uHash < pInfo->uHash) {
-        iEnd = iMid - 1;
-      } else {
-        iStart = iMid + 1;
-      }
-    } while (iStart <= iEnd);
-    iElementIndex = scriptIndex->wParentIndex;
-  }
-  return NULL;
-}
-const XFA_SCRIPTATTRIBUTEINFO* XFA_GetScriptAttributeByName(
-    XFA_ELEMENT eElement,
-    const CFX_WideStringC& wsAttributeName) {
-  int32_t iLength = wsAttributeName.GetLength();
-  if (iLength == 0) {
-    return NULL;
-  }
-  int32_t iElementIndex = eElement;
-  while (iElementIndex != -1) {
-    XFA_LPCSCRIPTHIERARCHY scriptIndex = g_XFAScriptIndex + iElementIndex;
-    int32_t icount = scriptIndex->wAttributeCount;
-    if (icount == 0) {
-      iElementIndex = scriptIndex->wParentIndex;
-      continue;
-    }
-    uint32_t uHash = FX_HashCode_String_GetW(wsAttributeName.GetPtr(), iLength);
-    int32_t iStart = scriptIndex->wAttributeStart, iEnd = iStart + icount - 1;
-    do {
-      int32_t iMid = (iStart + iEnd) / 2;
-      const XFA_SCRIPTATTRIBUTEINFO* pInfo = g_SomAttributeData + iMid;
-      if (uHash == pInfo->uHash) {
-        return pInfo;
-      } else if (uHash < pInfo->uHash) {
-        iEnd = iMid - 1;
-      } else {
-        iStart = iMid + 1;
-      }
-    } while (iStart <= iEnd);
-    iElementIndex = scriptIndex->wParentIndex;
-  }
-  return NULL;
-}
-void CXFA_Measurement::Set(const CFX_WideStringC& wsMeasure) {
-  if (wsMeasure.IsEmpty()) {
-    m_fValue = 0;
-    m_eUnit = XFA_UNIT_Unknown;
-    return;
-  }
-  int32_t iUsedLen = 0;
-  int32_t iOffset = (wsMeasure.GetAt(0) == L'=') ? 1 : 0;
-  FX_FLOAT fValue = FX_wcstof(wsMeasure.GetPtr() + iOffset,
-                              wsMeasure.GetLength() - iOffset, &iUsedLen);
-  XFA_UNIT eUnit = GetUnit(wsMeasure.Mid(iOffset + iUsedLen));
-  Set(fValue, eUnit);
-}
-FX_BOOL CXFA_Measurement::ToString(CFX_WideString& wsMeasure) const {
-  switch (GetUnit()) {
-    case XFA_UNIT_Mm:
-      wsMeasure.Format(L"%.8gmm", GetValue());
-      return TRUE;
-    case XFA_UNIT_Pt:
-      wsMeasure.Format(L"%.8gpt", GetValue());
-      return TRUE;
-    case XFA_UNIT_In:
-      wsMeasure.Format(L"%.8gin", GetValue());
-      return TRUE;
-    case XFA_UNIT_Cm:
-      wsMeasure.Format(L"%.8gcm", GetValue());
-      return TRUE;
-    case XFA_UNIT_Mp:
-      wsMeasure.Format(L"%.8gmp", GetValue());
-      return TRUE;
-    case XFA_UNIT_Pc:
-      wsMeasure.Format(L"%.8gpc", GetValue());
-      return TRUE;
-    case XFA_UNIT_Em:
-      wsMeasure.Format(L"%.8gem", GetValue());
-      return TRUE;
-    case XFA_UNIT_Percent:
-      wsMeasure.Format(L"%.8g%%", GetValue());
-      return TRUE;
-    default:
-      wsMeasure.Format(L"%.8g", GetValue());
-      return FALSE;
-  }
-}
-FX_BOOL CXFA_Measurement::ToUnit(XFA_UNIT eUnit, FX_FLOAT& fValue) const {
-  fValue = GetValue();
-  XFA_UNIT eFrom = GetUnit();
-  if (eFrom == eUnit) {
-    return TRUE;
-  }
-  switch (eFrom) {
-    case XFA_UNIT_Pt:
-      break;
-    case XFA_UNIT_Mm:
-      fValue *= 72 / 2.54f / 10;
-      break;
-    case XFA_UNIT_In:
-      fValue *= 72;
-      break;
-    case XFA_UNIT_Cm:
-      fValue *= 72 / 2.54f;
-      break;
-    case XFA_UNIT_Mp:
-      fValue *= 0.001f;
-      break;
-    case XFA_UNIT_Pc:
-      fValue *= 12.0f;
-      break;
-    default:
-      fValue = 0;
-      return FALSE;
-  }
-  switch (eUnit) {
-    case XFA_UNIT_Pt:
-      return TRUE;
-    case XFA_UNIT_Mm:
-      fValue /= 72 / 2.54f / 10;
-      return TRUE;
-    case XFA_UNIT_In:
-      fValue /= 72;
-      return TRUE;
-    case XFA_UNIT_Cm:
-      fValue /= 72 / 2.54f;
-      return TRUE;
-    case XFA_UNIT_Mp:
-      fValue /= 0.001f;
-      return TRUE;
-    case XFA_UNIT_Pc:
-      fValue /= 12.0f;
-      return TRUE;
-    default:
-      fValue = 0;
-      return FALSE;
-  }
-  return FALSE;
-}
-XFA_UNIT CXFA_Measurement::GetUnit(const CFX_WideStringC& wsUnit) {
-  if (wsUnit == FX_WSTRC(L"mm")) {
-    return XFA_UNIT_Mm;
-  } else if (wsUnit == FX_WSTRC(L"pt")) {
-    return XFA_UNIT_Pt;
-  } else if (wsUnit == FX_WSTRC(L"in")) {
-    return XFA_UNIT_In;
-  } else if (wsUnit == FX_WSTRC(L"cm")) {
-    return XFA_UNIT_Cm;
-  } else if (wsUnit == FX_WSTRC(L"pc")) {
-    return XFA_UNIT_Pc;
-  } else if (wsUnit == FX_WSTRC(L"mp")) {
-    return XFA_UNIT_Mp;
-  } else if (wsUnit == FX_WSTRC(L"em")) {
-    return XFA_UNIT_Em;
-  } else if (wsUnit == FX_WSTRC(L"%")) {
-    return XFA_UNIT_Percent;
-  } else {
-    return XFA_UNIT_Unknown;
-  }
-}
-IFX_Stream* XFA_CreateWideTextRead(const CFX_WideString& wsBuffer) {
-  return new CXFA_WideTextRead(wsBuffer);
-}
-CXFA_WideTextRead::CXFA_WideTextRead(const CFX_WideString& wsBuffer)
-    : m_wsBuffer(wsBuffer), m_iPosition(0), m_iRefCount(1) {}
-void CXFA_WideTextRead::Release() {
-  if (--m_iRefCount < 1) {
-    delete this;
-  }
-}
-IFX_Stream* CXFA_WideTextRead::Retain() {
-  m_iRefCount++;
-  return this;
-}
-FX_DWORD CXFA_WideTextRead::GetAccessModes() const {
-  return FX_STREAMACCESS_Read | FX_STREAMACCESS_Text;
-}
-int32_t CXFA_WideTextRead::GetLength() const {
-  return m_wsBuffer.GetLength() * sizeof(FX_WCHAR);
-}
-int32_t CXFA_WideTextRead::Seek(FX_STREAMSEEK eSeek, int32_t iOffset) {
-  switch (eSeek) {
-    case FX_STREAMSEEK_Begin:
-      m_iPosition = iOffset;
-      break;
-    case FX_STREAMSEEK_Current:
-      m_iPosition += iOffset;
-      break;
-    case FX_STREAMSEEK_End:
-      m_iPosition = m_wsBuffer.GetLength() + iOffset;
-      break;
-  }
-  if (m_iPosition < 0) {
-    m_iPosition = 0;
-  }
-  if (m_iPosition > m_wsBuffer.GetLength()) {
-    m_iPosition = m_wsBuffer.GetLength();
-  }
-  return GetPosition();
-}
-int32_t CXFA_WideTextRead::GetPosition() {
-  return m_iPosition * sizeof(FX_WCHAR);
-}
-FX_BOOL CXFA_WideTextRead::IsEOF() const {
-  return m_iPosition >= m_wsBuffer.GetLength();
-}
-int32_t CXFA_WideTextRead::ReadString(FX_WCHAR* pStr,
-                                      int32_t iMaxLength,
-                                      FX_BOOL& bEOS,
-                                      int32_t const* pByteSize) {
-  if (iMaxLength > m_wsBuffer.GetLength() - m_iPosition) {
-    iMaxLength = m_wsBuffer.GetLength() - m_iPosition;
-  }
-  FXSYS_wcsncpy(pStr, (const FX_WCHAR*)m_wsBuffer + m_iPosition, iMaxLength);
-  m_iPosition += iMaxLength;
-  bEOS = IsEOF();
-  return iMaxLength;
-}
-FX_WORD CXFA_WideTextRead::GetCodePage() const {
-  return (sizeof(FX_WCHAR) == 2) ? FX_CODEPAGE_UTF16LE : FX_CODEPAGE_UTF32LE;
-}
-FX_WORD CXFA_WideTextRead::SetCodePage(FX_WORD wCodePage) {
-  return GetCodePage();
-}
diff --git a/xfa/src/fxfa/parser/xfa_basic_imp.h b/xfa/src/fxfa/parser/xfa_basic_imp.h
deleted file mode 100644
index 562cf15909..0000000000
--- a/xfa/src/fxfa/parser/xfa_basic_imp.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_BASIC_IMP_H_
-#define XFA_SRC_FXFA_PARSER_XFA_BASIC_IMP_H_
-
-#include "xfa/include/fxfa/fxfa_basic.h"
-#include "xfa/src/fgas/crt/fgas_stream.h"
-
-struct XFA_NOTSUREATTRIBUTE {
-  XFA_ELEMENT eElement;
-  XFA_ATTRIBUTE eAttribute;
-  XFA_ATTRIBUTETYPE eType;
-  void* pValue;
-};
-const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(
-    XFA_ELEMENT eElement,
-    XFA_ATTRIBUTE eAttribute,
-    XFA_ATTRIBUTETYPE eType = XFA_ATTRIBUTETYPE_NOTSURE);
-
-class CXFA_WideTextRead : public IFX_Stream {
- public:
-  CXFA_WideTextRead(const CFX_WideString& wsBuffer);
-  virtual void Release();
-  virtual IFX_Stream* Retain();
-
-  virtual FX_DWORD GetAccessModes() const;
-  virtual int32_t GetLength() const;
-  virtual int32_t Seek(FX_STREAMSEEK eSeek, int32_t iOffset);
-  virtual int32_t GetPosition();
-  virtual FX_BOOL IsEOF() const;
-
-  virtual int32_t ReadData(uint8_t* pBuffer, int32_t iBufferSize) { return 0; }
-  virtual int32_t ReadString(FX_WCHAR* pStr,
-                             int32_t iMaxLength,
-                             FX_BOOL& bEOS,
-                             int32_t const* pByteSize = NULL);
-  virtual int32_t WriteData(const uint8_t* pBuffer, int32_t iBufferSize) {
-    return 0;
-  }
-  virtual int32_t WriteString(const FX_WCHAR* pStr, int32_t iLength) {
-    return 0;
-  }
-  virtual void Flush() {}
-  virtual FX_BOOL SetLength(int32_t iLength) { return FALSE; }
-
-  virtual int32_t GetBOM(uint8_t bom[4]) const { return 0; }
-  virtual FX_WORD GetCodePage() const;
-  virtual FX_WORD SetCodePage(FX_WORD wCodePage);
-
-  virtual void Lock() {}
-  virtual void Unlock() {}
-
-  virtual IFX_Stream* CreateSharedStream(FX_DWORD dwAccess,
-                                         int32_t iOffset,
-                                         int32_t iLength) {
-    return NULL;
-  }
-
-  CFX_WideString GetSrcText() const { return m_wsBuffer; }
-
- protected:
-  CFX_WideString m_wsBuffer;
-  int32_t m_iPosition;
-  int32_t m_iRefCount;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_BASIC_IMP_H_
diff --git a/xfa/src/fxfa/parser/xfa_docdata.h b/xfa/src/fxfa/parser/xfa_docdata.h
deleted file mode 100644
index 5c6cf13dfe..0000000000
--- a/xfa/src/fxfa/parser/xfa_docdata.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCDATA_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCDATA_H_
-
-#include "xfa/src/fxfa/parser/xfa_document.h"
-
-enum XFA_DATAFORMAT {
-  XFA_DATAFORMAT_XDP,
-};
-
-class IXFA_PacketExport {
- public:
-  static IXFA_PacketExport* Create(CXFA_Document* pDocument,
-                                   XFA_DATAFORMAT eFormat = XFA_DATAFORMAT_XDP);
-  virtual ~IXFA_PacketExport() {}
-  virtual void Release() = 0;
-  virtual FX_BOOL Export(IFX_FileWrite* pWrite) = 0;
-  virtual FX_BOOL Export(IFX_FileWrite* pWrite,
-                         CXFA_Node* pNode,
-                         FX_DWORD dwFlag = 0,
-                         const FX_CHAR* pChecksum = NULL) = 0;
-};
-class IXFA_PacketImport {
- public:
-  static IXFA_PacketImport* Create(CXFA_Document* pDstDoc);
-  virtual ~IXFA_PacketImport() {}
-  virtual void Release() = 0;
-  virtual FX_BOOL ImportData(IFX_FileRead* pDataDocument) = 0;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCDATA_H_
diff --git a/xfa/src/fxfa/parser/xfa_doclayout.h b/xfa/src/fxfa/parser/xfa_doclayout.h
deleted file mode 100644
index 1ebe412078..0000000000
--- a/xfa/src/fxfa/parser/xfa_doclayout.h
+++ /dev/null
@@ -1,136 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCLAYOUT_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCLAYOUT_H_
-
-#include "xfa/src/fxfa/parser/xfa_document.h"
-
-class CXFA_ContainerLayoutItem;
-class CXFA_ContentLayoutItem;
-class IXFA_DocLayout;
-
-class IXFA_LayoutPage {
- public:
-  virtual ~IXFA_LayoutPage() {}
-  virtual IXFA_DocLayout* GetLayout() const = 0;
-  virtual int32_t GetPageIndex() const = 0;
-  virtual void GetPageSize(CFX_SizeF& size) = 0;
-  virtual CXFA_Node* GetMasterPage() const = 0;
-};
-
-class CXFA_LayoutItem {
- public:
-  virtual ~CXFA_LayoutItem();
-
-  FX_BOOL IsContainerLayoutItem() const { return !m_bIsContentLayoutItem; }
-  FX_BOOL IsContentLayoutItem() const { return m_bIsContentLayoutItem; }
-  inline CXFA_ContainerLayoutItem* AsContainerLayoutItem();
-  inline CXFA_ContentLayoutItem* AsContentLayoutItem();
-
-  IXFA_LayoutPage* GetPage() const;
-  CXFA_Node* GetFormNode() const;
-  void GetRect(CFX_RectF& rtLayout, FX_BOOL bRelative = FALSE) const;
-  int32_t GetIndex() const;
-  int32_t GetCount() const;
-  CXFA_LayoutItem* GetParent() const;
-  const CXFA_LayoutItem* GetFirst() const;
-  CXFA_LayoutItem* GetFirst();
-  const CXFA_LayoutItem* GetLast() const;
-  CXFA_LayoutItem* GetLast();
-  CXFA_LayoutItem* GetPrev() const;
-  CXFA_LayoutItem* GetNext() const;
-
-  void AddChild(CXFA_LayoutItem* pChildItem);
-  void AddHeadChild(CXFA_LayoutItem* pChildItem);
-  void RemoveChild(CXFA_LayoutItem* pChildItem);
-  void InsertChild(CXFA_LayoutItem* pBeforeItem, CXFA_LayoutItem* pChildItem);
-
-  CXFA_Node* m_pFormNode;
-  CXFA_LayoutItem* m_pParent;
-  CXFA_LayoutItem* m_pNextSibling;
-  CXFA_LayoutItem* m_pFirstChild;
-
- protected:
-  CXFA_LayoutItem(CXFA_Node* pNode, FX_BOOL bIsContentLayoutItem);
-
-  FX_BOOL m_bIsContentLayoutItem;
-};
-
-class CXFA_ContainerLayoutItem : public CXFA_LayoutItem,
-                                 public IXFA_LayoutPage {
- public:
-  CXFA_ContainerLayoutItem(CXFA_Node* pNode);
-
-  // IXFA_LayoutPage:
-  IXFA_DocLayout* GetLayout() const override;
-  int32_t GetPageIndex() const override;
-  void GetPageSize(CFX_SizeF& size) override;
-  CXFA_Node* GetMasterPage() const override;
-
-  CXFA_Node* m_pOldSubform;
-};
-
-#define XFA_WIDGETSTATUS_Access 0x80000000
-#define XFA_WIDGETSTATUS_Disabled 0x40000000
-#define XFA_WIDGETSTATUS_RectCached 0x20000000
-#define XFA_WIDGETSTATUS_ButtonDown 0x10000000
-#define XFA_WIDGETSTATUS_Highlight 0x08000000
-#define XFA_WIDGETSTATUS_TextEditValueChanged 0x04000000
-
-class CXFA_ContentLayoutItem : public CXFA_LayoutItem {
- public:
-  CXFA_ContentLayoutItem(CXFA_Node* pNode);
-  virtual ~CXFA_ContentLayoutItem();
-
-  CXFA_ContentLayoutItem* m_pPrev;
-  CXFA_ContentLayoutItem* m_pNext;
-  CFX_PointF m_sPos;
-  CFX_SizeF m_sSize;
-  FX_DWORD m_dwStatus;
-};
-
-CXFA_ContainerLayoutItem* CXFA_LayoutItem::AsContainerLayoutItem() {
-  return IsContainerLayoutItem() ? static_cast<CXFA_ContainerLayoutItem*>(this)
-                                 : nullptr;
-}
-CXFA_ContentLayoutItem* CXFA_LayoutItem::AsContentLayoutItem() {
-  return IsContentLayoutItem() ? static_cast<CXFA_ContentLayoutItem*>(this)
-                               : nullptr;
-}
-inline CXFA_ContainerLayoutItem* ToContainerLayoutItem(CXFA_LayoutItem* pItem) {
-  return pItem ? pItem->AsContainerLayoutItem() : nullptr;
-}
-inline CXFA_ContentLayoutItem* ToContentLayoutItem(CXFA_LayoutItem* pItem) {
-  return pItem ? pItem->AsContentLayoutItem() : nullptr;
-}
-
-class CXFA_TraverseStrategy_LayoutItem {
- public:
-  static inline CXFA_LayoutItem* GetFirstChild(CXFA_LayoutItem* pLayoutItem) {
-    return pLayoutItem->m_pFirstChild;
-  }
-  static inline CXFA_LayoutItem* GetNextSibling(CXFA_LayoutItem* pLayoutItem) {
-    return pLayoutItem->m_pNextSibling;
-  }
-  static inline CXFA_LayoutItem* GetParent(CXFA_LayoutItem* pLayoutItem) {
-    return pLayoutItem->m_pParent;
-  }
-};
-
-class IXFA_DocLayout {
- public:
-  virtual ~IXFA_DocLayout() {}
-  virtual CXFA_Document* GetDocument() const = 0;
-  virtual int32_t StartLayout(FX_BOOL bForceRestart = FALSE) = 0;
-  virtual int32_t DoLayout(IFX_Pause* pPause = NULL) = 0;
-  virtual FX_BOOL IncrementLayout() = 0;
-  virtual int32_t CountPages() const = 0;
-  virtual IXFA_LayoutPage* GetPage(int32_t index) const = 0;
-  virtual CXFA_LayoutItem* GetLayoutItem(CXFA_Node* pFormItem) = 0;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCLAYOUT_H_
diff --git a/xfa/src/fxfa/parser/xfa_document.h b/xfa/src/fxfa/parser/xfa_document.h
deleted file mode 100644
index d17c9883c9..0000000000
--- a/xfa/src/fxfa/parser/xfa_document.h
+++ /dev/null
@@ -1,201 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_H_
-
-#include "xfa/include/fxfa/fxfa.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-class CXFA_Document;
-class CXFA_LayoutItem;
-class CXFA_LayoutProcessor;
-class CXFA_Node;
-class IXFA_DocLayout;
-class IXFA_DocParser;
-class IXFA_LayoutPage;
-class IXFA_Notify;
-class IXFA_ObjFactory;
-class IXFA_ScriptContext;
-
-enum XFA_VERSION {
-  XFA_VERSION_UNKNOWN = 0,
-  XFA_VERSION_200 = 200,
-  XFA_VERSION_202 = 202,
-  XFA_VERSION_204 = 204,
-  XFA_VERSION_205 = 205,
-  XFA_VERSION_206 = 206,
-  XFA_VERSION_207 = 207,
-  XFA_VERSION_208 = 208,
-  XFA_VERSION_300 = 300,
-  XFA_VERSION_301 = 301,
-  XFA_VERSION_303 = 303,
-  XFA_VERSION_306 = 306,
-  XFA_VERSION_DEFAULT = XFA_VERSION_303,
-  XFA_VERSION_MIN = 200,
-  XFA_VERSION_MAX = 400,
-};
-
-#define XFA_LAYOUTSTATUS_Visible 0x0001
-#define XFA_LAYOUTSTATUS_Viewable 0x0010
-#define XFA_LAYOUTSTATUS_Printable 0x0020
-enum XFA_NODEEVENT {
-  XFA_NODEEVENT_Ready,
-  XFA_NODEEVENT_ValueChanging,
-  XFA_NODEEVENT_ValueChanged,
-  XFA_NODEEVENT_ChildAdded,
-  XFA_NODEEVENT_ChildRemoved,
-};
-enum XFA_PAGEEVENT {
-  XFA_PAGEEVENT_PageAdded,
-  XFA_PAGEEVENT_PageRemoved,
-};
-enum XFA_LAYOUTEVENT {
-  XFA_LAYOUTEVENT_ItemAdded,
-  XFA_LAYOUTEVENT_ItemRemoving,
-  XFA_LAYOUTEVENT_RectChanged,
-  XFA_LAYOUTEVENT_StatusChanged,
-};
-enum XFA_LAYOUTRESULT {
-  XFA_LAYOUTRESULT_Continue,
-  XFA_LAYOUTRESULT_Done,
-  XFA_LAYOUTRESULT_NextContent,
-};
-#define XFA_LAYOUTNOTIFY_StrictHeight 0x0001
-#define XFA_LAYOUTNOTIFY_NoParentBreak 0x0002
-
-class IXFA_Notify {
- public:
-  virtual ~IXFA_Notify() {}
-  virtual void OnPageEvent(IXFA_LayoutPage* pSender,
-                           XFA_PAGEEVENT eEvent,
-                           void* pParam = NULL) = 0;
-
-  virtual void OnNodeEvent(CXFA_Node* pSender,
-                           XFA_NODEEVENT eEvent,
-                           void* pParam = NULL,
-                           void* pParam2 = NULL,
-                           void* pParam3 = NULL,
-                           void* pParam4 = NULL) = 0;
-  virtual void OnWidgetDataEvent(CXFA_WidgetData* pSender,
-                                 FX_DWORD dwEvent,
-                                 void* pParam = NULL,
-                                 void* pAdditional = NULL,
-                                 void* pAdditional2 = NULL) = 0;
-
-  virtual CXFA_LayoutItem* OnCreateLayoutItem(CXFA_Node* pNode) = 0;
-  virtual void OnLayoutEvent(IXFA_DocLayout* pLayout,
-                             CXFA_LayoutItem* pSender,
-                             XFA_LAYOUTEVENT eEvent,
-                             void* pParam = NULL,
-                             void* pParam2 = NULL) = 0;
-  virtual void StartFieldDrawLayout(CXFA_Node* pItem,
-                                    FX_FLOAT& fCalcWidth,
-                                    FX_FLOAT& fCalcHeight) = 0;
-  virtual FX_BOOL FindSplitPos(CXFA_Node* pItem,
-                               int32_t iBlockIndex,
-                               FX_FLOAT& fCalcHeightPos) = 0;
-  virtual FX_BOOL RunScript(CXFA_Node* pScript, CXFA_Node* pFormItem) = 0;
-  virtual int32_t ExecEventByDeepFirst(CXFA_Node* pFormNode,
-                                       XFA_EVENTTYPE eEventType,
-                                       FX_BOOL bIsFormReady = FALSE,
-                                       FX_BOOL bRecursive = TRUE,
-                                       CXFA_WidgetAcc* pExclude = NULL) = 0;
-  virtual void AddCalcValidate(CXFA_Node* pNode) = 0;
-  virtual IXFA_Doc* GetHDOC() = 0;
-  virtual IXFA_DocProvider* GetDocProvider() = 0;
-  virtual IXFA_AppProvider* GetAppProvider() = 0;
-  virtual IXFA_WidgetHandler* GetWidgetHandler() = 0;
-  virtual IXFA_Widget* GetHWidget(CXFA_LayoutItem* pLayoutItem) = 0;
-  virtual void OpenDropDownList(IXFA_Widget* hWidget) = 0;
-  virtual CFX_WideString GetCurrentDateTime() = 0;
-  virtual void ResetData(CXFA_WidgetData* pWidgetData = NULL) = 0;
-  virtual int32_t GetLayoutStatus() = 0;
-  virtual void RunNodeInitialize(CXFA_Node* pNode) = 0;
-  virtual void RunSubformIndexChange(CXFA_Node* pSubformNode) = 0;
-  virtual CXFA_Node* GetFocusWidgetNode() = 0;
-  virtual void SetFocusWidgetNode(CXFA_Node* pNode) = 0;
-};
-class IXFA_ObjFactory {
- public:
-  virtual ~IXFA_ObjFactory() {}
-  virtual CXFA_Node* CreateNode(FX_DWORD dwPacket, XFA_ELEMENT eElement) = 0;
-  virtual CXFA_Node* CreateNode(const XFA_PACKETINFO* pPacket,
-                                XFA_ELEMENT eElement) = 0;
-};
-#define XFA_DOCFLAG_StrictScoping 0x0001
-#define XFA_DOCFLAG_HasInteractive 0x0002
-#define XFA_DOCFLAG_Interactive 0x0004
-#define XFA_DOCFLAG_Scripting 0x0008
-class CScript_DataWindow;
-class CScript_EventPseudoModel;
-class CScript_HostPseudoModel;
-class CScript_LogPseudoModel;
-class CScript_LayoutPseudoModel;
-class CScript_SignaturePseudoModel;
-class CXFA_Document : public IXFA_ObjFactory {
- public:
-  CXFA_Document(IXFA_DocParser* pParser);
-  ~CXFA_Document();
-  CXFA_Node* GetRoot() const { return m_pRootNode; }
-  IXFA_DocParser* GetParser() const { return m_pParser; }
-  IXFA_Notify* GetNotify() const;
-  void SetRoot(CXFA_Node* pNewRoot);
-  CXFA_Object* GetXFAObject(const CFX_WideStringC& wsNodeName);
-  CXFA_Object* GetXFAObject(FX_DWORD wsNodeNameHash);
-  void AddPurgeNode(CXFA_Node* pNode);
-  FX_BOOL RemovePurgeNode(CXFA_Node* pNode);
-  void PurgeNodes();
-  bool HasFlag(FX_DWORD dwFlag) { return (m_dwDocFlags & dwFlag) == dwFlag; }
-  void SetFlag(FX_DWORD dwFlag, FX_BOOL bOn = TRUE);
-  FX_BOOL IsInteractive();
-  XFA_VERSION GetCurVersionMode() { return m_eCurVersionMode; }
-  XFA_VERSION RecognizeXFAVersionNumber(CFX_WideString& wsTemplateNS);
-  CXFA_LocaleMgr* GetLocalMgr();
-  virtual CXFA_Node* CreateNode(FX_DWORD dwPacket, XFA_ELEMENT eElement);
-  virtual CXFA_Node* CreateNode(const XFA_PACKETINFO* pPacket,
-                                XFA_ELEMENT eElement);
-  void DoProtoMerge();
-  CXFA_Node* GetNodeByID(CXFA_Node* pRoot, const CFX_WideStringC& wsID);
-  void DoDataMerge();
-  void DoDataRemerge(FX_BOOL bDoDataMerge);
-  CXFA_Node* DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
-                                     CXFA_Node* pFormNode,
-                                     CXFA_Node* pDataScope,
-                                     FX_BOOL bOneInstance = FALSE,
-                                     FX_BOOL bDataMerge = TRUE,
-                                     FX_BOOL bUpLevel = TRUE);
-  void DataMerge_UpdateBindingRelations(CXFA_Node* pFormUpdateRoot);
-  CXFA_Node* GetNotBindNode(CXFA_ObjArray& arrayNodes);
-  CXFA_LayoutProcessor* GetLayoutProcessor();
-  IXFA_DocLayout* GetDocLayout();
-  IXFA_ScriptContext* InitScriptContext(FXJSE_HRUNTIME hRuntime);
-  IXFA_ScriptContext* GetScriptContext();
-  void ClearLayoutData();
-
-  CFX_MapPtrTemplate<FX_DWORD, CXFA_Node*> m_rgGlobalBinding;
-  CXFA_NodeArray m_pPendingPageSet;
-
- protected:
-  IXFA_DocParser* m_pParser;
-  IXFA_ScriptContext* m_pScriptContext;
-  CXFA_LayoutProcessor* m_pLayoutProcessor;
-  CXFA_Node* m_pRootNode;
-  CXFA_LocaleMgr* m_pLocalMgr;
-  CScript_DataWindow* m_pScriptDataWindow;
-  CScript_EventPseudoModel* m_pScriptEvent;
-  CScript_HostPseudoModel* m_pScriptHost;
-  CScript_LogPseudoModel* m_pScriptLog;
-  CScript_LayoutPseudoModel* m_pScriptLayout;
-  CScript_SignaturePseudoModel* m_pScriptSignature;
-  CXFA_NodeSet m_rgPurgeNodes;
-  XFA_VERSION m_eCurVersionMode;
-  FX_DWORD m_dwDocFlags;
-  friend class CXFA_SimpleParser;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_H_
diff --git a/xfa/src/fxfa/parser/xfa_document_datadescription_imp.cpp b/xfa/src/fxfa/parser/xfa_document_datadescription_imp.cpp
deleted file mode 100644
index 321fbbd466..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_datadescription_imp.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-// 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/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-#define XFA_HASHCODE_Group 0xf7f75fcd
-
-class CXFA_TraverseStrategy_DDGroup {
- public:
-  static inline CXFA_Node* GetFirstChild(CXFA_Node* pDDGroupNode) {
-    return pDDGroupNode->GetFirstChildByName(XFA_HASHCODE_Group);
-  }
-  static inline CXFA_Node* GetNextSibling(CXFA_Node* pDDGroupNode) {
-    return pDDGroupNode->GetNextSameNameSibling(XFA_HASHCODE_Group);
-  }
-  static inline CXFA_Node* GetParent(CXFA_Node* pDDGroupNode) {
-    return pDDGroupNode->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-};
-void XFA_DataDescription_UpdateDataRelation(CXFA_Node* pDataNode,
-                                            CXFA_Node* pDataDescriptionNode) {
-  FXSYS_assert(pDataDescriptionNode);
-  for (CXFA_Node* pDataChild = pDataNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pDataChild;
-       pDataChild = pDataChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    FX_DWORD dwNameHash = pDataChild->GetNameHash();
-    XFA_ELEMENT eType = pDataChild->GetClassID();
-    if (!dwNameHash) {
-      continue;
-    }
-    CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_DDGroup>
-        sIterator(pDataDescriptionNode);
-    for (CXFA_Node* pDDGroupNode = sIterator.GetCurrent(); pDDGroupNode;
-         pDDGroupNode = sIterator.MoveToNext()) {
-      if (pDDGroupNode != pDataDescriptionNode) {
-        if (pDDGroupNode->GetClassID() != XFA_ELEMENT_DataGroup) {
-          continue;
-        }
-        CFX_WideString wsNamespace;
-        if (!pDDGroupNode->TryNamespace(wsNamespace) ||
-            wsNamespace != FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
-          continue;
-        }
-      }
-      CXFA_Node* pDDNode = pDDGroupNode->GetFirstChildByName(dwNameHash);
-      if (!pDDNode) {
-        continue;
-      }
-      if (pDDNode->GetClassID() != eType) {
-        break;
-      }
-      pDataChild->SetDataDescriptionNode(pDDNode);
-      XFA_DataDescription_UpdateDataRelation(pDataChild, pDDNode);
-      break;
-    }
-  }
-}
-CXFA_Node* XFA_DataDescription_MaybeCreateDataNode(
-    CXFA_Document* pDocument,
-    CXFA_Node* pDataParent,
-    XFA_ELEMENT eNodeType,
-    const CFX_WideStringC& wsName) {
-  if (!pDataParent) {
-    return NULL;
-  }
-  CXFA_Node* pParentDDNode = pDataParent->GetDataDescriptionNode();
-  if (!pParentDDNode) {
-    CXFA_Node* pDataNode =
-        pDocument->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
-    FXSYS_assert(pDataNode);
-    pDataNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
-    pDataNode->CreateXMLMappingNode();
-    pDataParent->InsertChild(pDataNode);
-    pDataNode->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-    return pDataNode;
-  } else {
-    CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_DDGroup>
-        sIterator(pParentDDNode);
-    for (CXFA_Node* pDDGroupNode = sIterator.GetCurrent(); pDDGroupNode;
-         pDDGroupNode = sIterator.MoveToNext()) {
-      if (pDDGroupNode != pParentDDNode) {
-        if (pDDGroupNode->GetClassID() != XFA_ELEMENT_DataGroup) {
-          continue;
-        }
-        CFX_WideString wsNamespace;
-        if (!pDDGroupNode->TryNamespace(wsNamespace) ||
-            wsNamespace != FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
-          continue;
-        }
-      }
-      CXFA_Node* pDDNode = pDDGroupNode->GetFirstChildByName(wsName);
-      if (!pDDNode) {
-        continue;
-      }
-      if (pDDNode->GetClassID() != eNodeType) {
-        break;
-      }
-      CXFA_Node* pDataNode =
-          pDocument->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
-      FXSYS_assert(pDataNode);
-      pDataNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
-      pDataNode->CreateXMLMappingNode();
-      if (eNodeType == XFA_ELEMENT_DataValue &&
-          pDDNode->GetEnum(XFA_ATTRIBUTE_Contains) ==
-              XFA_ATTRIBUTEENUM_MetaData) {
-        pDataNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_MetaData);
-      }
-      pDataParent->InsertChild(pDataNode);
-      pDataNode->SetDataDescriptionNode(pDDNode);
-      pDataNode->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-      return pDataNode;
-    }
-    return NULL;
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_document_datadescription_imp.h b/xfa/src/fxfa/parser/xfa_document_datadescription_imp.h
deleted file mode 100644
index bf0b1a45c7..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_datadescription_imp.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_DATADESCRIPTION_IMP_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_DATADESCRIPTION_IMP_H_
-
-void XFA_DataDescription_UpdateDataRelation(CXFA_Node* pDataNode,
-                                            CXFA_Node* pDataDescriptionNode);
-CXFA_Node* XFA_DataDescription_MaybeCreateDataNode(
-    CXFA_Document* pDocument,
-    CXFA_Node* pDataParent,
-    XFA_ELEMENT eNodeType,
-    const CFX_WideStringC& wsName);
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_DATADESCRIPTION_IMP_H_
diff --git a/xfa/src/fxfa/parser/xfa_document_datamerger_imp.cpp b/xfa/src/fxfa/parser/xfa_document_datamerger_imp.cpp
deleted file mode 100644
index ecbbba7579..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_datamerger_imp.cpp
+++ /dev/null
@@ -1,1429 +0,0 @@
-// 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/src/fxfa/parser/xfa_document_datamerger_imp.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_datadescription_imp.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-static FX_BOOL XFA_GetOccurInfo(CXFA_Node* pOccurNode,
-                                int32_t& iMin,
-                                int32_t& iMax,
-                                int32_t& iInit) {
-  if (!pOccurNode) {
-    return FALSE;
-  }
-  CXFA_Occur occur(pOccurNode);
-  return occur.GetOccurInfo(iMin, iMax, iInit);
-}
-struct XFA_DataMerge_RecurseRecord {
-  CXFA_Node* pTemplateChild;
-  CXFA_Node* pDataChild;
-};
-static CXFA_Node* XFA_DataMerge_FormValueNode_CreateChild(
-    CXFA_Node* pValueNode,
-    XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) {
-  CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  if (!pChildNode) {
-    if (iType == XFA_ELEMENT_UNKNOWN) {
-      return FALSE;
-    }
-    pChildNode = pValueNode->GetProperty(0, iType);
-  }
-  return pChildNode;
-}
-static void XFA_DataMerge_FormValueNode_MatchNoneCreateChild(
-    CXFA_Node* pFormNode) {
-  CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
-  FXSYS_assert(pWidgetData);
-  pWidgetData->GetUIType();
-}
-static FX_BOOL XFA_DataMerge_FormValueNode_SetChildContent(
-    CXFA_Node* pValueNode,
-    const CFX_WideString& wsContent,
-    XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) {
-  if (!pValueNode) {
-    return FALSE;
-  }
-  FXSYS_assert(pValueNode->GetPacketID() == XFA_XDPPACKET_Form);
-  CXFA_Node* pChildNode =
-      XFA_DataMerge_FormValueNode_CreateChild(pValueNode, iType);
-  if (!pChildNode) {
-    return FALSE;
-  }
-  XFA_OBJECTTYPE objectType = pChildNode->GetObjectType();
-  switch (objectType) {
-    case XFA_OBJECTTYPE_ContentNode: {
-      CXFA_Node* pContentRawDataNode =
-          pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (!pContentRawDataNode) {
-        XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
-        if (pChildNode->GetClassID() == XFA_ELEMENT_ExData) {
-          CFX_WideString wsContentType;
-          pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
-                                   FALSE);
-          if (wsContentType.Equal(FX_WSTRC(L"text/html"))) {
-            element = XFA_ELEMENT_SharpxHTML;
-          } else if (wsContentType.Equal(FX_WSTRC(L"text/xml"))) {
-            element = XFA_ELEMENT_Sharpxml;
-          }
-        }
-        pContentRawDataNode = pChildNode->CreateSamePacketNode(element);
-        pChildNode->InsertChild(pContentRawDataNode);
-      }
-      pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
-    } break;
-    case XFA_OBJECTTYPE_NodeC:
-    case XFA_OBJECTTYPE_TextNode:
-    case XFA_OBJECTTYPE_NodeV: {
-      pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
-    } break;
-    default:
-      FXSYS_assert(FALSE);
-      break;
-  }
-  return TRUE;
-}
-static void XFA_DataMerge_CreateDataBinding(CXFA_Node* pFormNode,
-                                            CXFA_Node* pDataNode,
-                                            FX_BOOL bDataToForm = TRUE) {
-  pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode);
-  pDataNode->AddBindItem(pFormNode);
-  XFA_ELEMENT eClass = pFormNode->GetClassID();
-  if (eClass != XFA_ELEMENT_Field && eClass != XFA_ELEMENT_ExclGroup) {
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
-  FXSYS_assert(pWidgetData);
-  FX_BOOL bNotify = FALSE;
-  XFA_ELEMENT eUIType = pWidgetData->GetUIType();
-  CXFA_Value defValue(pFormNode->GetProperty(0, XFA_ELEMENT_Value));
-  if (!bDataToForm) {
-    CFX_WideString wsValue;
-    CFX_WideString wsFormatedValue;
-    switch (eUIType) {
-      case XFA_ELEMENT_ImageEdit: {
-        CXFA_Image image = defValue.GetImage();
-        CFX_WideString wsContentType;
-        CFX_WideString wsHref;
-        if (image) {
-          image.GetContent(wsValue);
-          image.GetContentType(wsContentType);
-          image.GetHref(wsHref);
-        }
-        IFDE_XMLElement* pXMLDataElement =
-            (IFDE_XMLElement*)(pDataNode->GetXMLMappingNode());
-        FXSYS_assert(pXMLDataElement);
-        pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
-        pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-        pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-        if (!wsHref.IsEmpty()) {
-          pXMLDataElement->SetString(FX_WSTRC(L"href"), wsHref);
-        }
-      } break;
-      case XFA_ELEMENT_ChoiceList:
-        defValue.GetChildValueContent(wsValue);
-        if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
-          CFX_WideStringArray wsSelTextArray;
-          pWidgetData->GetSelectedItemsValue(wsSelTextArray);
-          int32_t iSize = wsSelTextArray.GetSize();
-          if (iSize >= 1) {
-            CXFA_Node* pValue = NULL;
-            for (int32_t i = 0; i < iSize; i++) {
-              pValue = pDataNode->CreateSamePacketNode(XFA_ELEMENT_DataValue);
-              pValue->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"value"));
-              pValue->CreateXMLMappingNode();
-              pDataNode->InsertChild(pValue);
-              pValue->SetCData(XFA_ATTRIBUTE_Value, wsSelTextArray[i]);
-            }
-          } else {
-            IFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
-            FXSYS_assert(pXMLNode->GetType() == FDE_XMLNODE_Element);
-            ((IFDE_XMLElement*)pXMLNode)
-                ->SetString(FX_WSTRC(L"xfa:dataNode"), FX_WSTRC(L"dataGroup"));
-          }
-        } else if (!wsValue.IsEmpty()) {
-          pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
-          pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-        }
-        break;
-      case XFA_ELEMENT_CheckButton:
-        defValue.GetChildValueContent(wsValue);
-        if (wsValue.IsEmpty()) {
-          break;
-        }
-        pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
-        pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-        break;
-      case XFA_ELEMENT_ExclGroup: {
-        CXFA_Node* pChecked = NULL;
-        CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-        for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-          if (pChild->GetClassID() != XFA_ELEMENT_Field) {
-            continue;
-          }
-          CXFA_Node* pValue = pChild->GetChild(0, XFA_ELEMENT_Value);
-          if (!pValue) {
-            continue;
-          }
-          CXFA_Value valueChild(pValue);
-          valueChild.GetChildValueContent(wsValue);
-          if (wsValue.IsEmpty()) {
-            continue;
-          }
-          CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items);
-          if (!pItems) {
-            continue;
-          }
-          CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-          if (!pText) {
-            continue;
-          }
-          CFX_WideString wsContent;
-          if (pText->TryContent(wsContent) && (wsContent == wsValue)) {
-            pChecked = pChild;
-            wsFormatedValue = wsValue;
-            pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-            pFormNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
-            break;
-          }
-        }
-        if (!pChecked) {
-          break;
-        }
-        pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-        for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-          if (pChild == pChecked) {
-            continue;
-          }
-          if (pChild->GetClassID() != XFA_ELEMENT_Field) {
-            continue;
-          }
-          CXFA_Node* pValue = pChild->GetProperty(0, XFA_ELEMENT_Value);
-          CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items);
-          CXFA_Node* pText =
-              pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : NULL;
-          if (pText) {
-            pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
-          }
-          CFX_WideString wsContent;
-          if (pText) {
-            pText->TryContent(wsContent);
-          }
-          XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsContent,
-                                                      XFA_ELEMENT_Text);
-        }
-      } break;
-      case XFA_ELEMENT_NumericEdit: {
-        defValue.GetChildValueContent(wsValue);
-        if (wsValue.IsEmpty()) {
-          break;
-        }
-        CFX_WideString wsOutput;
-        pWidgetData->NormalizeNumStr(wsValue, wsOutput);
-        wsValue = wsOutput;
-        pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
-        pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-        CXFA_Node* pValue = pFormNode->GetProperty(0, XFA_ELEMENT_Value);
-        XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsValue,
-                                                    XFA_ELEMENT_Float);
-      } break;
-      default:
-        defValue.GetChildValueContent(wsValue);
-        if (wsValue.IsEmpty()) {
-          break;
-        }
-        pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
-        pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
-        break;
-    }
-  } else {
-    CFX_WideString wsXMLValue;
-    pDataNode->TryContent(wsXMLValue);
-    CFX_WideString wsNormailizeValue;
-    pWidgetData->GetNormalizeDataValue(wsXMLValue, wsNormailizeValue);
-    pDataNode->SetAttributeValue(wsNormailizeValue, wsXMLValue);
-    switch (eUIType) {
-      case XFA_ELEMENT_ImageEdit: {
-        XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Image);
-        CXFA_Image image = defValue.GetImage();
-        if (image) {
-          IFDE_XMLElement* pXMLDataElement =
-              (IFDE_XMLElement*)(pDataNode->GetXMLMappingNode());
-          FXSYS_assert(pXMLDataElement);
-          CFX_WideString wsContentType;
-          CFX_WideString wsHref;
-          pXMLDataElement->GetString(L"xfa:contentType", wsContentType);
-          if (!wsContentType.IsEmpty()) {
-            pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-            image.SetContentType(wsContentType);
-          }
-          pXMLDataElement->GetString(L"href", wsHref);
-          if (!wsHref.IsEmpty()) {
-            image.SetHref(wsHref);
-          }
-        }
-      } break;
-      case XFA_ELEMENT_ChoiceList:
-        if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
-          CXFA_NodeArray items;
-          pDataNode->GetNodeList(items);
-          int32_t iCounts = items.GetSize();
-          if (iCounts > 0) {
-            wsNormailizeValue.Empty();
-            CFX_WideString wsItem;
-            for (int32_t i = 0; i < iCounts; i++) {
-              items[i]->TryContent(wsItem);
-              wsItem = (iCounts == 1) ? wsItem : wsItem + FX_WSTRC(L"\n");
-              wsNormailizeValue += wsItem;
-            }
-            CXFA_ExData exData = defValue.GetExData();
-            FXSYS_assert(exData);
-            exData.SetContentType((iCounts == 1) ? FX_WSTRC(L"text/plain")
-                                                 : FX_WSTRC(L"text/xml"));
-          }
-          XFA_DataMerge_FormValueNode_SetChildContent(
-              defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_ExData);
-        } else {
-          XFA_DataMerge_FormValueNode_SetChildContent(
-              defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text);
-        }
-        break;
-      case XFA_ELEMENT_CheckButton:
-        XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text);
-        break;
-      case XFA_ELEMENT_ExclGroup: {
-        pWidgetData->SetSelectedMemberByValue(wsNormailizeValue, bNotify, FALSE,
-                                              FALSE);
-      } break;
-      case XFA_ELEMENT_DateTimeEdit:
-        XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_DateTime);
-        break;
-      case XFA_ELEMENT_NumericEdit: {
-        CFX_WideString wsPicture;
-        pWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
-        if (wsPicture.IsEmpty()) {
-          CFX_WideString wsOutput;
-          pWidgetData->NormalizeNumStr(wsNormailizeValue, wsOutput);
-          wsNormailizeValue = wsOutput;
-        }
-        XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Float);
-      } break;
-      case XFA_ELEMENT_Barcode:
-      case XFA_ELEMENT_Button:
-      case XFA_ELEMENT_PasswordEdit:
-      case XFA_ELEMENT_Signature:
-      case XFA_ELEMENT_TextEdit:
-      default:
-        XFA_DataMerge_FormValueNode_SetChildContent(
-            defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text);
-        break;
-    }
-  }
-}
-static CXFA_Node* XFA_DataMerge_GetGlobalBinding(CXFA_Document* pDocument,
-                                                 FX_DWORD dwNameHash) {
-  CXFA_Node* pNode = NULL;
-  pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode);
-  return pNode;
-}
-static void XFA_DataMerge_RegisterGlobalBinding(CXFA_Document* pDocument,
-                                                FX_DWORD dwNameHash,
-                                                CXFA_Node* pDataNode) {
-  pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode);
-}
-static void XFA_DataMerge_ClearGlobalBinding(CXFA_Document* pDocument) {
-  pDocument->m_rgGlobalBinding.RemoveAll();
-}
-static CXFA_Node* XFA_DataMerge_ScopeMatchGlobalBinding(
-    CXFA_Node* pDataScope,
-    FX_DWORD dwNameHash,
-    XFA_ELEMENT eMatchDataNodeType,
-    FX_BOOL bUpLevel = TRUE) {
-  for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = NULL;
-       pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
-       pLastDataScope = pCurDataScope,
-                 pCurDataScope =
-                     pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
-    for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
-         pDataChild;
-         pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
-      if (pDataChild == pLastDataScope ||
-          (eMatchDataNodeType != XFA_ELEMENT_DataModel &&
-           pDataChild->GetClassID() != eMatchDataNodeType) ||
-          pDataChild->HasBindItem()) {
-        continue;
-      }
-      return pDataChild;
-    }
-    for (CXFA_Node* pDataChild =
-             pCurDataScope->GetFirstChildByClass(XFA_ELEMENT_DataGroup);
-         pDataChild; pDataChild = pDataChild->GetNextSameClassSibling(
-                         XFA_ELEMENT_DataGroup)) {
-      CXFA_Node* pDataNode = XFA_DataMerge_ScopeMatchGlobalBinding(
-          pDataChild, dwNameHash, eMatchDataNodeType, FALSE);
-      if (pDataNode) {
-        return pDataNode;
-      }
-    }
-    if (!bUpLevel) {
-      break;
-    }
-  }
-  return NULL;
-}
-static CXFA_Node* XFA_DataMerge_FindGlobalDataNode(CXFA_Document* pDocument,
-                                                   CFX_WideStringC wsName,
-                                                   CXFA_Node* pDataScope,
-                                                   XFA_ELEMENT eMatchNodeType) {
-  FX_DWORD dwNameHash =
-      wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
-                                                     wsName.GetLength());
-  if (dwNameHash != 0) {
-    CXFA_Node* pBounded = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash);
-    if (!pBounded) {
-      pBounded = XFA_DataMerge_ScopeMatchGlobalBinding(pDataScope, dwNameHash,
-                                                       eMatchNodeType);
-      if (pBounded) {
-        XFA_DataMerge_RegisterGlobalBinding(pDocument, dwNameHash, pBounded);
-      }
-    }
-    return pBounded;
-  }
-  return NULL;
-}
-static CXFA_Node* XFA_DataMerge_FindOnceDataNode(CXFA_Document* pDocument,
-                                                 CFX_WideStringC wsName,
-                                                 CXFA_Node* pDataScope,
-                                                 XFA_ELEMENT eMatchNodeType) {
-  FX_DWORD dwNameHash =
-      wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
-                                                     wsName.GetLength());
-  if (dwNameHash != 0) {
-    for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = NULL;
-         pCurDataScope &&
-         pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
-         pLastDataScope = pCurDataScope,
-                   pCurDataScope =
-                       pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
-      for (CXFA_Node* pDataChild =
-               pCurDataScope->GetFirstChildByName(dwNameHash);
-           pDataChild;
-           pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
-        if (pDataChild == pLastDataScope ||
-            (eMatchNodeType != XFA_ELEMENT_DataModel &&
-             pDataChild->GetClassID() != eMatchNodeType) ||
-            pDataChild->HasBindItem()) {
-          continue;
-        }
-        return pDataChild;
-      }
-    }
-  }
-  return NULL;
-}
-static CXFA_Node* XFA_DataMerge_FindDataRefDataNode(CXFA_Document* pDocument,
-                                                    CFX_WideStringC wsRef,
-                                                    CXFA_Node* pDataScope,
-                                                    XFA_ELEMENT eMatchNodeType,
-                                                    CXFA_Node* pTemplateNode,
-                                                    FX_BOOL bForceBind,
-                                                    FX_BOOL bUpLevel = TRUE) {
-  FX_DWORD dFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_BindNew;
-  if (bUpLevel || wsRef != FX_WSTRC(L"name")) {
-    dFlags |= (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings);
-  }
-  XFA_RESOLVENODE_RS rs;
-  pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags,
-                                                pTemplateNode);
-  if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll ||
-      rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll ||
-      rs.nodes.GetSize() > 1) {
-    return pDocument->GetNotBindNode(rs.nodes);
-  }
-  if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) {
-    CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL;
-    CXFA_Node* pNode = ToNode(pObject);
-    if (!bForceBind && pNode && pNode->HasBindItem()) {
-      pNode = NULL;
-    }
-    return pNode;
-  }
-  return NULL;
-}
-CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
-                                             XFA_ELEMENT eClassID,
-                                             FX_DWORD dwNameHash,
-                                             CXFA_Node* pFormParent) {
-  CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pFormChild;
-       pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pFormChild->GetClassID() == eClassID &&
-        pFormChild->GetNameHash() == dwNameHash &&
-        pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-      return pFormChild;
-    }
-  }
-  return NULL;
-}
-static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild,
-                                    FX_BOOL bUseInstanceManager = TRUE) {
-  XFA_ELEMENT eType = pTemplateChild->GetClassID();
-  if (eType == XFA_ELEMENT_Variables) {
-    return TRUE;
-  }
-  if (pTemplateChild->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) {
-    return FALSE;
-  }
-  if (eType == XFA_ELEMENT_Proto ||
-      (bUseInstanceManager && eType == XFA_ELEMENT_Occur)) {
-    return FALSE;
-  }
-  return TRUE;
-}
-CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
-                                               CXFA_Node* pFormParent,
-                                               CXFA_Node* pTemplateNode,
-                                               FX_BOOL bRecursive,
-                                               CXFA_NodeArray* pSubformArray) {
-  CXFA_Node* pExistingNode = NULL;
-  if (pSubformArray == NULL) {
-    pExistingNode = XFA_DataMerge_FindFormDOMInstance(
-        pDocument, pTemplateNode->GetClassID(), pTemplateNode->GetNameHash(),
-        pFormParent);
-  } else if (pSubformArray->GetSize() > 0) {
-    pExistingNode = pSubformArray->GetAt(0);
-    pSubformArray->RemoveAt(0);
-  }
-  if (pExistingNode) {
-    if (pSubformArray) {
-      pFormParent->InsertChild(pExistingNode);
-    } else if (pExistingNode->IsContainerNode()) {
-      pFormParent->RemoveChild(pExistingNode);
-      pFormParent->InsertChild(pExistingNode);
-    }
-    pExistingNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-    pExistingNode->SetTemplateNode(pTemplateNode);
-    if (bRecursive && pExistingNode->GetClassID() != XFA_ELEMENT_Items) {
-      for (CXFA_Node* pTemplateChild =
-               pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-           pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                               XFA_NODEITEM_NextSibling)) {
-        if (XFA_NeedGenerateForm(pTemplateChild)) {
-          XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode,
-                                              pTemplateChild, bRecursive);
-        }
-      }
-    }
-    pExistingNode->SetFlag(XFA_NODEFLAG_Initialized);
-    return pExistingNode;
-  }
-  CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE);
-  pFormParent->InsertChild(pNewNode, NULL);
-  if (bRecursive) {
-    for (CXFA_Node* pTemplateChild =
-             pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-         pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                             XFA_NODEITEM_NextSibling)) {
-      if (XFA_NeedGenerateForm(pTemplateChild)) {
-        CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(TRUE);
-        pNewNode->InsertChild(pNewChild, NULL);
-      }
-    }
-  }
-  return pNewNode;
-}
-static CXFA_Node* XFA_NodeMerge_CloneOrMergeInstanceManager(
-    CXFA_Document* pDocument,
-    CXFA_Node* pFormParent,
-    CXFA_Node* pTemplateNode,
-    CXFA_NodeArray& subforms) {
-  CFX_WideStringC wsSubformName = pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
-  CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName;
-  FX_DWORD dwInstNameHash =
-      FX_HashCode_String_GetW(wsInstMgrNodeName, wsInstMgrNodeName.GetLength());
-  CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
-      pDocument, XFA_ELEMENT_InstanceManager, dwInstNameHash, pFormParent);
-  if (pExistingNode) {
-    FX_DWORD dwNameHash = pTemplateNode->GetNameHash();
-    for (CXFA_Node* pNode =
-             pExistingNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-         pNode;) {
-      XFA_ELEMENT eCurType = pNode->GetClassID();
-      if (eCurType == XFA_ELEMENT_InstanceManager) {
-        break;
-      }
-      if ((eCurType != XFA_ELEMENT_Subform) &&
-          (eCurType != XFA_ELEMENT_SubformSet)) {
-        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-        continue;
-      }
-      if (dwNameHash != pNode->GetNameHash()) {
-        break;
-      }
-      CXFA_Node* pNextNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-      pFormParent->RemoveChild(pNode);
-      subforms.Add(pNode);
-      pNode = pNextNode;
-    }
-    pFormParent->RemoveChild(pExistingNode);
-    pFormParent->InsertChild(pExistingNode);
-    pExistingNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-    pExistingNode->SetTemplateNode(pTemplateNode);
-    return pExistingNode;
-  }
-  CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode(
-      XFA_XDPPACKET_Form, XFA_ELEMENT_InstanceManager);
-  FXSYS_assert(pNewNode);
-  wsInstMgrNodeName =
-      FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
-  pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName);
-  pFormParent->InsertChild(pNewNode, NULL);
-  pNewNode->SetTemplateNode(pTemplateNode);
-  return pNewNode;
-}
-static CXFA_Node* XFA_DataMerge_FindMatchingDataNode(
-    CXFA_Document* pDocument,
-    CXFA_Node* pTemplateNode,
-    CXFA_Node* pDataScope,
-    FX_BOOL& bAccessedDataDOM,
-    FX_BOOL bForceBind,
-    CXFA_NodeIteratorTemplate<CXFA_Node,
-                              CXFA_TraverseStrategy_XFAContainerNode>*
-        pIterator,
-    FX_BOOL& bSelfMatch,
-    XFA_ATTRIBUTEENUM& eBindMatch,
-    FX_BOOL bUpLevel = TRUE) {
-  FX_BOOL bOwnIterator = FALSE;
-  if (!pIterator) {
-    bOwnIterator = TRUE;
-    pIterator = new CXFA_NodeIteratorTemplate<
-        CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode);
-  }
-  CXFA_Node* pResult = NULL;
-  for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent();
-       pCurTemplateNode;) {
-    XFA_ELEMENT eMatchNodeType;
-    switch (pCurTemplateNode->GetClassID()) {
-      case XFA_ELEMENT_Subform:
-        eMatchNodeType = XFA_ELEMENT_DataGroup;
-        break;
-      case XFA_ELEMENT_Field: {
-        eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode)
-                             ? XFA_ELEMENT_DataGroup
-                             : XFA_ELEMENT_DataValue;
-      } break;
-      case XFA_ELEMENT_ExclGroup:
-        eMatchNodeType = XFA_ELEMENT_DataValue;
-        break;
-      default:
-        pCurTemplateNode = pIterator->MoveToNext();
-        continue;
-    }
-    CXFA_Node* pTemplateNodeOccur =
-        pCurTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
-    int32_t iMin, iMax, iInit;
-    if (pTemplateNodeOccur &&
-        XFA_GetOccurInfo(pTemplateNodeOccur, iMin, iMax, iInit) && iMax == 0) {
-      pCurTemplateNode = pIterator->MoveToNext();
-      continue;
-    }
-    CXFA_Node* pTemplateNodeBind =
-        pCurTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Bind);
-    XFA_ATTRIBUTEENUM eMatch =
-        pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
-                          : XFA_ATTRIBUTEENUM_Once;
-    eBindMatch = eMatch;
-    switch (eMatch) {
-      case XFA_ATTRIBUTEENUM_None:
-        pCurTemplateNode = pIterator->MoveToNext();
-        continue;
-      case XFA_ATTRIBUTEENUM_Global:
-        bAccessedDataDOM = TRUE;
-        if (!bForceBind) {
-          pCurTemplateNode = pIterator->MoveToNext();
-          continue;
-        }
-        if (eMatchNodeType == XFA_ELEMENT_DataValue ||
-            (eMatchNodeType == XFA_ELEMENT_DataGroup &&
-             XFA_FieldIsMultiListBox(pTemplateNodeBind))) {
-          CXFA_Node* pGlobalBindNode = XFA_DataMerge_FindGlobalDataNode(
-              pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
-              pDataScope, eMatchNodeType);
-          if (!pGlobalBindNode) {
-            pCurTemplateNode = pIterator->MoveToNext();
-            continue;
-          }
-          pResult = pGlobalBindNode;
-          break;
-        }
-      case XFA_ATTRIBUTEENUM_Once: {
-        bAccessedDataDOM = TRUE;
-        CXFA_Node* pOnceBindNode = XFA_DataMerge_FindOnceDataNode(
-            pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
-            pDataScope, eMatchNodeType);
-        if (!pOnceBindNode) {
-          pCurTemplateNode = pIterator->MoveToNext();
-          continue;
-        }
-        pResult = pOnceBindNode;
-      } break;
-      case XFA_ATTRIBUTEENUM_DataRef: {
-        bAccessedDataDOM = TRUE;
-        CXFA_Node* pDataRefBindNode = XFA_DataMerge_FindDataRefDataNode(
-            pDocument, pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref),
-            pDataScope, eMatchNodeType, pTemplateNode, bForceBind, bUpLevel);
-        if (pDataRefBindNode &&
-            pDataRefBindNode->GetClassID() == eMatchNodeType) {
-          pResult = pDataRefBindNode;
-        }
-        if (!pResult) {
-          pCurTemplateNode = pIterator->SkipChildrenAndMoveToNext();
-          continue;
-        }
-      } break;
-      default:
-        break;
-    }
-    if (pCurTemplateNode == pTemplateNode && pResult) {
-      bSelfMatch = TRUE;
-    }
-    break;
-  }
-  if (bOwnIterator) {
-    delete pIterator;
-  }
-  return pResult;
-}
-static void XFA_DataMerge_SortRecurseRecord(
-    CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord>& rgRecords,
-    CXFA_Node* pDataScope,
-    FX_BOOL bChoiceMode = FALSE) {
-  int32_t iCount = rgRecords.GetSize();
-  CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgResultRecord;
-  for (CXFA_Node* pChildNode = pDataScope->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pChildNode;
-       pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    for (int32_t i = 0; i < iCount; i++) {
-      CXFA_Node* pNode = rgRecords[i].pDataChild;
-      if (pChildNode == pNode) {
-        XFA_DataMerge_RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild,
-                                                  pNode};
-        rgResultRecord.Add(sNewRecord);
-        rgRecords.RemoveAt(i);
-        iCount--;
-        break;
-      }
-    }
-    if (bChoiceMode && rgResultRecord.GetSize() > 0) {
-      break;
-    }
-  }
-  if (rgResultRecord.GetSize() > 0) {
-    if (!bChoiceMode) {
-      for (int32_t i = 0; i < iCount; i++) {
-        XFA_DataMerge_RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild,
-                                                  rgRecords[i].pDataChild};
-        rgResultRecord.Add(sNewRecord);
-      }
-    }
-    rgRecords.RemoveAll();
-    rgRecords.Copy(rgResultRecord);
-  }
-}
-static CXFA_Node* XFA_DataMerge_CopyContainer_SubformSet(
-    CXFA_Document* pDocument,
-    CXFA_Node* pTemplateNode,
-    CXFA_Node* pFormParentNode,
-    CXFA_Node* pDataScope,
-    FX_BOOL bOneInstance,
-    FX_BOOL bDataMerge) {
-  XFA_ELEMENT eElement = pTemplateNode->GetClassID();
-  CXFA_Node* pOccurNode = NULL;
-  CXFA_Node* pFirstInstance = NULL;
-  FX_BOOL bUseInstanceManager =
-      pFormParentNode->GetClassID() != XFA_ELEMENT_Area;
-  CXFA_Node* pInstMgrNode = NULL;
-  CXFA_NodeArray subformArray;
-  CXFA_NodeArray* pSearchArray = NULL;
-  if (!bOneInstance &&
-      (eElement == XFA_ELEMENT_SubformSet || eElement == XFA_ELEMENT_Subform)) {
-    pInstMgrNode =
-        bUseInstanceManager
-            ? XFA_NodeMerge_CloneOrMergeInstanceManager(
-                  pDocument, pFormParentNode, pTemplateNode, subformArray)
-            : NULL;
-    if (CXFA_Node* pOccurTemplateNode =
-            pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur)) {
-      pOccurNode = pInstMgrNode
-                       ? XFA_NodeMerge_CloneOrMergeContainer(
-                             pDocument, pInstMgrNode, pOccurTemplateNode, FALSE)
-                       : pOccurTemplateNode;
-    } else if (pInstMgrNode) {
-      pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
-      if (pOccurNode) {
-        pOccurNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-      }
-    }
-    if (pInstMgrNode) {
-      pInstMgrNode->SetFlag(XFA_NODEFLAG_Initialized);
-      pSearchArray = &subformArray;
-      if (pFormParentNode->GetClassID() == XFA_ELEMENT_PageArea) {
-        bOneInstance = TRUE;
-        if (subformArray.GetSize() < 1) {
-          pSearchArray = NULL;
-        }
-      } else if ((pTemplateNode->GetNameHash() == 0) &&
-                 (subformArray.GetSize() < 1)) {
-        pSearchArray = NULL;
-      }
-    }
-  }
-  int32_t iMax = 1, iInit = 1, iMin = 1;
-  if (!bOneInstance) {
-    XFA_GetOccurInfo(pOccurNode, iMin, iMax, iInit);
-  }
-  XFA_ATTRIBUTEENUM eRelation =
-      eElement == XFA_ELEMENT_SubformSet
-          ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation)
-          : XFA_ATTRIBUTEENUM_Ordered;
-  int32_t iCurRepeatIndex = 0;
-  XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None;
-  if (bDataMerge) {
-    CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
-        sNodeIterator(pTemplateNode);
-    FX_BOOL bAccessedDataDOM = FALSE;
-    if (eElement == XFA_ELEMENT_SubformSet || eElement == XFA_ELEMENT_Area) {
-      sNodeIterator.MoveToNext();
-    } else {
-      CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray;
-      CXFA_NodeArray subformArray;
-      for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
-        FX_BOOL bSelfMatch = FALSE;
-        XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
-        CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode(
-            pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE,
-            &sNodeIterator, bSelfMatch, eBindMatch);
-        if (!pDataNode || sNodeIterator.GetCurrent() != pTemplateNode) {
-          break;
-        }
-        eParentBindMatch = eBindMatch;
-        CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
-        if (!pFirstInstance) {
-          pFirstInstance = pSubformNode;
-        }
-        XFA_DataMerge_CreateDataBinding(pSubformNode, pDataNode);
-        FXSYS_assert(pSubformNode);
-        subformMapArray.SetAt(pSubformNode, pDataNode);
-        subformArray.Add(pSubformNode);
-      }
-      subformMapArray.GetStartPosition();
-      for (int32_t iIndex = 0; iIndex < subformArray.GetSize(); iIndex++) {
-        CXFA_Node* pSubform = subformArray[iIndex];
-        CXFA_Node* pDataNode =
-            reinterpret_cast<CXFA_Node*>(subformMapArray.GetValueAt(pSubform));
-        for (CXFA_Node* pTemplateChild =
-                 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-             pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                                 XFA_NODEITEM_NextSibling)) {
-          if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
-            XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform,
-                                                pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
-            pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform,
-                                               pDataNode, FALSE, TRUE, FALSE);
-          }
-        }
-      }
-      subformMapArray.RemoveAll();
-    }
-    for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
-      FX_BOOL bSelfMatch = FALSE;
-      XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
-      if (!XFA_DataMerge_FindMatchingDataNode(
-              pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE,
-              &sNodeIterator, bSelfMatch, eBindMatch)) {
-        break;
-      }
-      if (eBindMatch == XFA_ATTRIBUTEENUM_DataRef &&
-          eParentBindMatch == XFA_ATTRIBUTEENUM_DataRef) {
-        break;
-      }
-      if (eRelation == XFA_ATTRIBUTEENUM_Choice ||
-          eRelation == XFA_ATTRIBUTEENUM_Unordered) {
-        CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
-        FXSYS_assert(pSubformSetNode);
-        if (!pFirstInstance) {
-          pFirstInstance = pSubformSetNode;
-        }
-        CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgItemMatchList;
-        CFX_ArrayTemplate<CXFA_Node*> rgItemUnmatchList;
-        for (CXFA_Node* pTemplateChild =
-                 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-             pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                                 XFA_NODEITEM_NextSibling)) {
-          if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
-            XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
-                                                pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
-            CXFA_Node* pDataMatch;
-            bSelfMatch = FALSE;
-            eBindMatch = XFA_ATTRIBUTEENUM_None;
-            if (eRelation != XFA_ATTRIBUTEENUM_Ordered &&
-                (pDataMatch = XFA_DataMerge_FindMatchingDataNode(
-                     pDocument, pTemplateChild, pDataScope, bAccessedDataDOM,
-                     FALSE, NULL, bSelfMatch, eBindMatch))) {
-              XFA_DataMerge_RecurseRecord sNewRecord = {pTemplateChild,
-                                                        pDataMatch};
-              if (bSelfMatch) {
-                rgItemMatchList.InsertAt(0, sNewRecord);
-              } else {
-                rgItemMatchList.Add(sNewRecord);
-              }
-            } else {
-              rgItemUnmatchList.Add(pTemplateChild);
-            }
-          }
-        }
-        switch (eRelation) {
-          case XFA_ATTRIBUTEENUM_Choice: {
-            FXSYS_assert(rgItemMatchList.GetSize());
-            XFA_DataMerge_SortRecurseRecord(rgItemMatchList, pDataScope, TRUE);
-            pDocument->DataMerge_CopyContainer(
-                rgItemMatchList[0].pTemplateChild, pSubformSetNode, pDataScope);
-          } break;
-          case XFA_ATTRIBUTEENUM_Unordered: {
-            if (rgItemMatchList.GetSize()) {
-              XFA_DataMerge_SortRecurseRecord(rgItemMatchList, pDataScope);
-              for (int32_t i = 0, count = rgItemMatchList.GetSize(); i < count;
-                   i++) {
-                pDocument->DataMerge_CopyContainer(
-                    rgItemMatchList[i].pTemplateChild, pSubformSetNode,
-                    pDataScope);
-              }
-            }
-            for (int32_t i = 0, count = rgItemUnmatchList.GetSize(); i < count;
-                 i++) {
-              pDocument->DataMerge_CopyContainer(rgItemUnmatchList[i],
-                                                 pSubformSetNode, pDataScope);
-            }
-          } break;
-          default:
-            break;
-        }
-      } else {
-        CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
-        FXSYS_assert(pSubformSetNode);
-        if (!pFirstInstance) {
-          pFirstInstance = pSubformSetNode;
-        }
-        for (CXFA_Node* pTemplateChild =
-                 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-             pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                                 XFA_NODEITEM_NextSibling)) {
-          if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
-            XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
-                                                pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
-            pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
-                                               pDataScope);
-          }
-        }
-      }
-    }
-    if (iCurRepeatIndex == 0 && bAccessedDataDOM == FALSE) {
-      int32_t iLimit = iMax;
-      if (pInstMgrNode && pTemplateNode->GetNameHash() == 0) {
-        iLimit = subformArray.GetSize();
-        if (iLimit < iMin) {
-          iLimit = iInit;
-        }
-      }
-      for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) {
-        if (pInstMgrNode) {
-          if (pSearchArray && pSearchArray->GetSize() < 1) {
-            if (pTemplateNode->GetNameHash() != 0) {
-              break;
-            }
-            pSearchArray = NULL;
-          }
-        } else if (!XFA_DataMerge_FindFormDOMInstance(
-                       pDocument, pTemplateNode->GetClassID(),
-                       pTemplateNode->GetNameHash(), pFormParentNode)) {
-          break;
-        }
-        CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
-        FXSYS_assert(pSubformNode);
-        if (!pFirstInstance) {
-          pFirstInstance = pSubformNode;
-        }
-        for (CXFA_Node* pTemplateChild =
-                 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-             pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                                 XFA_NODEITEM_NextSibling)) {
-          if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
-            XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformNode,
-                                                pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
-            pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformNode,
-                                               pDataScope);
-          }
-        }
-      }
-    }
-  }
-  int32_t iMinimalLimit = iCurRepeatIndex == 0 ? iInit : iMin;
-  for (; iCurRepeatIndex < iMinimalLimit; iCurRepeatIndex++) {
-    CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-        pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
-    FXSYS_assert(pSubformSetNode);
-    if (!pFirstInstance) {
-      pFirstInstance = pSubformSetNode;
-    }
-    FX_BOOL bFound = FALSE;
-    for (CXFA_Node* pTemplateChild =
-             pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-         pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                             XFA_NODEITEM_NextSibling)) {
-      if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
-        XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
-                                            pTemplateChild, TRUE);
-      } else if (pTemplateChild->GetObjectType() ==
-                 XFA_OBJECTTYPE_ContainerNode) {
-        if (bFound && eRelation == XFA_ATTRIBUTEENUM_Choice) {
-          continue;
-        }
-        pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
-                                           pDataScope, FALSE, bDataMerge);
-        bFound = TRUE;
-      }
-    }
-  }
-  return pFirstInstance;
-}
-static CXFA_Node* XFA_DataMerge_CopyContainer_Field(CXFA_Document* pDocument,
-                                                    CXFA_Node* pTemplateNode,
-                                                    CXFA_Node* pFormNode,
-                                                    CXFA_Node* pDataScope,
-                                                    FX_BOOL bDataMerge,
-                                                    FX_BOOL bUpLevel = TRUE) {
-  CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer(
-      pDocument, pFormNode, pTemplateNode, FALSE);
-  FXSYS_assert(pFieldNode);
-  for (CXFA_Node* pTemplateChildNode =
-           pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem(
-                               XFA_NODEITEM_NextSibling)) {
-    if (XFA_NeedGenerateForm(pTemplateChildNode)) {
-      XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode,
-                                          pTemplateChildNode, TRUE);
-    } else if (pTemplateNode->GetClassID() == XFA_ELEMENT_ExclGroup &&
-               pTemplateChildNode->IsContainerNode()) {
-      if (pTemplateChildNode->GetClassID() == XFA_ELEMENT_Field) {
-        XFA_DataMerge_CopyContainer_Field(pDocument, pTemplateChildNode,
-                                          pFieldNode, NULL, FALSE);
-      }
-    }
-  }
-  if (bDataMerge) {
-    FX_BOOL bAccessedDataDOM = FALSE;
-    FX_BOOL bSelfMatch = FALSE;
-    XFA_ATTRIBUTEENUM eBindMatch;
-    CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode(
-        pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, NULL,
-        bSelfMatch, eBindMatch, bUpLevel);
-    if (pDataNode) {
-      XFA_DataMerge_CreateDataBinding(pFieldNode, pDataNode);
-    }
-  } else {
-    XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFieldNode);
-  }
-  return pFieldNode;
-}
-CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
-                                                  CXFA_Node* pFormNode,
-                                                  CXFA_Node* pDataScope,
-                                                  FX_BOOL bOneInstance,
-                                                  FX_BOOL bDataMerge,
-                                                  FX_BOOL bUpLevel) {
-  switch (pTemplateNode->GetClassID()) {
-    case XFA_ELEMENT_SubformSet:
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_PageArea:
-      return XFA_DataMerge_CopyContainer_SubformSet(
-          this, pTemplateNode, pFormNode, pDataScope, bOneInstance, bDataMerge);
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_Field:
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_ContentArea:
-      return XFA_DataMerge_CopyContainer_Field(
-          this, pTemplateNode, pFormNode, pDataScope, bDataMerge, bUpLevel);
-    case XFA_ELEMENT_PageSet:
-      break;
-    case XFA_ELEMENT_Variables:
-      break;
-    default:
-      FXSYS_assert(FALSE);
-      break;
-  }
-  return NULL;
-}
-
-static void XFA_DataMerge_UpdateBindingRelations(CXFA_Document* pDocument,
-                                                 CXFA_Node* pFormNode,
-                                                 CXFA_Node* pDataScope,
-                                                 FX_BOOL bDataRef,
-                                                 FX_BOOL bParentDataRef) {
-  FX_BOOL bMatchRef = TRUE;
-  XFA_ELEMENT eClassID = pFormNode->GetClassID();
-  CXFA_Node* pDataNode = pFormNode->GetBindData();
-  if (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup ||
-      eClassID == XFA_ELEMENT_Field) {
-    CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
-    CXFA_Node* pTemplateNodeBind =
-        pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Bind)
-                      : NULL;
-    XFA_ATTRIBUTEENUM eMatch =
-        pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
-                          : XFA_ATTRIBUTEENUM_Once;
-    switch (eMatch) {
-      case XFA_ATTRIBUTEENUM_None:
-        if (!bDataRef || bParentDataRef) {
-          XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
-        }
-        break;
-      case XFA_ATTRIBUTEENUM_Once:
-        if (!bDataRef || bParentDataRef) {
-          if (!pDataNode) {
-            if (pFormNode->GetNameHash() != 0 &&
-                pFormNode->GetEnum(XFA_ATTRIBUTE_Scope) !=
-                    XFA_ATTRIBUTEENUM_None) {
-              XFA_ELEMENT eDataNodeType = (eClassID == XFA_ELEMENT_Subform ||
-                                           XFA_FieldIsMultiListBox(pFormNode))
-                                              ? XFA_ELEMENT_DataGroup
-                                              : XFA_ELEMENT_DataValue;
-              pDataNode = XFA_DataDescription_MaybeCreateDataNode(
-                  pDocument, pDataScope, eDataNodeType,
-                  pFormNode->GetCData(XFA_ATTRIBUTE_Name));
-              if (pDataNode) {
-                XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE);
-              }
-            }
-            if (!pDataNode) {
-              XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
-            }
-          } else {
-            CXFA_Node* pDataParent =
-                pDataNode->GetNodeItem(XFA_NODEITEM_Parent);
-            if (pDataParent != pDataScope) {
-              FXSYS_assert(pDataParent);
-              pDataParent->RemoveChild(pDataNode);
-              pDataScope->InsertChild(pDataNode);
-            }
-          }
-        }
-        break;
-      case XFA_ATTRIBUTEENUM_Global:
-        if (!bDataRef || bParentDataRef) {
-          FX_DWORD dwNameHash = pFormNode->GetNameHash();
-          if (dwNameHash != 0 && !pDataNode) {
-            pDataNode = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash);
-            if (!pDataNode) {
-              XFA_ELEMENT eDataNodeType = (eClassID == XFA_ELEMENT_Subform ||
-                                           XFA_FieldIsMultiListBox(pFormNode))
-                                              ? XFA_ELEMENT_DataGroup
-                                              : XFA_ELEMENT_DataValue;
-              CXFA_Node* pRecordNode =
-                  ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
-              pDataNode = XFA_DataDescription_MaybeCreateDataNode(
-                  pDocument, pRecordNode, eDataNodeType,
-                  pFormNode->GetCData(XFA_ATTRIBUTE_Name));
-              if (pDataNode) {
-                XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE);
-                XFA_DataMerge_RegisterGlobalBinding(
-                    pDocument, pFormNode->GetNameHash(), pDataNode);
-              }
-            } else {
-              XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode);
-            }
-          }
-          if (!pDataNode) {
-            XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
-          }
-        }
-        break;
-      case XFA_ATTRIBUTEENUM_DataRef: {
-        bMatchRef = bDataRef;
-        bParentDataRef = TRUE;
-        if (!pDataNode && bDataRef) {
-          CFX_WideStringC wsRef =
-              pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref);
-          FX_DWORD dFlags =
-              XFA_RESOLVENODE_Children | XFA_RESOLVENODE_CreateNode;
-          XFA_RESOLVENODE_RS rs;
-          pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs,
-                                                        dFlags, pTemplateNode);
-          CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL;
-          pDataNode = ToNode(pObject);
-          if (pDataNode) {
-            XFA_DataMerge_CreateDataBinding(
-                pFormNode, pDataNode,
-                rs.dwFlags == XFA_RESOVENODE_RSTYPE_ExistNodes);
-          } else {
-            XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
-          }
-        }
-      } break;
-      default:
-        break;
-    }
-  }
-  if (bMatchRef &&
-      (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_SubformSet ||
-       eClassID == XFA_ELEMENT_Area || eClassID == XFA_ELEMENT_PageArea ||
-       eClassID == XFA_ELEMENT_PageSet)) {
-    for (CXFA_Node* pFormChild =
-             pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-         pFormChild;
-         pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pFormChild->GetObjectType() != XFA_OBJECTTYPE_ContainerNode) {
-        continue;
-      }
-      if (pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-        continue;
-      }
-      XFA_DataMerge_UpdateBindingRelations(pDocument, pFormChild,
-                                           pDataNode ? pDataNode : pDataScope,
-                                           bDataRef, bParentDataRef);
-    }
-  }
-}
-CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode) {
-  for (CXFA_Node* pRootBoundNode = pParentFormNode;
-       pRootBoundNode &&
-       pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode;
-       pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
-    CXFA_Node* pDataScope = pRootBoundNode->GetBindData();
-    if (pDataScope) {
-      return pDataScope;
-    }
-  }
-  return ToNode(
-      pParentFormNode->GetDocument()->GetXFAObject(XFA_HASHCODE_Data));
-}
-void CXFA_Document::DataMerge_UpdateBindingRelations(
-    CXFA_Node* pFormUpdateRoot) {
-  CXFA_Node* pDataScope = XFA_DataMerge_FindDataScope(
-      pFormUpdateRoot->GetNodeItem(XFA_NODEITEM_Parent));
-  if (!pDataScope) {
-    return;
-  }
-  XFA_DataMerge_UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, FALSE,
-                                       FALSE);
-  XFA_DataMerge_UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, TRUE,
-                                       FALSE);
-}
-CXFA_Node* CXFA_Document::GetNotBindNode(CXFA_ObjArray& arrayNodes) {
-  for (int32_t i = 0; i < arrayNodes.GetSize(); i++) {
-    CXFA_Node* pNode = arrayNodes[i]->AsNode();
-    if (pNode && !pNode->HasBindItem())
-      return pNode;
-  }
-  return nullptr;
-}
-void CXFA_Document::DoDataMerge() {
-  CXFA_Node* pDatasetsRoot = ToNode(GetXFAObject(XFA_HASHCODE_Datasets));
-  if (!pDatasetsRoot) {
-    IFDE_XMLElement* pDatasetsXMLNode =
-        IFDE_XMLElement::Create(FX_WSTRC(L"xfa:datasets"));
-    FXSYS_assert(pDatasetsXMLNode);
-    pDatasetsXMLNode->SetString(
-        FX_WSTRC(L"xmlns:xfa"),
-        FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"));
-    pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel);
-    pDatasetsRoot->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"datasets"));
-    m_pRootNode->GetXMLMappingNode()->InsertChildNode(pDatasetsXMLNode);
-    m_pRootNode->InsertChild(pDatasetsRoot);
-    pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode);
-  }
-  CXFA_Node *pDataRoot = NULL, *pDDRoot = NULL;
-  CFX_WideString wsDatasetsURI;
-  pDatasetsRoot->TryNamespace(wsDatasetsURI);
-  for (CXFA_Node* pChildNode =
-           pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pChildNode;
-       pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pChildNode->GetClassID() != XFA_ELEMENT_DataGroup) {
-      continue;
-    }
-    CFX_WideString wsNamespaceURI;
-    if (!pDDRoot && pChildNode->GetNameHash() == XFA_HASHCODE_DataDescription) {
-      if (!pChildNode->TryNamespace(wsNamespaceURI)) {
-        continue;
-      }
-      if (wsNamespaceURI ==
-          FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
-        pDDRoot = pChildNode;
-      }
-    } else if (!pDataRoot && pChildNode->GetNameHash() == XFA_HASHCODE_Data) {
-      if (!pChildNode->TryNamespace(wsNamespaceURI)) {
-        continue;
-      }
-      if (wsNamespaceURI == wsDatasetsURI) {
-        pDataRoot = pChildNode;
-      }
-    }
-    if (pDataRoot && pDDRoot) {
-      break;
-    }
-  }
-  if (!pDataRoot) {
-    IFDE_XMLElement* pDataRootXMLNode =
-        IFDE_XMLElement::Create(FX_WSTRC(L"xfa:data"));
-    FXSYS_assert(pDataRootXMLNode);
-    pDataRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
-    pDataRoot->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"data"));
-    pDataRoot->SetXMLMappingNode(pDataRootXMLNode);
-    pDatasetsRoot->InsertChild(pDataRoot);
-  }
-  CXFA_Node* pDataTopLevel =
-      pDataRoot->GetFirstChildByClass(XFA_ELEMENT_DataGroup);
-  FX_DWORD dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0;
-  CXFA_Node* pTemplateRoot =
-      m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template);
-  if (!pTemplateRoot) {
-    return;
-  }
-  CXFA_Node* pTemplateChosen =
-      dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash) : NULL;
-  if (!pTemplateChosen ||
-      pTemplateChosen->GetClassID() != XFA_ELEMENT_Subform) {
-    pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform);
-  }
-  if (!pTemplateChosen) {
-    return;
-  }
-  CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Form);
-  FX_BOOL bEmptyForm = FALSE;
-  if (!pFormRoot) {
-    bEmptyForm = TRUE;
-    pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
-    FXSYS_assert(pFormRoot);
-    pFormRoot->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"form"));
-    m_pRootNode->InsertChild(pFormRoot, NULL);
-  } else {
-    CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
-        sIterator(pFormRoot);
-    for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
-         pNode = sIterator.MoveToNext()) {
-      pNode->SetFlag(XFA_NODEFLAG_UnusedNode);
-    }
-  }
-  CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-      this, pFormRoot, pTemplateChosen, FALSE);
-  FXSYS_assert(pSubformSetNode);
-  if (!pDataTopLevel) {
-    CFX_WideStringC wsFormName = pSubformSetNode->GetCData(XFA_ATTRIBUTE_Name);
-    CFX_WideString wsDataTopLevelName =
-        wsFormName.IsEmpty() ? FX_WSTRC(L"form") : wsFormName;
-    IFDE_XMLElement* pDataTopLevelXMLNode =
-        IFDE_XMLElement::Create(wsDataTopLevelName);
-    FXSYS_assert(pDataTopLevelXMLNode);
-    pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
-    pDataTopLevel->SetCData(XFA_ATTRIBUTE_Name, wsDataTopLevelName);
-    pDataTopLevel->SetXMLMappingNode(pDataTopLevelXMLNode);
-    CXFA_Node* pBeforeNode = pDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
-    pDataRoot->InsertChild(pDataTopLevel, pBeforeNode);
-  }
-  FXSYS_assert(pDataTopLevel);
-  XFA_DataMerge_CreateDataBinding(pSubformSetNode, pDataTopLevel);
-  for (CXFA_Node* pTemplateChild =
-           pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pTemplateChild;
-       pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (XFA_NeedGenerateForm(pTemplateChild)) {
-      XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild,
-                                          TRUE);
-    } else if (pTemplateChild->GetObjectType() ==
-               XFA_OBJECTTYPE_ContainerNode) {
-      DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel);
-    }
-  }
-  if (pDDRoot) {
-    XFA_DataDescription_UpdateDataRelation(pDataRoot, pDDRoot);
-  }
-  DataMerge_UpdateBindingRelations(pSubformSetNode);
-  CXFA_Node* pPageSetNode =
-      pSubformSetNode->GetFirstChildByClass(XFA_ELEMENT_PageSet);
-  while (pPageSetNode) {
-    m_pPendingPageSet.Add(pPageSetNode);
-    CXFA_Node* pNextPageSetNode =
-        pPageSetNode->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
-    pSubformSetNode->RemoveChild(pPageSetNode);
-    pPageSetNode = pNextPageSetNode;
-  }
-  if (!bEmptyForm) {
-    CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
-        sIterator(pFormRoot);
-    CXFA_Node* pNode = sIterator.MoveToNext();
-    while (pNode) {
-      if (pNode->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-        if (pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode ||
-            pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
-          CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
-          pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
-          pNode = pNext;
-        } else {
-          pNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-          pNode->SetFlag(XFA_NODEFLAG_Initialized);
-          pNode = sIterator.MoveToNext();
-        }
-      } else {
-        pNode->SetFlag(XFA_NODEFLAG_Initialized);
-        pNode = sIterator.MoveToNext();
-      }
-    }
-  }
-}
-void CXFA_Document::DoDataRemerge(FX_BOOL bDoDataMerge) {
-  CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form));
-  if (pFormRoot) {
-    while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-      pFormRoot->RemoveChild(pNode);
-    }
-    pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
-  }
-  XFA_DataMerge_ClearGlobalBinding(this);
-  if (bDoDataMerge) {
-    DoDataMerge();
-  }
-  CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
-  pLayoutProcessor->SetForceReLayout(TRUE);
-}
diff --git a/xfa/src/fxfa/parser/xfa_document_datamerger_imp.h b/xfa/src/fxfa/parser/xfa_document_datamerger_imp.h
deleted file mode 100644
index 57ac6385b1..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_datamerger_imp.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_DATAMERGER_IMP_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_DATAMERGER_IMP_H_
-
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(
-    CXFA_Document* pDocument,
-    CXFA_Node* pFormParent,
-    CXFA_Node* pTemplateNode,
-    FX_BOOL bRecursive,
-    CXFA_NodeArray* pSubformArray = NULL);
-CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode);
-CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
-                                             XFA_ELEMENT eClassID,
-                                             FX_DWORD dwNameHash,
-                                             CXFA_Node* pFormParent);
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_DATAMERGER_IMP_H_
diff --git a/xfa/src/fxfa/parser/xfa_document_imp.cpp b/xfa/src/fxfa/parser/xfa_document_imp.cpp
deleted file mode 100644
index 980b4e4a3e..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_imp.cpp
+++ /dev/null
@@ -1,441 +0,0 @@
-// 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 "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_script_datawindow.h"
-#include "xfa/src/fxfa/parser/xfa_script_eventpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_hostpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_logpseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_Document::CXFA_Document(IXFA_DocParser* pParser)
-    : m_pParser(pParser),
-      m_pScriptContext(nullptr),
-      m_pLayoutProcessor(nullptr),
-      m_pRootNode(nullptr),
-      m_pLocalMgr(nullptr),
-      m_pScriptDataWindow(nullptr),
-      m_pScriptEvent(nullptr),
-      m_pScriptHost(nullptr),
-      m_pScriptLog(nullptr),
-      m_pScriptLayout(nullptr),
-      m_pScriptSignature(nullptr),
-      m_eCurVersionMode(XFA_VERSION_DEFAULT),
-      m_dwDocFlags(0) {
-  ASSERT(m_pParser);
-}
-CXFA_Document::~CXFA_Document() {
-  delete m_pRootNode;
-  PurgeNodes();
-}
-void CXFA_Document::ClearLayoutData() {
-  if (m_pLayoutProcessor) {
-    delete m_pLayoutProcessor;
-    m_pLayoutProcessor = NULL;
-  }
-  if (m_pScriptContext) {
-    m_pScriptContext->Release();
-    m_pScriptContext = NULL;
-  }
-  if (m_pLocalMgr) {
-    delete m_pLocalMgr;
-    m_pLocalMgr = NULL;
-  }
-  if (m_pScriptDataWindow) {
-    delete m_pScriptDataWindow;
-    m_pScriptDataWindow = NULL;
-  }
-  if (m_pScriptEvent) {
-    delete m_pScriptEvent;
-    m_pScriptEvent = NULL;
-  }
-  if (m_pScriptHost) {
-    delete m_pScriptHost;
-    m_pScriptHost = NULL;
-  }
-  if (m_pScriptLog) {
-    delete m_pScriptLog;
-    m_pScriptLog = NULL;
-  }
-  if (m_pScriptLayout) {
-    delete m_pScriptLayout;
-    m_pScriptLayout = NULL;
-  }
-  if (m_pScriptSignature) {
-    delete m_pScriptSignature;
-    m_pScriptSignature = NULL;
-  }
-}
-void CXFA_Document::SetRoot(CXFA_Node* pNewRoot) {
-  if (m_pRootNode) {
-    AddPurgeNode(m_pRootNode);
-  }
-  m_pRootNode = pNewRoot;
-  RemovePurgeNode(pNewRoot);
-}
-IXFA_Notify* CXFA_Document::GetNotify() const {
-  return m_pParser->GetNotify();
-}
-CXFA_Object* CXFA_Document::GetXFAObject(const CFX_WideStringC& wsNodeName) {
-  return GetXFAObject(
-      FX_HashCode_String_GetW(wsNodeName.GetPtr(), wsNodeName.GetLength()));
-}
-CXFA_Object* CXFA_Document::GetXFAObject(FX_DWORD dwNodeNameHash) {
-  switch (dwNodeNameHash) {
-    case XFA_HASHCODE_Data: {
-      CXFA_Node* pDatasetsNode = ToNode(GetXFAObject(XFA_HASHCODE_Datasets));
-      if (!pDatasetsNode) {
-        return NULL;
-      }
-      for (CXFA_Node* pDatasetsChild =
-               pDatasetsNode->GetFirstChildByClass(XFA_ELEMENT_DataGroup);
-           pDatasetsChild;
-           pDatasetsChild =
-               pDatasetsChild->GetNextSameClassSibling(XFA_ELEMENT_DataGroup)) {
-        if (pDatasetsChild->GetNameHash() != XFA_HASHCODE_Data) {
-          continue;
-        }
-        CFX_WideString wsNamespaceURI;
-        if (!pDatasetsChild->TryNamespace(wsNamespaceURI)) {
-          continue;
-        }
-        CFX_WideString wsDatasetsURI;
-        if (!pDatasetsNode->TryNamespace(wsDatasetsURI)) {
-          continue;
-        }
-        if (wsNamespaceURI == wsDatasetsURI) {
-          return pDatasetsChild;
-        }
-      }
-    }
-      return NULL;
-    case XFA_HASHCODE_Record: {
-      CXFA_Node* pData = ToNode(GetXFAObject(XFA_HASHCODE_Data));
-      return pData ? pData->GetFirstChildByClass(XFA_ELEMENT_DataGroup) : NULL;
-    }
-    case XFA_HASHCODE_DataWindow: {
-      if (m_pScriptDataWindow == NULL) {
-        m_pScriptDataWindow = new CScript_DataWindow(this);
-      }
-      return m_pScriptDataWindow;
-    }
-    case XFA_HASHCODE_Event: {
-      if (m_pScriptEvent == NULL) {
-        m_pScriptEvent = new CScript_EventPseudoModel(this);
-      }
-      return m_pScriptEvent;
-    }
-    case XFA_HASHCODE_Host: {
-      if (m_pScriptHost == NULL) {
-        m_pScriptHost = new CScript_HostPseudoModel(this);
-      }
-      return m_pScriptHost;
-    }
-    case XFA_HASHCODE_Log: {
-      if (m_pScriptLog == NULL) {
-        m_pScriptLog = new CScript_LogPseudoModel(this);
-      }
-      return m_pScriptLog;
-    }
-    case XFA_HASHCODE_Signature: {
-      if (m_pScriptSignature == NULL) {
-        m_pScriptSignature = new CScript_SignaturePseudoModel(this);
-      }
-      return m_pScriptSignature;
-    }
-    case XFA_HASHCODE_Layout: {
-      if (m_pScriptLayout == NULL) {
-        m_pScriptLayout = new CScript_LayoutPseudoModel(this);
-      }
-      return m_pScriptLayout;
-    }
-    default:
-      return m_pRootNode->GetFirstChildByName(dwNodeNameHash);
-  }
-}
-CXFA_Node* CXFA_Document::CreateNode(FX_DWORD dwPacket, XFA_ELEMENT eElement) {
-  return CreateNode(XFA_GetPacketByID(dwPacket), eElement);
-}
-CXFA_Node* CXFA_Document::CreateNode(const XFA_PACKETINFO* pPacket,
-                                     XFA_ELEMENT eElement) {
-  if (pPacket == NULL) {
-    return NULL;
-  }
-  const XFA_ELEMENTINFO* pElement = XFA_GetElementByID(eElement);
-  if (pElement && (pElement->dwPackets & pPacket->eName)) {
-    CXFA_Node* pNode = new CXFA_Node(this, pPacket->eName, pElement->eName);
-    if (pNode) {
-      AddPurgeNode(pNode);
-    }
-    return pNode;
-  }
-  return NULL;
-}
-void CXFA_Document::AddPurgeNode(CXFA_Node* pNode) {
-  m_rgPurgeNodes.Add(pNode);
-}
-FX_BOOL CXFA_Document::RemovePurgeNode(CXFA_Node* pNode) {
-  return m_rgPurgeNodes.RemoveKey(pNode);
-}
-void CXFA_Document::PurgeNodes() {
-  FX_POSITION psNode = m_rgPurgeNodes.GetStartPosition();
-  while (psNode) {
-    CXFA_Node* pNode;
-    m_rgPurgeNodes.GetNextAssoc(psNode, pNode);
-    delete pNode;
-  }
-  m_rgPurgeNodes.RemoveAll();
-}
-void CXFA_Document::SetFlag(FX_DWORD dwFlag, FX_BOOL bOn) {
-  if (bOn) {
-    m_dwDocFlags |= dwFlag;
-  } else {
-    m_dwDocFlags &= ~dwFlag;
-  }
-}
-FX_BOOL CXFA_Document::IsInteractive() {
-  if (m_dwDocFlags & XFA_DOCFLAG_HasInteractive) {
-    return m_dwDocFlags & XFA_DOCFLAG_Interactive;
-  }
-  CXFA_Node* pConfig = ToNode(GetXFAObject(XFA_HASHCODE_Config));
-  if (!pConfig) {
-    return FALSE;
-  }
-  CFX_WideString wsInteractive;
-  CXFA_Node* pPresent = pConfig->GetFirstChildByClass(XFA_ELEMENT_Present);
-  if (!pPresent) {
-    return FALSE;
-  }
-  CXFA_Node* pPDF = pPresent->GetFirstChildByClass(XFA_ELEMENT_Pdf);
-  if (!pPDF) {
-    return FALSE;
-  }
-  CXFA_Node* pInteractive = pPDF->GetChild(0, XFA_ELEMENT_Interactive);
-  if (pInteractive) {
-    m_dwDocFlags |= XFA_DOCFLAG_HasInteractive;
-    if (pInteractive->TryContent(wsInteractive) &&
-        wsInteractive == FX_WSTRC(L"1")) {
-      m_dwDocFlags |= XFA_DOCFLAG_Interactive;
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-CXFA_LocaleMgr* CXFA_Document::GetLocalMgr() {
-  if (!m_pLocalMgr) {
-    CFX_WideString wsLanguage;
-    GetParser()->GetNotify()->GetAppProvider()->GetLanguage(wsLanguage);
-    m_pLocalMgr = new CXFA_LocaleMgr(
-        ToNode(GetXFAObject(XFA_HASHCODE_LocaleSet)), wsLanguage);
-  }
-  return m_pLocalMgr;
-}
-IXFA_ScriptContext* CXFA_Document::InitScriptContext(FXJSE_HRUNTIME hRuntime) {
-  if (!m_pScriptContext) {
-    m_pScriptContext = XFA_ScriptContext_Create(this);
-  }
-  m_pScriptContext->Initialize(hRuntime);
-  return m_pScriptContext;
-}
-IXFA_ScriptContext* CXFA_Document::GetScriptContext() {
-  if (!m_pScriptContext) {
-    m_pScriptContext = XFA_ScriptContext_Create(this);
-  }
-  return m_pScriptContext;
-}
-XFA_VERSION CXFA_Document::RecognizeXFAVersionNumber(
-    CFX_WideString& wsTemplateNS) {
-  CFX_WideStringC wsTemplateURIPrefix =
-      XFA_GetPacketByIndex(XFA_PACKET_Template)->pURI;
-  FX_STRSIZE nPrefixLength = wsTemplateURIPrefix.GetLength();
-  if (CFX_WideStringC(wsTemplateNS, wsTemplateNS.GetLength()) !=
-      wsTemplateURIPrefix) {
-    return XFA_VERSION_UNKNOWN;
-  }
-  FX_STRSIZE nDotPos = wsTemplateNS.Find('.', nPrefixLength);
-  if (nDotPos == (FX_STRSIZE)-1) {
-    return XFA_VERSION_UNKNOWN;
-  }
-  int8_t iMajor =
-      FXSYS_wtoi(wsTemplateNS.Mid(nPrefixLength, nDotPos - nPrefixLength));
-  int8_t iMinor = FXSYS_wtoi(
-      wsTemplateNS.Mid(nDotPos + 1, wsTemplateNS.GetLength() - nDotPos - 2));
-  XFA_VERSION eVersion = (XFA_VERSION)((int32_t)iMajor * 100 + iMinor);
-  if (eVersion < XFA_VERSION_MIN || eVersion > XFA_VERSION_MAX) {
-    return XFA_VERSION_UNKNOWN;
-  }
-  m_eCurVersionMode = eVersion;
-  return eVersion;
-}
-CXFA_Node* CXFA_Document::GetNodeByID(CXFA_Node* pRoot,
-                                      const CFX_WideStringC& wsID) {
-  if (!pRoot || wsID.IsEmpty()) {
-    return NULL;
-  }
-  CXFA_NodeIterator sIterator(pRoot);
-  for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-       pNode = sIterator.MoveToNext()) {
-    CFX_WideStringC wsIDVal;
-    if (pNode->TryCData(XFA_ATTRIBUTE_Id, wsIDVal) && !wsIDVal.IsEmpty()) {
-      if (wsIDVal == wsID) {
-        return pNode;
-      }
-    }
-  }
-  return NULL;
-}
-static void XFA_ProtoMerge_MergeNodeRecurse(CXFA_Document* pDocument,
-                                            CXFA_Node* pDestNodeParent,
-                                            CXFA_Node* pProtoNode) {
-  CXFA_Node* pExistingNode = NULL;
-  for (CXFA_Node* pFormChild =
-           pDestNodeParent->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pFormChild;
-       pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pFormChild->GetClassID() == pProtoNode->GetClassID() &&
-        pFormChild->GetNameHash() == pProtoNode->GetNameHash() &&
-        pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-      pFormChild->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-      pExistingNode = pFormChild;
-      break;
-    }
-  }
-  if (pExistingNode) {
-    pExistingNode->SetTemplateNode(pProtoNode);
-    for (CXFA_Node* pTemplateChild =
-             pProtoNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-         pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
-                             XFA_NODEITEM_NextSibling)) {
-      XFA_ProtoMerge_MergeNodeRecurse(pDocument, pExistingNode, pTemplateChild);
-    }
-    return;
-  }
-  CXFA_Node* pNewNode = pProtoNode->Clone(TRUE);
-  pNewNode->SetTemplateNode(pProtoNode);
-  pDestNodeParent->InsertChild(pNewNode, NULL);
-}
-static void XFA_ProtoMerge_MergeNode(CXFA_Document* pDocument,
-                                     CXFA_Node* pDestNode,
-                                     CXFA_Node* pProtoNode) {
-  {
-    CXFA_NodeIterator sIterator(pDestNode);
-    for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-         pNode = sIterator.MoveToNext()) {
-      pNode->SetFlag(XFA_NODEFLAG_UnusedNode);
-    }
-  }
-  pDestNode->SetTemplateNode(pProtoNode);
-  for (CXFA_Node* pTemplateChild =
-           pProtoNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pTemplateChild;
-       pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_ProtoMerge_MergeNodeRecurse(pDocument, pDestNode, pTemplateChild);
-  }
-  {
-    CXFA_NodeIterator sIterator(pDestNode);
-    for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-         pNode = sIterator.MoveToNext()) {
-      pNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-    }
-  }
-}
-void CXFA_Document::DoProtoMerge() {
-  CXFA_Node* pTemplateRoot = ToNode(GetXFAObject(XFA_HASHCODE_Template));
-  if (!pTemplateRoot) {
-    return;
-  }
-  CFX_MapPtrTemplate<FX_DWORD, CXFA_Node*> mIDMap;
-  CXFA_NodeSet sUseNodes;
-  CXFA_NodeIterator sIterator(pTemplateRoot);
-  for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-       pNode = sIterator.MoveToNext()) {
-    CFX_WideStringC wsIDVal;
-    if (pNode->TryCData(XFA_ATTRIBUTE_Id, wsIDVal) && !wsIDVal.IsEmpty()) {
-      mIDMap[FX_HashCode_String_GetW(wsIDVal.GetPtr(), wsIDVal.GetLength())] =
-          pNode;
-    }
-    CFX_WideStringC wsUseVal;
-    if (pNode->TryCData(XFA_ATTRIBUTE_Use, wsUseVal) && !wsUseVal.IsEmpty()) {
-      sUseNodes.Add(pNode);
-    } else if (pNode->TryCData(XFA_ATTRIBUTE_Usehref, wsUseVal) &&
-               !wsUseVal.IsEmpty()) {
-      sUseNodes.Add(pNode);
-    }
-  }
-  FX_POSITION pos = sUseNodes.GetStartPosition();
-  while (pos) {
-    CXFA_Node* pUseHrefNode = NULL;
-    sUseNodes.GetNextAssoc(pos, pUseHrefNode);
-    CFX_WideString wsUseVal;
-    CFX_WideStringC wsURI, wsID, wsSOM;
-    if (pUseHrefNode->TryCData(XFA_ATTRIBUTE_Usehref, wsUseVal) &&
-        !wsUseVal.IsEmpty()) {
-      FX_STRSIZE uSharpPos = wsUseVal.Find('#');
-      if (uSharpPos < 0) {
-        wsURI = wsUseVal;
-      } else {
-        wsURI = CFX_WideStringC((const FX_WCHAR*)wsUseVal, uSharpPos);
-        FX_STRSIZE uLen = wsUseVal.GetLength();
-        if (uLen >= uSharpPos + 5 &&
-            CFX_WideStringC((const FX_WCHAR*)wsUseVal + uSharpPos, 5) ==
-                FX_WSTRC(L"#som(") &&
-            wsUseVal[uLen - 1] == ')') {
-          wsSOM = CFX_WideStringC((const FX_WCHAR*)wsUseVal + uSharpPos + 5,
-                                  uLen - 1 - uSharpPos - 5);
-        } else {
-          wsID = CFX_WideStringC((const FX_WCHAR*)wsUseVal + uSharpPos + 1,
-                                 uLen - uSharpPos - 1);
-        }
-      }
-    } else if (pUseHrefNode->TryCData(XFA_ATTRIBUTE_Use, wsUseVal) &&
-               !wsUseVal.IsEmpty()) {
-      if (wsUseVal[0] == '#') {
-        wsID = CFX_WideStringC((const FX_WCHAR*)wsUseVal + 1,
-                               wsUseVal.GetLength() - 1);
-      } else {
-        wsSOM =
-            CFX_WideStringC((const FX_WCHAR*)wsUseVal, wsUseVal.GetLength());
-      }
-    }
-    if (!wsURI.IsEmpty() && wsURI != FX_WSTRC(L".")) {
-      continue;
-    }
-    CXFA_Node* pProtoNode = NULL;
-    if (!wsSOM.IsEmpty()) {
-      FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
-                        XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
-                        XFA_RESOLVENODE_Siblings;
-      XFA_RESOLVENODE_RS resoveNodeRS;
-      int32_t iRet = m_pScriptContext->ResolveObjects(pUseHrefNode, wsSOM,
-                                                      resoveNodeRS, dwFlag);
-      if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
-        pProtoNode = resoveNodeRS.nodes[0]->AsNode();
-      }
-    } else if (!wsID.IsEmpty()) {
-      if (!mIDMap.Lookup(
-              FX_HashCode_String_GetW(wsID.GetPtr(), wsID.GetLength()),
-              pProtoNode)) {
-        continue;
-      }
-    }
-    if (!pProtoNode) {
-      continue;
-    }
-    XFA_ProtoMerge_MergeNode(this, pUseHrefNode, pProtoNode);
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_document_layout_imp.cpp b/xfa/src/fxfa/parser/xfa_document_layout_imp.cpp
deleted file mode 100644
index 2ac2bd6164..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_layout_imp.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-// 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/src/fxfa/parser/xfa_document_layout_imp.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_datamerger_imp.h"
-#include "xfa/src/fxfa/parser/xfa_layout_appadapter.h"
-#include "xfa/src/fxfa/parser/xfa_layout_itemlayout.h"
-#include "xfa/src/fxfa/parser/xfa_layout_pagemgr_new.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_LayoutProcessor* CXFA_Document::GetLayoutProcessor() {
-  if (!m_pLayoutProcessor) {
-    m_pLayoutProcessor = new CXFA_LayoutProcessor(this);
-    ASSERT(m_pLayoutProcessor);
-  }
-  return m_pLayoutProcessor;
-}
-IXFA_DocLayout* CXFA_Document::GetDocLayout() {
-  return GetLayoutProcessor();
-}
-CXFA_LayoutProcessor::CXFA_LayoutProcessor(CXFA_Document* pDocument)
-    : m_pDocument(pDocument),
-      m_pRootItemLayoutProcessor(NULL),
-      m_pLayoutPageMgr(NULL),
-      m_nProgressCounter(0),
-      m_bNeeLayout(TRUE) {}
-CXFA_LayoutProcessor::~CXFA_LayoutProcessor() {
-  ClearLayoutData();
-}
-CXFA_Document* CXFA_LayoutProcessor::GetDocument() const {
-  return m_pDocument;
-}
-int32_t CXFA_LayoutProcessor::StartLayout(FX_BOOL bForceRestart) {
-  if (!bForceRestart && !IsNeedLayout()) {
-    return 100;
-  }
-  if (m_pRootItemLayoutProcessor) {
-    delete m_pRootItemLayoutProcessor;
-    m_pRootItemLayoutProcessor = NULL;
-  }
-  m_nProgressCounter = 0;
-  CXFA_Node* pFormPacketNode =
-      ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
-  if (!pFormPacketNode) {
-    return -1;
-  }
-  CXFA_Node* pFormRoot =
-      pFormPacketNode->GetFirstChildByClass(XFA_ELEMENT_Subform);
-  if (!pFormRoot) {
-    return -1;
-  }
-  if (!m_pLayoutPageMgr) {
-    m_pLayoutPageMgr = new CXFA_LayoutPageMgr(this);
-  }
-  if (!m_pLayoutPageMgr->InitLayoutPage(pFormRoot)) {
-    return -1;
-  }
-  if (!m_pLayoutPageMgr->PrepareFirstPage(pFormRoot)) {
-    return -1;
-  }
-  m_pRootItemLayoutProcessor =
-      new CXFA_ItemLayoutProcessor(pFormRoot, m_pLayoutPageMgr);
-  m_nProgressCounter = 1;
-  return 0;
-}
-int32_t CXFA_LayoutProcessor::DoLayout(IFX_Pause* pPause) {
-  if (m_nProgressCounter < 1) {
-    return -1;
-  }
-  XFA_ItemLayoutProcessorResult eStatus;
-  CXFA_Node* pFormNode = m_pRootItemLayoutProcessor->GetFormNode();
-  FX_FLOAT fPosX = pFormNode->GetMeasure(XFA_ATTRIBUTE_X).ToUnit(XFA_UNIT_Pt);
-  FX_FLOAT fPosY = pFormNode->GetMeasure(XFA_ATTRIBUTE_Y).ToUnit(XFA_UNIT_Pt);
-  do {
-    FX_FLOAT fAvailHeight = m_pLayoutPageMgr->GetAvailHeight();
-    eStatus =
-        m_pRootItemLayoutProcessor->DoLayout(TRUE, fAvailHeight, fAvailHeight);
-    if (eStatus != XFA_ItemLayoutProcessorResult_Done) {
-      m_nProgressCounter++;
-    }
-    CXFA_ContentLayoutItem* pLayoutItem =
-        m_pRootItemLayoutProcessor->ExtractLayoutItem();
-    if (pLayoutItem) {
-      pLayoutItem->m_sPos = CFX_PointF(fPosX, fPosY);
-    }
-    m_pLayoutPageMgr->SubmitContentItem(pLayoutItem, eStatus);
-  } while (eStatus != XFA_ItemLayoutProcessorResult_Done &&
-           (!pPause || !pPause->NeedToPauseNow()));
-  if (eStatus == XFA_ItemLayoutProcessorResult_Done) {
-    m_pLayoutPageMgr->FinishPaginatedPageSets();
-    m_pLayoutPageMgr->SyncLayoutData();
-    m_bNeeLayout = FALSE;
-    m_rgChangedContainers.RemoveAll();
-  }
-  return 100 * (eStatus == XFA_ItemLayoutProcessorResult_Done
-                    ? m_nProgressCounter
-                    : m_nProgressCounter - 1) /
-         m_nProgressCounter;
-}
-FX_BOOL CXFA_LayoutProcessor::IncrementLayout() {
-  if (m_bNeeLayout) {
-    StartLayout(TRUE);
-    return DoLayout(NULL) == 100;
-  }
-  for (int32_t i = 0, c = m_rgChangedContainers.GetSize(); i < c; i++) {
-    CXFA_Node* pNode = m_rgChangedContainers[i];
-    CXFA_Node* pParentNode =
-        pNode->GetNodeItem(XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
-    if (!pParentNode) {
-      return FALSE;
-    }
-    if (!CXFA_ItemLayoutProcessor::IncrementRelayoutNode(this, pNode,
-                                                         pParentNode)) {
-      return FALSE;
-    }
-  }
-  m_rgChangedContainers.RemoveAll();
-  return TRUE;
-}
-int32_t CXFA_LayoutProcessor::CountPages() const {
-  return m_pLayoutPageMgr ? m_pLayoutPageMgr->GetPageCount() : 0;
-}
-IXFA_LayoutPage* CXFA_LayoutProcessor::GetPage(int32_t index) const {
-  return m_pLayoutPageMgr ? m_pLayoutPageMgr->GetPage(index) : NULL;
-}
-CXFA_LayoutItem* CXFA_LayoutProcessor::GetLayoutItem(CXFA_Node* pFormItem) {
-  return static_cast<CXFA_LayoutItem*>(
-      pFormItem->GetUserData(XFA_LAYOUTITEMKEY));
-}
-void CXFA_LayoutProcessor::AddChangedContainer(CXFA_Node* pContainer) {
-  if (m_rgChangedContainers.Find(pContainer) < 0) {
-    m_rgChangedContainers.Add(pContainer);
-  }
-}
-CXFA_ContainerLayoutItem* CXFA_LayoutProcessor::GetRootLayoutItem() const {
-  return m_pLayoutPageMgr ? m_pLayoutPageMgr->GetRootLayoutItem() : NULL;
-}
-void CXFA_LayoutProcessor::ClearLayoutData() {
-  if (m_pLayoutPageMgr) {
-    delete m_pLayoutPageMgr;
-    m_pLayoutPageMgr = NULL;
-  }
-  if (m_pRootItemLayoutProcessor) {
-    delete m_pRootItemLayoutProcessor;
-    m_pRootItemLayoutProcessor = NULL;
-  }
-  m_nProgressCounter = 0;
-}
-FX_BOOL CXFA_LayoutProcessor::IsNeedLayout() {
-  return m_bNeeLayout || m_rgChangedContainers.GetSize() > 0;
-}
-CXFA_LayoutItem::CXFA_LayoutItem(CXFA_Node* pNode, FX_BOOL bIsContentLayoutItem)
-    : m_pFormNode(pNode),
-      m_pParent(NULL),
-      m_pNextSibling(NULL),
-      m_pFirstChild(NULL),
-      m_bIsContentLayoutItem(bIsContentLayoutItem) {}
-CXFA_LayoutItem::~CXFA_LayoutItem() {}
-CXFA_ContainerLayoutItem::CXFA_ContainerLayoutItem(CXFA_Node* pNode)
-    : CXFA_LayoutItem(pNode, FALSE), m_pOldSubform(NULL) {}
-IXFA_DocLayout* CXFA_ContainerLayoutItem::GetLayout() const {
-  return m_pFormNode->GetDocument()->GetLayoutProcessor();
-}
-int32_t CXFA_ContainerLayoutItem::GetPageIndex() const {
-  return m_pFormNode->GetDocument()
-      ->GetLayoutProcessor()
-      ->GetLayoutPageMgr()
-      ->GetPageIndex(this);
-}
-void CXFA_ContainerLayoutItem::GetPageSize(CFX_SizeF& size) {
-  size.clear();
-  CXFA_Node* pMedium = m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Medium);
-  if (!pMedium)
-    return;
-
-  size = CFX_SizeF(pMedium->GetMeasure(XFA_ATTRIBUTE_Short).ToUnit(XFA_UNIT_Pt),
-                   pMedium->GetMeasure(XFA_ATTRIBUTE_Long).ToUnit(XFA_UNIT_Pt));
-  if (pMedium->GetEnum(XFA_ATTRIBUTE_Orientation) ==
-      XFA_ATTRIBUTEENUM_Landscape) {
-    size = CFX_SizeF(size.y, size.x);
-  }
-}
-CXFA_Node* CXFA_ContainerLayoutItem::GetMasterPage() const {
-  return m_pFormNode;
-}
-CXFA_ContentLayoutItem::CXFA_ContentLayoutItem(CXFA_Node* pNode)
-    : CXFA_LayoutItem(pNode, TRUE),
-      m_pPrev(NULL),
-      m_pNext(NULL),
-      m_dwStatus(0) {}
-CXFA_ContentLayoutItem::~CXFA_ContentLayoutItem() {
-  if (m_pFormNode->GetUserData(XFA_LAYOUTITEMKEY) == this) {
-    m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY, NULL);
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_document_layout_imp.h b/xfa/src/fxfa/parser/xfa_document_layout_imp.h
deleted file mode 100644
index c471588c97..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_layout_imp.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_LAYOUT_IMP_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_LAYOUT_IMP_H_
-
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-
-class CXFA_ItemLayoutProcessor;
-class CXFA_LayoutPageMgr;
-class CXFA_ContainerLayoutItem;
-
-class CXFA_LayoutProcessor : public IXFA_DocLayout {
- public:
-  CXFA_LayoutProcessor(CXFA_Document* pDocument);
-  ~CXFA_LayoutProcessor();
-  virtual CXFA_Document* GetDocument() const;
-  virtual int32_t StartLayout(FX_BOOL bForceRestart = FALSE);
-  virtual int32_t DoLayout(IFX_Pause* pPause = NULL);
-  virtual FX_BOOL IncrementLayout();
-  virtual int32_t CountPages() const;
-  virtual IXFA_LayoutPage* GetPage(int32_t index) const;
-  virtual CXFA_LayoutItem* GetLayoutItem(CXFA_Node* pFormItem);
-
-  void AddChangedContainer(CXFA_Node* pContainer);
-  void SetForceReLayout(FX_BOOL bForceRestart) { m_bNeeLayout = bForceRestart; }
-  CXFA_ContainerLayoutItem* GetRootLayoutItem() const;
-  CXFA_ItemLayoutProcessor* GetRootRootItemLayoutProcessor() {
-    return m_pRootItemLayoutProcessor;
-  }
-  CXFA_LayoutPageMgr* GetLayoutPageMgr() { return m_pLayoutPageMgr; }
-
- protected:
-  void ClearLayoutData();
-
-  FX_BOOL IsNeedLayout();
-
-  CXFA_Document* m_pDocument;
-  CXFA_ItemLayoutProcessor* m_pRootItemLayoutProcessor;
-  CXFA_LayoutPageMgr* m_pLayoutPageMgr;
-  CXFA_NodeArray m_rgChangedContainers;
-  uint32_t m_nProgressCounter;
-  FX_BOOL m_bNeeLayout;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_LAYOUT_IMP_H_
diff --git a/xfa/src/fxfa/parser/xfa_document_serialize.cpp b/xfa/src/fxfa/parser/xfa_document_serialize.cpp
deleted file mode 100644
index 66a9b75e0c..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_serialize.cpp
+++ /dev/null
@@ -1,590 +0,0 @@
-// 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/src/fxfa/parser/xfa_document_serialize.h"
-
-#include "xfa/src/fgas/crt/fgas_codepage.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-IXFA_PacketImport* IXFA_PacketImport::Create(CXFA_Document* pDocument) {
-  return new CXFA_DataImporter(pDocument);
-}
-CXFA_DataImporter::CXFA_DataImporter(CXFA_Document* pDocument)
-    : m_pDocument(pDocument) {
-  ASSERT(m_pDocument);
-}
-FX_BOOL CXFA_DataImporter::ImportData(IFX_FileRead* pDataDocument) {
-  IXFA_Parser* pDataDocumentParser = IXFA_Parser::Create(m_pDocument);
-  if (!pDataDocumentParser) {
-    return FALSE;
-  }
-  if (pDataDocumentParser->StartParse(pDataDocument, XFA_XDPPACKET_Datasets) !=
-      XFA_PARSESTATUS_Ready) {
-    pDataDocumentParser->Release();
-    return FALSE;
-  }
-  if (pDataDocumentParser->DoParse(NULL) < XFA_PARSESTATUS_Done) {
-    pDataDocumentParser->Release();
-    return FALSE;
-  }
-  CXFA_Node* pImportDataRoot = pDataDocumentParser->GetRootNode();
-  if (!pImportDataRoot) {
-    pDataDocumentParser->Release();
-    return FALSE;
-  }
-  CXFA_Node* pDataModel =
-      ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets));
-  if (!pDataModel) {
-    pDataDocumentParser->Release();
-    return FALSE;
-  }
-  CXFA_Node* pDataNode = ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Data));
-  if (pDataNode) {
-    pDataModel->RemoveChild(pDataNode);
-  }
-  if (pImportDataRoot->GetClassID() == XFA_ELEMENT_DataModel) {
-    while (CXFA_Node* pChildNode =
-               pImportDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-      pImportDataRoot->RemoveChild(pChildNode);
-      pDataModel->InsertChild(pChildNode);
-    }
-  } else {
-    IFDE_XMLNode* pXMLNode = pImportDataRoot->GetXMLMappingNode();
-    IFDE_XMLNode* pParentXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
-    if (pParentXMLNode) {
-      pParentXMLNode->RemoveChildNode(pXMLNode);
-    }
-    pDataModel->InsertChild(pImportDataRoot);
-  }
-  m_pDocument->DoDataRemerge(FALSE);
-  pDataDocumentParser->Release();
-  return TRUE;
-}
-CFX_WideString XFA_ExportEncodeAttribute(const CFX_WideString& str) {
-  CFX_WideTextBuf textBuf;
-  int32_t iLen = str.GetLength();
-  for (int32_t i = 0; i < iLen; i++) {
-    switch (str[i]) {
-      case '&':
-        textBuf << FX_WSTRC(L"&amp;");
-        break;
-      case '<':
-        textBuf << FX_WSTRC(L"&lt;");
-        break;
-      case '>':
-        textBuf << FX_WSTRC(L"&gt;");
-        break;
-      case '\'':
-        textBuf << FX_WSTRC(L"&apos;");
-        break;
-      case '\"':
-        textBuf << FX_WSTRC(L"&quot;");
-        break;
-      default:
-        textBuf.AppendChar(str[i]);
-    }
-  }
-  return textBuf.GetWideString();
-}
-CFX_WideString XFA_ExportEncodeContent(const CFX_WideStringC& str) {
-  CFX_WideTextBuf textBuf;
-  int32_t iLen = str.GetLength();
-  for (int32_t i = 0; i < iLen; i++) {
-    FX_WCHAR ch = str.GetAt(i);
-    if (!FDE_IsXMLValidChar(ch)) {
-      continue;
-    }
-    if (ch == '&') {
-      textBuf << FX_WSTRC(L"&amp;");
-    } else if (ch == '<') {
-      textBuf << FX_WSTRC(L"&lt;");
-    } else if (ch == '>') {
-      textBuf << FX_WSTRC(L"&gt;");
-    } else if (ch == '\'') {
-      textBuf << FX_WSTRC(L"&apos;");
-    } else if (ch == '\"') {
-      textBuf << FX_WSTRC(L"&quot;");
-    } else if (ch == ' ') {
-      if (i && str.GetAt(i - 1) != ' ') {
-        textBuf.AppendChar(' ');
-      } else {
-        textBuf << FX_WSTRC(L"&#x20;");
-      }
-    } else {
-      textBuf.AppendChar(str.GetAt(i));
-    }
-  }
-  return textBuf.GetWideString();
-}
-static void XFA_SaveAttribute(CXFA_Node* pNode,
-                              XFA_ATTRIBUTE eName,
-                              const CFX_WideStringC& wsName,
-                              FX_BOOL bProto,
-                              CFX_WideString& wsOutput) {
-  CFX_WideString wsValue;
-  if ((!bProto && !pNode->HasAttribute((XFA_ATTRIBUTE)eName, bProto)) ||
-      !pNode->GetAttribute((XFA_ATTRIBUTE)eName, wsValue, FALSE)) {
-    return;
-  }
-  wsValue = XFA_ExportEncodeAttribute(wsValue);
-  wsOutput += FX_WSTRC(L" ");
-  wsOutput += wsName;
-  wsOutput += FX_WSTRC(L"=\"");
-  wsOutput += wsValue;
-  wsOutput += FX_WSTRC(L"\"");
-}
-static FX_BOOL XFA_DataExporter_AttributeSaveInDataModel(
-    CXFA_Node* pNode,
-    XFA_ATTRIBUTE eAttribute) {
-  FX_BOOL bSaveInDataModel = FALSE;
-  if (pNode->GetClassID() != XFA_ELEMENT_Image) {
-    return bSaveInDataModel;
-  }
-  CXFA_Node* pValueNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!pValueNode || pValueNode->GetClassID() != XFA_ELEMENT_Value) {
-    return bSaveInDataModel;
-  }
-  CXFA_Node* pFieldNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pFieldNode && pFieldNode->GetBindData() &&
-      eAttribute == XFA_ATTRIBUTE_Href) {
-    bSaveInDataModel = TRUE;
-  }
-  return bSaveInDataModel;
-}
-FX_BOOL XFA_DataExporter_ContentNodeNeedtoExport(CXFA_Node* pContentNode) {
-  CFX_WideString wsContent;
-  if (!pContentNode->TryContent(wsContent, FALSE, FALSE)) {
-    return FALSE;
-  }
-  FXSYS_assert(pContentNode->GetObjectType() == XFA_OBJECTTYPE_ContentNode);
-  CXFA_Node* pParentNode = pContentNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!pParentNode || pParentNode->GetClassID() != XFA_ELEMENT_Value) {
-    return TRUE;
-  }
-  CXFA_Node* pGrandParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!pGrandParentNode ||
-      pGrandParentNode->GetObjectType() != XFA_OBJECTTYPE_ContainerNode) {
-    return TRUE;
-  }
-  if (pGrandParentNode->GetBindData()) {
-    return FALSE;
-  }
-  CXFA_WidgetData* pWidgetData = pGrandParentNode->GetWidgetData();
-  XFA_ELEMENT eUIType = pWidgetData->GetUIType();
-  if (eUIType == XFA_ELEMENT_PasswordEdit) {
-    return FALSE;
-  }
-  return TRUE;
-}
-static void XFA_DataExporter_RecognizeXFAVersionNumber(
-    CXFA_Node* pTemplateRoot,
-    CFX_WideString& wsVersionNumber) {
-  wsVersionNumber.Empty();
-  if (!pTemplateRoot) {
-    return;
-  }
-  CFX_WideString wsTemplateNS;
-  if (!pTemplateRoot->TryNamespace(wsTemplateNS)) {
-    return;
-  }
-  XFA_VERSION eVersion =
-      pTemplateRoot->GetDocument()->RecognizeXFAVersionNumber(wsTemplateNS);
-  if (eVersion == XFA_VERSION_UNKNOWN) {
-    eVersion = XFA_VERSION_DEFAULT;
-  }
-  wsVersionNumber.Format(L"%i.%i", eVersion / 100, eVersion % 100);
-}
-static void XFA_DataExporter_RegenerateFormFile_Changed(
-    CXFA_Node* pNode,
-    CFX_WideTextBuf& buf,
-    FX_BOOL bSaveXML = FALSE) {
-  CFX_WideString wsAttrs;
-  int32_t iAttrs = 0;
-  const uint8_t* pAttrs = XFA_GetElementAttributes(pNode->GetClassID(), iAttrs);
-  while (iAttrs--) {
-    const XFA_ATTRIBUTEINFO* pAttr =
-        XFA_GetAttributeByID((XFA_ATTRIBUTE)pAttrs[iAttrs]);
-    if (pAttr->eName == XFA_ATTRIBUTE_Name ||
-        (XFA_DataExporter_AttributeSaveInDataModel(pNode, pAttr->eName) &&
-         !bSaveXML)) {
-      continue;
-    }
-    CFX_WideString wsAttr;
-    XFA_SaveAttribute(pNode, pAttr->eName, pAttr->pName, bSaveXML, wsAttr);
-    wsAttrs += wsAttr;
-  }
-  CFX_WideString wsChildren;
-  switch (pNode->GetObjectType()) {
-    case XFA_OBJECTTYPE_ContentNode: {
-      if (!bSaveXML && !XFA_DataExporter_ContentNodeNeedtoExport(pNode)) {
-        break;
-      }
-      CXFA_Node* pRawValueNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-      while (pRawValueNode &&
-             pRawValueNode->GetClassID() != XFA_ELEMENT_SharpxHTML &&
-             pRawValueNode->GetClassID() != XFA_ELEMENT_Sharptext &&
-             pRawValueNode->GetClassID() != XFA_ELEMENT_Sharpxml) {
-        pRawValueNode = pRawValueNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-      }
-      if (!pRawValueNode) {
-        break;
-      }
-      CFX_WideString wsContentType;
-      pNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
-      if (pRawValueNode->GetClassID() == XFA_ELEMENT_SharpxHTML &&
-          wsContentType.Equal(FX_WSTRC(L"text/html"))) {
-        IFDE_XMLNode* pExDataXML = pNode->GetXMLMappingNode();
-        if (!pExDataXML) {
-          break;
-        }
-        IFDE_XMLNode* pRichTextXML =
-            pExDataXML->GetNodeItem(IFDE_XMLNode::FirstChild);
-        if (!pRichTextXML) {
-          break;
-        }
-        IFX_MemoryStream* pMemStream = FX_CreateMemoryStream(TRUE);
-        IFX_Stream* pTempStream = IFX_Stream::CreateStream(
-            (IFX_FileWrite*)pMemStream, FX_STREAMACCESS_Text |
-                                            FX_STREAMACCESS_Write |
-                                            FX_STREAMACCESS_Append);
-        pTempStream->SetCodePage(FX_CODEPAGE_UTF8);
-        pRichTextXML->SaveXMLNode(pTempStream);
-        wsChildren += CFX_WideString::FromUTF8(
-            (const FX_CHAR*)pMemStream->GetBuffer(), pMemStream->GetSize());
-        pTempStream->Release();
-        pMemStream->Release();
-      } else if (pRawValueNode->GetClassID() == XFA_ELEMENT_Sharpxml &&
-                 wsContentType.Equal(FX_WSTRC(L"text/xml"))) {
-        CFX_WideString wsRawValue;
-        pRawValueNode->GetAttribute(XFA_ATTRIBUTE_Value, wsRawValue, FALSE);
-        if (wsRawValue.IsEmpty()) {
-          break;
-        }
-        CFX_WideStringArray wsSelTextArray;
-        int32_t iStart = 0;
-        int32_t iEnd = wsRawValue.Find(L'\n', iStart);
-        iEnd = (iEnd == -1) ? wsRawValue.GetLength() : iEnd;
-        while (iEnd >= iStart) {
-          wsSelTextArray.Add(wsRawValue.Mid(iStart, iEnd - iStart));
-          iStart = iEnd + 1;
-          if (iStart >= wsRawValue.GetLength()) {
-            break;
-          }
-          iEnd = wsRawValue.Find(L'\n', iStart);
-        }
-        CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-        FXSYS_assert(pParentNode);
-        CXFA_Node* pGrandparentNode =
-            pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
-        FXSYS_assert(pGrandparentNode);
-        CFX_WideString bodyTagName;
-        bodyTagName = pGrandparentNode->GetCData(XFA_ATTRIBUTE_Name);
-        if (bodyTagName.IsEmpty()) {
-          bodyTagName = FX_WSTRC(L"ListBox1");
-        }
-        buf << FX_WSTRC(L"<");
-        buf << bodyTagName;
-        buf << FX_WSTRC(L" xmlns=\"\"\n>");
-        for (int32_t i = 0; i < wsSelTextArray.GetSize(); i++) {
-          buf << FX_WSTRC(L"<value\n>");
-          buf << XFA_ExportEncodeContent(wsSelTextArray[i]);
-          buf << FX_WSTRC(L"</value\n>");
-        }
-        buf << FX_WSTRC(L"</");
-        buf << bodyTagName;
-        buf << FX_WSTRC(L"\n>");
-        wsChildren += buf.GetWideString();
-        buf.Clear();
-      } else {
-        CFX_WideStringC wsValue = pRawValueNode->GetCData(XFA_ATTRIBUTE_Value);
-        wsChildren += XFA_ExportEncodeContent(wsValue);
-      }
-    } break;
-    case XFA_OBJECTTYPE_TextNode:
-    case XFA_OBJECTTYPE_NodeC:
-    case XFA_OBJECTTYPE_NodeV: {
-      CFX_WideStringC wsValue = pNode->GetCData(XFA_ATTRIBUTE_Value);
-      wsChildren += XFA_ExportEncodeContent(wsValue);
-    } break;
-    default:
-      if (pNode->GetClassID() == XFA_ELEMENT_Items) {
-        CXFA_Node* pTemplateNode = pNode->GetTemplateNode();
-        if (!pTemplateNode ||
-            pTemplateNode->CountChildren(XFA_ELEMENT_UNKNOWN) !=
-                pNode->CountChildren(XFA_ELEMENT_UNKNOWN)) {
-          bSaveXML = TRUE;
-        }
-      }
-      CFX_WideTextBuf newBuf;
-      CXFA_Node* pChildNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-      while (pChildNode) {
-        XFA_DataExporter_RegenerateFormFile_Changed(pChildNode, newBuf,
-                                                    bSaveXML);
-        wsChildren += newBuf.GetWideString();
-        newBuf.Clear();
-        pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-      }
-      if (!bSaveXML && !wsChildren.IsEmpty() &&
-          pNode->GetClassID() == XFA_ELEMENT_Items) {
-        wsChildren.Empty();
-        bSaveXML = TRUE;
-        CXFA_Node* pChildNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-        while (pChildNode) {
-          XFA_DataExporter_RegenerateFormFile_Changed(pChildNode, newBuf,
-                                                      bSaveXML);
-          wsChildren += newBuf.GetWideString();
-          newBuf.Clear();
-          pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-        }
-      }
-      break;
-  }
-  if (!wsChildren.IsEmpty() || !wsAttrs.IsEmpty() ||
-      pNode->HasAttribute(XFA_ATTRIBUTE_Name)) {
-    CFX_WideStringC wsElement;
-    pNode->GetClassName(wsElement);
-    CFX_WideString wsName;
-    XFA_SaveAttribute(pNode, XFA_ATTRIBUTE_Name, FX_WSTRC(L"name"), TRUE,
-                      wsName);
-    buf << FX_WSTRC(L"<");
-    buf << wsElement;
-    buf << wsName;
-    buf << wsAttrs;
-    if (wsChildren.IsEmpty()) {
-      buf << FX_WSTRC(L"\n/>");
-    } else {
-      buf << FX_WSTRC(L"\n>");
-      buf << wsChildren;
-      buf << FX_WSTRC(L"</");
-      buf << wsElement;
-      buf << FX_WSTRC(L"\n>");
-    }
-  }
-}
-static void XFA_DataExporter_RegenerateFormFile_Container(
-    CXFA_Node* pNode,
-    IFX_Stream* pStream,
-    FX_BOOL bSaveXML = FALSE) {
-  XFA_ELEMENT eElement = pNode->GetClassID();
-  if (eElement == XFA_ELEMENT_Field || eElement == XFA_ELEMENT_Draw ||
-      !pNode->IsContainerNode()) {
-    CFX_WideTextBuf buf;
-    XFA_DataExporter_RegenerateFormFile_Changed(pNode, buf, bSaveXML);
-    FX_STRSIZE nLen = buf.GetLength();
-    if (nLen > 0) {
-      pStream->WriteString((const FX_WCHAR*)buf.GetBuffer(), nLen);
-    }
-    return;
-  }
-  CFX_WideStringC wsElement;
-  pNode->GetClassName(wsElement);
-  pStream->WriteString(L"<", 1);
-  pStream->WriteString(wsElement.GetPtr(), wsElement.GetLength());
-  CFX_WideString wsOutput;
-  XFA_SaveAttribute(pNode, XFA_ATTRIBUTE_Name, FX_WSTRC(L"name"), TRUE,
-                    wsOutput);
-  CFX_WideString wsAttrs;
-  int32_t iAttrs = 0;
-  const uint8_t* pAttrs = XFA_GetElementAttributes(pNode->GetClassID(), iAttrs);
-  while (iAttrs--) {
-    const XFA_ATTRIBUTEINFO* pAttr =
-        XFA_GetAttributeByID((XFA_ATTRIBUTE)pAttrs[iAttrs]);
-    if (pAttr->eName == XFA_ATTRIBUTE_Name) {
-      continue;
-    }
-    CFX_WideString wsAttr;
-    XFA_SaveAttribute(pNode, pAttr->eName, pAttr->pName, FALSE, wsAttr);
-    wsOutput += wsAttr;
-  }
-  if (!wsOutput.IsEmpty()) {
-    pStream->WriteString((const FX_WCHAR*)wsOutput, wsOutput.GetLength());
-  }
-  CXFA_Node* pChildNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  if (pChildNode) {
-    pStream->WriteString(L"\n>", 2);
-    while (pChildNode) {
-      XFA_DataExporter_RegenerateFormFile_Container(pChildNode, pStream,
-                                                    bSaveXML);
-      pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-    pStream->WriteString(L"</", 2);
-    pStream->WriteString(wsElement.GetPtr(), wsElement.GetLength());
-    pStream->WriteString(L"\n>", 2);
-  } else {
-    pStream->WriteString(L"\n/>", 3);
-  }
-}
-void XFA_DataExporter_RegenerateFormFile(CXFA_Node* pNode,
-                                         IFX_Stream* pStream,
-                                         const FX_CHAR* pChecksum,
-                                         FX_BOOL bSaveXML) {
-  if (pNode->GetObjectType() == XFA_OBJECTTYPE_ModelNode) {
-    static const FX_WCHAR* s_pwsTagName = L"<form";
-    static const FX_WCHAR* s_pwsClose = L"</form\n>";
-    pStream->WriteString(s_pwsTagName, FXSYS_wcslen(s_pwsTagName));
-    if (pChecksum) {
-      static const FX_WCHAR* s_pwChecksum = L" checksum=\"";
-      CFX_WideString wsChecksum =
-          CFX_WideString::FromUTF8(pChecksum, FXSYS_strlen(pChecksum));
-      pStream->WriteString(s_pwChecksum, FXSYS_wcslen(s_pwChecksum));
-      pStream->WriteString((const FX_WCHAR*)wsChecksum, wsChecksum.GetLength());
-      pStream->WriteString(L"\"", 1);
-    }
-    pStream->WriteString(L" xmlns=\"", FXSYS_wcslen(L" xmlns=\""));
-    const FX_WCHAR* pURI = XFA_GetPacketByIndex(XFA_PACKET_Form)->pURI;
-    pStream->WriteString(pURI, FXSYS_wcslen(pURI));
-    CFX_WideString wsVersionNumber;
-    XFA_DataExporter_RecognizeXFAVersionNumber(
-        ToNode(pNode->GetDocument()->GetXFAObject(XFA_XDPPACKET_Template)),
-        wsVersionNumber);
-    if (wsVersionNumber.IsEmpty()) {
-      wsVersionNumber = FX_WSTRC(L"2.8");
-    }
-    wsVersionNumber += FX_WSTRC(L"/\"\n>");
-    pStream->WriteString((const FX_WCHAR*)wsVersionNumber,
-                         wsVersionNumber.GetLength());
-    CXFA_Node* pChildNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    while (pChildNode) {
-      XFA_DataExporter_RegenerateFormFile_Container(pChildNode, pStream);
-      pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-    pStream->WriteString(s_pwsClose, FXSYS_wcslen(s_pwsClose));
-  } else {
-    XFA_DataExporter_RegenerateFormFile_Container(pNode, pStream, bSaveXML);
-  }
-}
-IXFA_PacketExport* IXFA_PacketExport::Create(CXFA_Document* pDocument,
-                                             XFA_DATAFORMAT eFormat) {
-  return new CXFA_DataExporter(pDocument);
-}
-CXFA_DataExporter::CXFA_DataExporter(CXFA_Document* pDocument)
-    : m_pDocument(pDocument) {
-  ASSERT(m_pDocument);
-}
-FX_BOOL CXFA_DataExporter::Export(IFX_FileWrite* pWrite) {
-  return Export(pWrite, m_pDocument->GetRoot());
-}
-FX_BOOL CXFA_DataExporter::Export(IFX_FileWrite* pWrite,
-                                  CXFA_Node* pNode,
-                                  FX_DWORD dwFlag,
-                                  const FX_CHAR* pChecksum) {
-  if (!pWrite) {
-    ASSERT(false);
-    return FALSE;
-  }
-  IFX_Stream* pStream = IFX_Stream::CreateStream(
-      pWrite,
-      FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
-  if (pStream == NULL) {
-    return FALSE;
-  }
-  pStream->SetCodePage(FX_CODEPAGE_UTF8);
-  FX_BOOL bRet = Export(pStream, pNode, dwFlag, pChecksum);
-  pStream->Release();
-  return bRet;
-}
-FX_BOOL CXFA_DataExporter::Export(IFX_Stream* pStream,
-                                  CXFA_Node* pNode,
-                                  FX_DWORD dwFlag,
-                                  const FX_CHAR* pChecksum) {
-  IFDE_XMLDoc* pXMLDoc = m_pDocument->GetParser()->GetXMLDoc();
-  if (pNode->GetObjectType() == XFA_OBJECTTYPE_ModelNode) {
-    switch (pNode->GetPacketID()) {
-      case XFA_XDPPACKET_XDP: {
-        static const FX_WCHAR* s_pwsPreamble =
-            L"<xdp:xdp xmlns:xdp=\"http://ns.adobe.com/xdp/\">";
-        pStream->WriteString(s_pwsPreamble, FXSYS_wcslen(s_pwsPreamble));
-        for (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-             pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-          Export(pStream, pChild, dwFlag, pChecksum);
-        }
-        static const FX_WCHAR* s_pwsPostamble = L"</xdp:xdp\n>";
-        pStream->WriteString(s_pwsPostamble, FXSYS_wcslen(s_pwsPostamble));
-      } break;
-      case XFA_XDPPACKET_Datasets: {
-        IFDE_XMLElement* pElement =
-            (IFDE_XMLElement*)pNode->GetXMLMappingNode();
-        if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
-          return FALSE;
-        }
-        CXFA_Node* pDataNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-        FXSYS_assert(pDataNode);
-        XFA_DataExporter_DealWithDataGroupNode(pDataNode);
-        pXMLDoc->SaveXMLNode(pStream, pElement);
-      } break;
-      case XFA_XDPPACKET_Form: {
-        XFA_DataExporter_RegenerateFormFile(pNode, pStream, pChecksum);
-      } break;
-      case XFA_XDPPACKET_Template:
-      default: {
-        IFDE_XMLElement* pElement =
-            (IFDE_XMLElement*)pNode->GetXMLMappingNode();
-        if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
-          return FALSE;
-        }
-        pXMLDoc->SaveXMLNode(pStream, pElement);
-      } break;
-    }
-  } else {
-    CXFA_Node* pDataNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-    CXFA_Node* pExportNode = pNode;
-    for (CXFA_Node* pChildNode =
-             pDataNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-         pChildNode;
-         pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pChildNode != pNode) {
-        pExportNode = pDataNode;
-        break;
-      }
-    }
-    IFDE_XMLElement* pElement =
-        (IFDE_XMLElement*)pExportNode->GetXMLMappingNode();
-    if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
-      return FALSE;
-    }
-    XFA_DataExporter_DealWithDataGroupNode(pExportNode);
-    pElement->SetString(FX_WSTRC(L"xmlns:xfa"),
-                        FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"));
-    pXMLDoc->SaveXMLNode(pStream, pElement);
-    pElement->RemoveAttribute(L"xmlns:xfa");
-  }
-  return TRUE;
-}
-void XFA_DataExporter_DealWithDataGroupNode(CXFA_Node* pDataNode) {
-  if (!pDataNode || pDataNode->GetClassID() == XFA_ELEMENT_DataValue) {
-    return;
-  }
-  int32_t iChildNum = 0;
-  for (CXFA_Node* pChildNode = pDataNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pChildNode;
-       pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    iChildNum++;
-    XFA_DataExporter_DealWithDataGroupNode(pChildNode);
-  }
-  if (pDataNode->GetClassID() == XFA_ELEMENT_DataGroup) {
-    if (iChildNum > 0) {
-      IFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
-      FXSYS_assert(pXMLNode->GetType() == FDE_XMLNODE_Element);
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
-      if (pXMLElement->HasAttribute(L"xfa:dataNode")) {
-        pXMLElement->RemoveAttribute(L"xfa:dataNode");
-      }
-    } else {
-      IFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
-      FXSYS_assert(pXMLNode->GetType() == FDE_XMLNODE_Element);
-      ((IFDE_XMLElement*)pXMLNode)
-          ->SetString(FX_WSTRC(L"xfa:dataNode"), FX_WSTRC(L"dataGroup"));
-    }
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_document_serialize.h b/xfa/src/fxfa/parser/xfa_document_serialize.h
deleted file mode 100644
index 37dbb9a03b..0000000000
--- a/xfa/src/fxfa/parser/xfa_document_serialize.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_SERIALIZE_H_
-#define XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_SERIALIZE_H_
-
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-
-class CXFA_DataImporter : public IXFA_PacketImport {
- public:
-  CXFA_DataImporter(CXFA_Document* pDocument);
-  virtual void Release() { delete this; }
-  virtual FX_BOOL ImportData(IFX_FileRead* pDataDocument);
-
- protected:
-  CXFA_Document* m_pDocument;
-};
-
-class CXFA_DataExporter : public IXFA_PacketExport {
- public:
-  CXFA_DataExporter(CXFA_Document* pDocument);
-  virtual void Release() { delete this; }
-  virtual FX_BOOL Export(IFX_FileWrite* pWrite);
-  virtual FX_BOOL Export(IFX_FileWrite* pWrite,
-                         CXFA_Node* pNode,
-                         FX_DWORD dwFlag = 0,
-                         const FX_CHAR* pChecksum = NULL);
-
- protected:
-  FX_BOOL Export(IFX_Stream* pStream,
-                 CXFA_Node* pNode,
-                 FX_DWORD dwFlag,
-                 const FX_CHAR* pChecksum);
-  CXFA_Document* m_pDocument;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_DOCUMENT_SERIALIZE_H_
diff --git a/xfa/src/fxfa/parser/xfa_layout_appadapter.cpp b/xfa/src/fxfa/parser/xfa_layout_appadapter.cpp
deleted file mode 100644
index bf79c83a38..0000000000
--- a/xfa/src/fxfa/parser/xfa_layout_appadapter.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// 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/src/fxfa/parser/xfa_layout_appadapter.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_layout_itemlayout.h"
-#include "xfa/src/fxfa/parser/xfa_layout_pagemgr_new.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-FX_DWORD XFA_GetRelevant(CXFA_Node* pFormItem, FX_DWORD dwParentRelvant) {
-  FX_DWORD dwRelevant = XFA_LAYOUTSTATUS_Viewable | XFA_LAYOUTSTATUS_Printable;
-  CFX_WideStringC wsRelevant;
-  if (pFormItem->TryCData(XFA_ATTRIBUTE_Relevant, wsRelevant)) {
-    if (wsRelevant == FX_WSTRC(L"+print") || wsRelevant == FX_WSTRC(L"print")) {
-      dwRelevant &= ~XFA_LAYOUTSTATUS_Viewable;
-    } else if (wsRelevant == FX_WSTRC(L"-print")) {
-      dwRelevant &= ~XFA_LAYOUTSTATUS_Printable;
-    }
-  }
-  if (!(dwParentRelvant & XFA_LAYOUTSTATUS_Viewable) &&
-      (dwRelevant != XFA_LAYOUTSTATUS_Viewable)) {
-    dwRelevant &= ~XFA_LAYOUTSTATUS_Viewable;
-  }
-  if (!(dwParentRelvant & XFA_LAYOUTSTATUS_Printable) &&
-      (dwRelevant != XFA_LAYOUTSTATUS_Printable)) {
-    dwRelevant &= ~XFA_LAYOUTSTATUS_Printable;
-  }
-  return dwRelevant;
-}
-void XFA_ReleaseLayoutItem(CXFA_LayoutItem* pLayoutItem) {
-  CXFA_LayoutItem* pNode = pLayoutItem->m_pFirstChild;
-  IXFA_Notify* pNotify =
-      pLayoutItem->m_pFormNode->GetDocument()->GetParser()->GetNotify();
-  IXFA_DocLayout* pDocLayout =
-      pLayoutItem->m_pFormNode->GetDocument()->GetDocLayout();
-  while (pNode) {
-    CXFA_LayoutItem* pNext = pNode->m_pNextSibling;
-    pNode->m_pParent = nullptr;
-    pNotify->OnLayoutEvent(pDocLayout, static_cast<CXFA_LayoutItem*>(pNode),
-                           XFA_LAYOUTEVENT_ItemRemoving);
-    XFA_ReleaseLayoutItem(pNode);
-    pNode = pNext;
-  }
-  pNotify->OnLayoutEvent(pDocLayout, pLayoutItem, XFA_LAYOUTEVENT_ItemRemoving);
-  if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_PageArea) {
-    pNotify->OnPageEvent(static_cast<CXFA_ContainerLayoutItem*>(pLayoutItem),
-                         XFA_PAGEEVENT_PageRemoved);
-  }
-  delete pLayoutItem;
-}
diff --git a/xfa/src/fxfa/parser/xfa_layout_appadapter.h b/xfa/src/fxfa/parser/xfa_layout_appadapter.h
deleted file mode 100644
index 94012fae0e..0000000000
--- a/xfa/src/fxfa/parser/xfa_layout_appadapter.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_LAYOUT_APPADAPTER_H_
-#define XFA_SRC_FXFA_PARSER_XFA_LAYOUT_APPADAPTER_H_
-
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-
-class CXFA_TraverseStrategy_PageAreaContainerLayoutItem {
- public:
-  static inline CXFA_ContainerLayoutItem* GetFirstChild(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_PageSet) {
-      return (CXFA_ContainerLayoutItem*)pLayoutItem->m_pFirstChild;
-    }
-    return NULL;
-  }
-  static inline CXFA_ContainerLayoutItem* GetNextSibling(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    return (CXFA_ContainerLayoutItem*)pLayoutItem->m_pNextSibling;
-  }
-  static inline CXFA_ContainerLayoutItem* GetParent(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    return (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent;
-  }
-};
-class CXFA_TraverseStrategy_ContentAreaContainerLayoutItem {
- public:
-  static inline CXFA_ContainerLayoutItem* GetFirstChild(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    for (CXFA_LayoutItem* pChildItem = pLayoutItem->m_pFirstChild; pChildItem;
-         pChildItem = pChildItem->m_pNextSibling) {
-      if (CXFA_ContainerLayoutItem* pContainer =
-              pChildItem->AsContainerLayoutItem()) {
-        return pContainer;
-      }
-    }
-    return nullptr;
-  }
-  static inline CXFA_ContainerLayoutItem* GetNextSibling(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    for (CXFA_LayoutItem* pChildItem = pLayoutItem->m_pNextSibling; pChildItem;
-         pChildItem = pChildItem->m_pNextSibling) {
-      if (CXFA_ContainerLayoutItem* pContainer =
-              pChildItem->AsContainerLayoutItem()) {
-        return pContainer;
-      }
-    }
-    return nullptr;
-  }
-  static inline CXFA_ContainerLayoutItem* GetParent(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    return (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent;
-  }
-};
-class CXFA_TraverseStrategy_ContentLayoutItem {
- public:
-  static inline CXFA_ContentLayoutItem* GetFirstChild(
-      CXFA_ContentLayoutItem* pLayoutItem) {
-    return (CXFA_ContentLayoutItem*)pLayoutItem->m_pFirstChild;
-  }
-  static inline CXFA_ContentLayoutItem* GetNextSibling(
-      CXFA_ContentLayoutItem* pLayoutItem) {
-    return (CXFA_ContentLayoutItem*)pLayoutItem->m_pNextSibling;
-  }
-  static inline CXFA_ContentLayoutItem* GetParent(
-      CXFA_ContentLayoutItem* pLayoutItem) {
-    return (CXFA_ContentLayoutItem*)pLayoutItem->m_pParent;
-  }
-};
-FX_DWORD XFA_GetRelevant(CXFA_Node* pFormItem, FX_DWORD dwParentRelvant);
-void XFA_ReleaseLayoutItem(CXFA_LayoutItem* pLayoutItem);
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_LAYOUT_APPADAPTER_H_
diff --git a/xfa/src/fxfa/parser/xfa_layout_itemlayout.cpp b/xfa/src/fxfa/parser/xfa_layout_itemlayout.cpp
deleted file mode 100644
index cdf327826b..0000000000
--- a/xfa/src/fxfa/parser/xfa_layout_itemlayout.cpp
+++ /dev/null
@@ -1,2968 +0,0 @@
-// 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/src/fxfa/parser/xfa_layout_itemlayout.h"
-
-#include <algorithm>
-#include <memory>
-
-#include "xfa/src/fgas/crt/fgas_algorithm.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_layout_appadapter.h"
-#include "xfa/src/fxfa/parser/xfa_layout_pagemgr_new.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_ItemLayoutProcessor::CXFA_ItemLayoutProcessor(CXFA_Node* pNode,
-                                                   CXFA_LayoutPageMgr* pPageMgr)
-    : m_bKeepBreakFinish(FALSE),
-      m_bIsProcessKeep(FALSE),
-      m_pKeepHeadNode(nullptr),
-      m_pKeepTailNode(nullptr),
-      m_pFormNode(pNode),
-      m_pLayoutItem(nullptr),
-      m_pOldLayoutItem(nullptr),
-      m_pCurChildNode(XFA_LAYOUT_INVALIDNODE),
-      m_pCurChildPreprocessor(nullptr),
-      m_nCurChildNodeStage(XFA_ItemLayoutProcessorStages_None),
-      m_fUsedSize(0),
-      m_pPageMgr(pPageMgr),
-      m_bBreakPending(TRUE),
-      m_fLastRowWidth(0),
-      m_fLastRowY(0),
-      m_fWidthLimite(0),
-      m_bUseInheriated(FALSE),
-      m_ePreProcessRs(XFA_ItemLayoutProcessorResult_Done),
-      m_bHasAvailHeight(TRUE) {
-  FXSYS_assert(m_pFormNode && (m_pFormNode->IsContainerNode() ||
-                               m_pFormNode->GetClassID() == XFA_ELEMENT_Form));
-  m_pOldLayoutItem =
-      (CXFA_ContentLayoutItem*)m_pFormNode->GetUserData(XFA_LAYOUTITEMKEY);
-}
-CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::CreateContentLayoutItem(
-    CXFA_Node* pFormNode) {
-  if (!pFormNode) {
-    return NULL;
-  }
-  CXFA_ContentLayoutItem* pLayoutItem = NULL;
-  if (m_pOldLayoutItem) {
-    pLayoutItem = m_pOldLayoutItem;
-    m_pOldLayoutItem = m_pOldLayoutItem->m_pNext;
-    return pLayoutItem;
-  }
-  pLayoutItem = (CXFA_ContentLayoutItem*)pFormNode->GetDocument()
-                    ->GetParser()
-                    ->GetNotify()
-                    ->OnCreateLayoutItem(pFormNode);
-  CXFA_ContentLayoutItem* pPrevLayoutItem =
-      (CXFA_ContentLayoutItem*)pFormNode->GetUserData(XFA_LAYOUTITEMKEY);
-  if (pPrevLayoutItem) {
-    while (pPrevLayoutItem->m_pNext) {
-      pPrevLayoutItem = pPrevLayoutItem->m_pNext;
-    }
-    pPrevLayoutItem->m_pNext = pLayoutItem;
-    pLayoutItem->m_pPrev = pPrevLayoutItem;
-  } else {
-    pFormNode->SetUserData(XFA_LAYOUTITEMKEY, pLayoutItem);
-  }
-  return pLayoutItem;
-}
-FX_BOOL CXFA_ItemLayoutProcessor::FindLayoutItemSplitPos(
-    CXFA_ContentLayoutItem* pLayoutItem,
-    FX_FLOAT fCurVerticalOffset,
-    FX_FLOAT& fProposedSplitPos,
-    FX_BOOL& bAppChange,
-    FX_BOOL bCalculateMargin) {
-  CXFA_Node* pFormNode = pLayoutItem->m_pFormNode;
-  if (fProposedSplitPos > fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION &&
-      fProposedSplitPos <= fCurVerticalOffset + pLayoutItem->m_sSize.y -
-                               XFA_LAYOUT_FLOAT_PERCISION) {
-    switch (pFormNode->GetIntact()) {
-      case XFA_ATTRIBUTEENUM_None: {
-        FX_BOOL bAnyChanged = FALSE;
-        CXFA_Document* pDocument = pFormNode->GetDocument();
-        IXFA_Notify* pNotify = pDocument->GetParser()->GetNotify();
-        FX_FLOAT fCurTopMargin = 0, fCurBottomMargin = 0;
-        CXFA_Node* pMarginNode =
-            pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-        if (pMarginNode && bCalculateMargin) {
-          fCurTopMargin = pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset)
-                              .ToUnit(XFA_UNIT_Pt);
-          fCurBottomMargin = pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset)
-                                 .ToUnit(XFA_UNIT_Pt);
-        }
-        FX_BOOL bChanged = TRUE;
-        while (bChanged) {
-          bChanged = FALSE;
-          {
-            FX_FLOAT fRelSplitPos = fProposedSplitPos - fCurVerticalOffset;
-            if (pNotify->FindSplitPos(pFormNode, pLayoutItem->GetIndex(),
-                                      fRelSplitPos)) {
-              bAnyChanged = TRUE;
-              bChanged = TRUE;
-              fProposedSplitPos = fCurVerticalOffset + fRelSplitPos;
-              bAppChange = TRUE;
-              if (fProposedSplitPos <=
-                  fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION) {
-                return TRUE;
-              }
-            }
-          }
-          FX_FLOAT fRelSplitPos = fProposedSplitPos - fCurBottomMargin;
-          for (CXFA_ContentLayoutItem* pChildItem =
-                   (CXFA_ContentLayoutItem*)pLayoutItem->m_pFirstChild;
-               pChildItem;
-               pChildItem =
-                   (CXFA_ContentLayoutItem*)pChildItem->m_pNextSibling) {
-            FX_FLOAT fChildOffset =
-                fCurVerticalOffset + fCurTopMargin + pChildItem->m_sPos.y;
-            FX_BOOL bAppChange = FALSE;
-            if (FindLayoutItemSplitPos(pChildItem, fChildOffset, fRelSplitPos,
-                                       bAppChange, bCalculateMargin)) {
-              if (fRelSplitPos - fChildOffset < XFA_LAYOUT_FLOAT_PERCISION &&
-                  bAppChange) {
-                fProposedSplitPos = fRelSplitPos - fCurTopMargin;
-              } else {
-                fProposedSplitPos = fRelSplitPos + fCurBottomMargin;
-              }
-              bAnyChanged = TRUE;
-              bChanged = TRUE;
-              if (fProposedSplitPos <=
-                  fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION) {
-                return TRUE;
-              }
-              if (bAnyChanged) {
-                break;
-              }
-            }
-          }
-        }
-        return bAnyChanged;
-      } break;
-      case XFA_ATTRIBUTEENUM_ContentArea:
-      case XFA_ATTRIBUTEENUM_PageArea: {
-        fProposedSplitPos = fCurVerticalOffset;
-        return TRUE;
-      }
-      default:
-        return FALSE;
-    }
-  }
-  return FALSE;
-}
-static XFA_ATTRIBUTEENUM XFA_ItemLayoutProcessor_GetLayout(
-    CXFA_Node* pFormNode,
-    FX_BOOL& bRootForceTb) {
-  bRootForceTb = FALSE;
-  XFA_ATTRIBUTEENUM eLayoutMode;
-  if (pFormNode->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, FALSE)) {
-    return eLayoutMode;
-  }
-  CXFA_Node* pParentNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_Form) {
-    bRootForceTb = TRUE;
-    return XFA_ATTRIBUTEENUM_Tb;
-  }
-  return XFA_ATTRIBUTEENUM_Position;
-}
-static FX_BOOL XFA_ExistContainerKeep(CXFA_Node* pCurNode, FX_BOOL bPreFind) {
-  if (pCurNode == NULL || !XFA_ItemLayoutProcessor_IsTakingSpace(pCurNode)) {
-    return FALSE;
-  }
-  XFA_NODEITEM eItemType = XFA_NODEITEM_PrevSibling;
-  if (!bPreFind) {
-    eItemType = XFA_NODEITEM_NextSibling;
-  }
-  CXFA_Node* pPreContainer =
-      pCurNode->GetNodeItem(eItemType, XFA_OBJECTTYPE_ContainerNode);
-  if (pPreContainer == NULL) {
-    return FALSE;
-  }
-  CXFA_Node* pKeep = pCurNode->GetFirstChildByClass(XFA_ELEMENT_Keep);
-  if (pKeep) {
-    XFA_ATTRIBUTEENUM ePrevious;
-    XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Previous;
-    if (!bPreFind) {
-      eKeepType = XFA_ATTRIBUTE_Next;
-    }
-    if (pKeep->TryEnum(eKeepType, ePrevious, FALSE)) {
-      if (ePrevious == XFA_ATTRIBUTEENUM_ContentArea ||
-          ePrevious == XFA_ATTRIBUTEENUM_PageArea) {
-        return TRUE;
-      }
-    }
-  }
-  pKeep = pPreContainer->GetFirstChildByClass(XFA_ELEMENT_Keep);
-  if (!pKeep) {
-    return FALSE;
-  }
-  XFA_ATTRIBUTEENUM eNext;
-  XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Next;
-  if (!bPreFind) {
-    eKeepType = XFA_ATTRIBUTE_Previous;
-  }
-  if (!pKeep->TryEnum(eKeepType, eNext, FALSE)) {
-    return FALSE;
-  }
-  if (eNext == XFA_ATTRIBUTEENUM_ContentArea ||
-      eNext == XFA_ATTRIBUTEENUM_PageArea) {
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_FLOAT CXFA_ItemLayoutProcessor::FindSplitPos(FX_FLOAT fProposedSplitPos) {
-  ASSERT(m_pLayoutItem);
-  XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-  FX_BOOL bCalculateMargin = TRUE;
-  if (eLayout == XFA_ATTRIBUTEENUM_Position) {
-    bCalculateMargin = FALSE;
-  }
-  while (fProposedSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
-    FX_BOOL bAppChange = FALSE;
-    if (!FindLayoutItemSplitPos(m_pLayoutItem, 0, fProposedSplitPos, bAppChange,
-                                bCalculateMargin)) {
-      break;
-    }
-  }
-  return fProposedSplitPos;
-}
-void CXFA_ItemLayoutProcessor::SplitLayoutItem(
-    CXFA_ContentLayoutItem* pLayoutItem,
-    CXFA_ContentLayoutItem* pSecondParent,
-    FX_FLOAT fSplitPos) {
-  FX_FLOAT fCurTopMargin = 0, fCurBottomMargin = 0;
-  XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-  FX_BOOL bCalculateMargin = TRUE;
-  if (eLayout == XFA_ATTRIBUTEENUM_Position) {
-    bCalculateMargin = FALSE;
-  }
-  CXFA_Node* pMarginNode =
-      pLayoutItem->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  if (pMarginNode && bCalculateMargin) {
-    fCurTopMargin =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
-    fCurBottomMargin =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
-  }
-  CXFA_ContentLayoutItem* pSecondLayoutItem = NULL;
-  if (m_pCurChildPreprocessor &&
-      m_pCurChildPreprocessor->m_pFormNode == pLayoutItem->m_pFormNode) {
-    pSecondLayoutItem = m_pCurChildPreprocessor->CreateContentLayoutItem(
-        pLayoutItem->m_pFormNode);
-  } else {
-    pSecondLayoutItem = CreateContentLayoutItem(pLayoutItem->m_pFormNode);
-  }
-  pSecondLayoutItem->m_sPos.x = pLayoutItem->m_sPos.x;
-  pSecondLayoutItem->m_sSize.x = pLayoutItem->m_sSize.x;
-  pSecondLayoutItem->m_sPos.y = 0;
-  pSecondLayoutItem->m_sSize.y = pLayoutItem->m_sSize.y - fSplitPos;
-  pLayoutItem->m_sSize.y -= pSecondLayoutItem->m_sSize.y;
-  if (pLayoutItem->m_pFirstChild) {
-    pSecondLayoutItem->m_sSize.y += fCurTopMargin;
-  }
-  if (pSecondParent) {
-    pSecondParent->AddChild(pSecondLayoutItem);
-    if (fCurTopMargin > 0 && pLayoutItem->m_pFirstChild) {
-      pSecondParent->m_sSize.y += fCurTopMargin;
-      CXFA_ContentLayoutItem* pParentItem =
-          (CXFA_ContentLayoutItem*)pSecondParent->m_pParent;
-      while (pParentItem) {
-        pParentItem->m_sSize.y += fCurTopMargin;
-        pParentItem = (CXFA_ContentLayoutItem*)pParentItem->m_pParent;
-      }
-    }
-  } else {
-    pSecondLayoutItem->m_pParent = pLayoutItem->m_pParent;
-    pSecondLayoutItem->m_pNextSibling = pLayoutItem->m_pNextSibling;
-    pLayoutItem->m_pNextSibling = pSecondLayoutItem;
-  }
-  CXFA_ContentLayoutItem* pChildren =
-      (CXFA_ContentLayoutItem*)pLayoutItem->m_pFirstChild;
-  pLayoutItem->m_pFirstChild = NULL;
-  FX_FLOAT lHeightForKeep = 0;
-  CFX_ArrayTemplate<CXFA_ContentLayoutItem*> keepLayoutItems;
-  FX_FLOAT fAddMarginHeight = 0;
-  for (CXFA_ContentLayoutItem *pChildItem = pChildren, *pChildNext = NULL;
-       pChildItem; pChildItem = pChildNext) {
-    pChildNext = (CXFA_ContentLayoutItem*)pChildItem->m_pNextSibling;
-    pChildItem->m_pNextSibling = NULL;
-    if (fSplitPos <= fCurTopMargin + pChildItem->m_sPos.y + fCurBottomMargin +
-                         XFA_LAYOUT_FLOAT_PERCISION) {
-      if (!XFA_ExistContainerKeep(pChildItem->m_pFormNode, TRUE)) {
-        pChildItem->m_sPos.y -= fSplitPos - fCurBottomMargin;
-        pChildItem->m_sPos.y += lHeightForKeep;
-        pChildItem->m_sPos.y += fAddMarginHeight;
-        pSecondLayoutItem->AddChild(pChildItem);
-      } else {
-        if (lHeightForKeep < XFA_LAYOUT_FLOAT_PERCISION) {
-          for (int32_t iIndex = 0; iIndex < keepLayoutItems.GetSize();
-               iIndex++) {
-            CXFA_ContentLayoutItem* pPreItem = keepLayoutItems[iIndex];
-            pLayoutItem->RemoveChild(pPreItem);
-            pPreItem->m_sPos.y -= fSplitPos;
-            if (pPreItem->m_sPos.y < 0) {
-              pPreItem->m_sPos.y = 0;
-            }
-            if (pPreItem->m_sPos.y + pPreItem->m_sSize.y > lHeightForKeep) {
-              pPreItem->m_sPos.y = lHeightForKeep;
-              lHeightForKeep += pPreItem->m_sSize.y;
-              pSecondLayoutItem->m_sSize.y += pPreItem->m_sSize.y;
-              if (pSecondParent) {
-                pSecondParent->m_sSize.y += pPreItem->m_sSize.y;
-              }
-            }
-            pSecondLayoutItem->AddChild(pPreItem);
-          }
-        }
-        pChildItem->m_sPos.y -= fSplitPos;
-        pChildItem->m_sPos.y += lHeightForKeep;
-        pChildItem->m_sPos.y += fAddMarginHeight;
-        pSecondLayoutItem->AddChild(pChildItem);
-      }
-    } else if (fSplitPos + XFA_LAYOUT_FLOAT_PERCISION >=
-               fCurTopMargin + fCurBottomMargin + pChildItem->m_sPos.y +
-                   pChildItem->m_sSize.y) {
-      pLayoutItem->AddChild(pChildItem);
-      if (XFA_ExistContainerKeep(pChildItem->m_pFormNode, FALSE)) {
-        keepLayoutItems.Add(pChildItem);
-      } else {
-        keepLayoutItems.RemoveAll();
-      }
-    } else {
-      FX_FLOAT fOldHeight = pSecondLayoutItem->m_sSize.y;
-      SplitLayoutItem(
-          pChildItem, pSecondLayoutItem,
-          fSplitPos - fCurTopMargin - fCurBottomMargin - pChildItem->m_sPos.y);
-      fAddMarginHeight = pSecondLayoutItem->m_sSize.y - fOldHeight;
-      pLayoutItem->AddChild(pChildItem);
-    }
-  }
-}
-void CXFA_ItemLayoutProcessor::SplitLayoutItem(FX_FLOAT fSplitPos) {
-  ASSERT(m_pLayoutItem);
-  SplitLayoutItem(m_pLayoutItem, NULL, fSplitPos);
-}
-
-IXFA_LayoutPage* CXFA_LayoutItem::GetPage() const {
-  for (CXFA_LayoutItem* pCurNode = const_cast<CXFA_LayoutItem*>(this); pCurNode;
-       pCurNode = pCurNode->m_pParent) {
-    if (pCurNode->m_pFormNode->GetClassID() == XFA_ELEMENT_PageArea)
-      return static_cast<CXFA_ContainerLayoutItem*>(pCurNode);
-  }
-  return nullptr;
-}
-
-CXFA_Node* CXFA_LayoutItem::GetFormNode() const {
-  return m_pFormNode;
-}
-
-void CXFA_LayoutItem::GetRect(CFX_RectF& rtLayout, FX_BOOL bRelative) const {
-  ASSERT(m_bIsContentLayoutItem);
-  const CXFA_ContentLayoutItem* pThis =
-      static_cast<const CXFA_ContentLayoutItem*>(this);
-  CFX_PointF sPos = pThis->m_sPos;
-  CFX_SizeF sSize = pThis->m_sSize;
-  if (!bRelative) {
-    for (CXFA_LayoutItem* pLayoutItem = pThis->m_pParent; pLayoutItem;
-         pLayoutItem = pLayoutItem->m_pParent) {
-      if (CXFA_ContentLayoutItem* pContent =
-              pLayoutItem->AsContentLayoutItem()) {
-        sPos += pContent->m_sPos;
-        if (CXFA_Node* pMarginNode =
-                pLayoutItem->m_pFormNode->GetFirstChildByClass(
-                    XFA_ELEMENT_Margin)) {
-          sPos += CFX_PointF(pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset)
-                                 .ToUnit(XFA_UNIT_Pt),
-                             pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset)
-                                 .ToUnit(XFA_UNIT_Pt));
-        }
-      } else {
-        if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_ContentArea) {
-          sPos +=
-              CFX_PointF(pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_X)
-                             .ToUnit(XFA_UNIT_Pt),
-                         pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_Y)
-                             .ToUnit(XFA_UNIT_Pt));
-          break;
-        } else if (pLayoutItem->m_pFormNode->GetClassID() ==
-                   XFA_ELEMENT_PageArea) {
-          break;
-        }
-      }
-    }
-  }
-  rtLayout.Set(sPos.x, sPos.y, sSize.x, sSize.y);
-}
-
-CXFA_LayoutItem* CXFA_LayoutItem::GetParent() const {
-  return m_pParent;
-}
-
-const CXFA_LayoutItem* CXFA_LayoutItem::GetFirst() const {
-  ASSERT(m_bIsContentLayoutItem);
-  const CXFA_ContentLayoutItem* pCurNode =
-      static_cast<const CXFA_ContentLayoutItem*>(this);
-  while (pCurNode->m_pPrev) {
-    pCurNode = pCurNode->m_pPrev;
-  }
-  return pCurNode;
-}
-
-CXFA_LayoutItem* CXFA_LayoutItem::GetFirst() {
-  ASSERT(m_bIsContentLayoutItem);
-  CXFA_ContentLayoutItem* pCurNode = static_cast<CXFA_ContentLayoutItem*>(this);
-  while (pCurNode->m_pPrev) {
-    pCurNode = pCurNode->m_pPrev;
-  }
-  return pCurNode;
-}
-
-CXFA_LayoutItem* CXFA_LayoutItem::GetLast() {
-  ASSERT(m_bIsContentLayoutItem);
-  CXFA_ContentLayoutItem* pCurNode = static_cast<CXFA_ContentLayoutItem*>(this);
-  while (pCurNode->m_pNext) {
-    pCurNode = pCurNode->m_pNext;
-  }
-  return pCurNode;
-}
-
-const CXFA_LayoutItem* CXFA_LayoutItem::GetLast() const {
-  ASSERT(m_bIsContentLayoutItem);
-  const CXFA_ContentLayoutItem* pCurNode =
-      static_cast<const CXFA_ContentLayoutItem*>(this);
-  while (pCurNode->m_pNext) {
-    pCurNode = pCurNode->m_pNext;
-  }
-  return pCurNode;
-}
-
-CXFA_LayoutItem* CXFA_LayoutItem::GetPrev() const {
-  ASSERT(m_bIsContentLayoutItem);
-  return static_cast<const CXFA_ContentLayoutItem*>(this)->m_pPrev;
-}
-
-CXFA_LayoutItem* CXFA_LayoutItem::GetNext() const {
-  ASSERT(m_bIsContentLayoutItem);
-  return static_cast<const CXFA_ContentLayoutItem*>(this)->m_pNext;
-}
-
-int32_t CXFA_LayoutItem::GetIndex() const {
-  ASSERT(m_bIsContentLayoutItem);
-  int32_t iIndex = 0;
-  const CXFA_ContentLayoutItem* pCurNode =
-      static_cast<const CXFA_ContentLayoutItem*>(this);
-  while (pCurNode->m_pPrev) {
-    pCurNode = pCurNode->m_pPrev;
-    ++iIndex;
-  }
-  return iIndex;
-}
-
-int32_t CXFA_LayoutItem::GetCount() const {
-  ASSERT(m_bIsContentLayoutItem);
-  int32_t iCount = GetIndex() + 1;
-  const CXFA_ContentLayoutItem* pCurNode =
-      static_cast<const CXFA_ContentLayoutItem*>(this);
-  while (pCurNode->m_pNext) {
-    pCurNode = pCurNode->m_pNext;
-    iCount++;
-  }
-  return iCount;
-}
-
-void CXFA_LayoutItem::AddChild(CXFA_LayoutItem* pChildItem) {
-  if (pChildItem->m_pParent) {
-    pChildItem->m_pParent->RemoveChild(pChildItem);
-  }
-  pChildItem->m_pParent = this;
-  if (m_pFirstChild == NULL) {
-    m_pFirstChild = pChildItem;
-  } else {
-    CXFA_LayoutItem* pExistingChildItem = m_pFirstChild;
-    while (pExistingChildItem->m_pNextSibling) {
-      pExistingChildItem = pExistingChildItem->m_pNextSibling;
-    }
-    pExistingChildItem->m_pNextSibling = pChildItem;
-  }
-}
-void CXFA_LayoutItem::AddHeadChild(CXFA_LayoutItem* pChildItem) {
-  if (pChildItem->m_pParent) {
-    pChildItem->m_pParent->RemoveChild(pChildItem);
-  }
-  pChildItem->m_pParent = this;
-  if (m_pFirstChild == NULL) {
-    m_pFirstChild = pChildItem;
-  } else {
-    CXFA_LayoutItem* pExistingChildItem = m_pFirstChild;
-    m_pFirstChild = pChildItem;
-    m_pFirstChild->m_pNextSibling = pExistingChildItem;
-  }
-}
-void CXFA_LayoutItem::InsertChild(CXFA_LayoutItem* pBeforeItem,
-                                  CXFA_LayoutItem* pChildItem) {
-  if (pBeforeItem->m_pParent != this) {
-    return;
-  }
-  if (pChildItem->m_pParent) {
-    pChildItem->m_pParent = NULL;
-  }
-  pChildItem->m_pParent = this;
-  CXFA_LayoutItem* pExistingChildItem = pBeforeItem->m_pNextSibling;
-  pBeforeItem->m_pNextSibling = pChildItem;
-  pChildItem->m_pNextSibling = pExistingChildItem;
-}
-void CXFA_LayoutItem::RemoveChild(CXFA_LayoutItem* pChildItem) {
-  if (pChildItem->m_pParent != this) {
-    return;
-  }
-  if (m_pFirstChild == pChildItem) {
-    m_pFirstChild = pChildItem->m_pNextSibling;
-  } else {
-    CXFA_LayoutItem* pExistingChildItem = m_pFirstChild;
-    while (pExistingChildItem &&
-           pExistingChildItem->m_pNextSibling != pChildItem) {
-      pExistingChildItem = pExistingChildItem->m_pNextSibling;
-    }
-    if (pExistingChildItem) {
-      pExistingChildItem->m_pNextSibling = pChildItem->m_pNextSibling;
-    }
-  }
-  pChildItem->m_pNextSibling = NULL;
-  pChildItem->m_pParent = NULL;
-}
-CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::ExtractLayoutItem() {
-  CXFA_ContentLayoutItem* pLayoutItem = m_pLayoutItem;
-  if (pLayoutItem) {
-    m_pLayoutItem = (CXFA_ContentLayoutItem*)pLayoutItem->m_pNextSibling;
-    pLayoutItem->m_pNextSibling = NULL;
-  }
-  if (m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done &&
-      ToContentLayoutItem(m_pOldLayoutItem)) {
-    if (m_pOldLayoutItem->m_pPrev) {
-      m_pOldLayoutItem->m_pPrev->m_pNext = NULL;
-    }
-    IXFA_Notify* pNotify =
-        m_pOldLayoutItem->m_pFormNode->GetDocument()->GetParser()->GetNotify();
-    IXFA_DocLayout* pDocLayout =
-        m_pOldLayoutItem->m_pFormNode->GetDocument()->GetDocLayout();
-    CXFA_ContentLayoutItem* pOldLayoutItem = m_pOldLayoutItem;
-    while (pOldLayoutItem) {
-      CXFA_ContentLayoutItem* pNextOldLayoutItem = pOldLayoutItem->m_pNext;
-      pNotify->OnLayoutEvent(pDocLayout, pOldLayoutItem,
-                             XFA_LAYOUTEVENT_ItemRemoving);
-      delete pOldLayoutItem;
-      pOldLayoutItem = pNextOldLayoutItem;
-    }
-    m_pOldLayoutItem = NULL;
-  }
-  return pLayoutItem;
-}
-static FX_BOOL XFA_ItemLayoutProcessor_FindBreakNode(
-    CXFA_Node* pContainerNode,
-    CXFA_Node*& pCurActionNode,
-    XFA_ItemLayoutProcessorStages& nCurStage,
-    FX_BOOL bBreakBefore) {
-  FX_BOOL bFindRs = FALSE;
-  for (CXFA_Node* pBreakNode = pContainerNode; pBreakNode;
-       pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_ATTRIBUTE eAttributeType = XFA_ATTRIBUTE_Before;
-    if (!bBreakBefore) {
-      eAttributeType = XFA_ATTRIBUTE_After;
-    }
-    switch (pBreakNode->GetClassID()) {
-      case XFA_ELEMENT_BreakBefore: {
-        if (bBreakBefore) {
-          pCurActionNode = pBreakNode;
-          nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
-          bFindRs = TRUE;
-        }
-      } break;
-      case XFA_ELEMENT_BreakAfter: {
-        if (!bBreakBefore) {
-          pCurActionNode = pBreakNode;
-          nCurStage = XFA_ItemLayoutProcessorStages_BreakAfter;
-          bFindRs = TRUE;
-        }
-      } break;
-      case XFA_ELEMENT_Break:
-        if (pBreakNode->GetEnum(eAttributeType) != XFA_ATTRIBUTEENUM_Auto) {
-          pCurActionNode = pBreakNode;
-          nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
-          if (!bBreakBefore) {
-            nCurStage = XFA_ItemLayoutProcessorStages_BreakAfter;
-          }
-          bFindRs = TRUE;
-          break;
-        }
-      default:
-        break;
-    }
-    if (bFindRs) {
-      break;
-    }
-  }
-  return bFindRs;
-}
-static void XFA_DeleteLayoutGeneratedNode(CXFA_Node* pGenerateNode) {
-  IXFA_Notify* pNotify = pGenerateNode->GetDocument()->GetParser()->GetNotify();
-  IXFA_DocLayout* pDocLayout = pGenerateNode->GetDocument()->GetDocLayout();
-  CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> sIterator(
-      pGenerateNode);
-  for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-       pNode = sIterator.MoveToNext()) {
-    CXFA_ContentLayoutItem* pCurLayoutItem =
-        (CXFA_ContentLayoutItem*)pNode->GetUserData(XFA_LAYOUTITEMKEY);
-    CXFA_ContentLayoutItem* pNextLayoutItem = NULL;
-    while (pCurLayoutItem) {
-      pNextLayoutItem = pCurLayoutItem->m_pNext;
-      pNotify->OnLayoutEvent(pDocLayout, pCurLayoutItem,
-                             XFA_LAYOUTEVENT_ItemRemoving);
-      delete pCurLayoutItem;
-      pCurLayoutItem = pNextLayoutItem;
-    }
-  }
-  pGenerateNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pGenerateNode);
-}
-void CXFA_ItemLayoutProcessor::XFA_ItemLayoutProcessor_GotoNextContainerNode(
-    CXFA_Node*& pCurActionNode,
-    XFA_ItemLayoutProcessorStages& nCurStage,
-    CXFA_Node* pParentContainer,
-    FX_BOOL bUsePageBreak) {
-  CXFA_Node* pEntireContainer = pParentContainer;
-  CXFA_Node* pChildContainer = XFA_LAYOUT_INVALIDNODE;
-  switch (nCurStage) {
-    case XFA_ItemLayoutProcessorStages_BreakBefore:
-    case XFA_ItemLayoutProcessorStages_BreakAfter: {
-      pChildContainer = pCurActionNode->GetNodeItem(XFA_NODEITEM_Parent);
-    } break;
-    case XFA_ItemLayoutProcessorStages_Keep:
-    case XFA_ItemLayoutProcessorStages_Container:
-      pChildContainer = pCurActionNode;
-      break;
-    default:
-      pChildContainer = XFA_LAYOUT_INVALIDNODE;
-      break;
-  }
-  switch (nCurStage) {
-    case XFA_ItemLayoutProcessorStages_Keep: {
-      CXFA_Node* pBreakAfterNode =
-          pChildContainer->GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (!m_bKeepBreakFinish &&
-          XFA_ItemLayoutProcessor_FindBreakNode(pBreakAfterNode, pCurActionNode,
-                                                nCurStage, FALSE)) {
-        return;
-      }
-      goto CheckNextChildContainer;
-    }
-    case XFA_ItemLayoutProcessorStages_None: {
-      pCurActionNode = XFA_LAYOUT_INVALIDNODE;
-      case XFA_ItemLayoutProcessorStages_BookendLeader:
-        for (CXFA_Node* pBookendNode =
-                 pCurActionNode == XFA_LAYOUT_INVALIDNODE
-                     ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
-                     : pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-             pBookendNode; pBookendNode = pBookendNode->GetNodeItem(
-                               XFA_NODEITEM_NextSibling)) {
-          switch (pBookendNode->GetClassID()) {
-            case XFA_ELEMENT_Bookend:
-            case XFA_ELEMENT_Break:
-              pCurActionNode = pBookendNode;
-              nCurStage = XFA_ItemLayoutProcessorStages_BookendLeader;
-              return;
-            default:
-              break;
-          }
-        }
-    }
-      {
-        pCurActionNode = XFA_LAYOUT_INVALIDNODE;
-        case XFA_ItemLayoutProcessorStages_BreakBefore:
-          if (pCurActionNode != XFA_LAYOUT_INVALIDNODE) {
-            CXFA_Node* pBreakBeforeNode =
-                pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-            if (!m_bKeepBreakFinish &&
-                XFA_ItemLayoutProcessor_FindBreakNode(
-                    pBreakBeforeNode, pCurActionNode, nCurStage, TRUE)) {
-              return;
-            }
-            if (m_bIsProcessKeep) {
-              if (ProcessKeepNodesForBreakBefore(pCurActionNode, nCurStage,
-                                                 pChildContainer)) {
-                return;
-              }
-              goto CheckNextChildContainer;
-            }
-            pCurActionNode = pChildContainer;
-            nCurStage = XFA_ItemLayoutProcessorStages_Container;
-            return;
-          }
-          goto CheckNextChildContainer;
-      }
-    case XFA_ItemLayoutProcessorStages_Container: {
-      pCurActionNode = XFA_LAYOUT_INVALIDNODE;
-      case XFA_ItemLayoutProcessorStages_BreakAfter: {
-        if (pCurActionNode == XFA_LAYOUT_INVALIDNODE) {
-          CXFA_Node* pBreakAfterNode =
-              pChildContainer->GetNodeItem(XFA_NODEITEM_FirstChild);
-          if (!m_bKeepBreakFinish &&
-              XFA_ItemLayoutProcessor_FindBreakNode(
-                  pBreakAfterNode, pCurActionNode, nCurStage, FALSE)) {
-            return;
-          }
-        } else {
-          CXFA_Node* pBreakAfterNode =
-              pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-          if (XFA_ItemLayoutProcessor_FindBreakNode(
-                  pBreakAfterNode, pCurActionNode, nCurStage, FALSE)) {
-            return;
-          }
-        }
-        goto CheckNextChildContainer;
-      }
-    }
-    CheckNextChildContainer : {
-      CXFA_Node* pNextChildContainer =
-          pChildContainer == XFA_LAYOUT_INVALIDNODE
-              ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild,
-                                              XFA_OBJECTTYPE_ContainerNode)
-              : pChildContainer->GetNodeItem(XFA_NODEITEM_NextSibling,
-                                             XFA_OBJECTTYPE_ContainerNode);
-      while (pNextChildContainer &&
-             pNextChildContainer->HasFlag(XFA_NODEFLAG_LayoutGeneratedNode)) {
-        CXFA_Node* pSaveNode = pNextChildContainer;
-        pNextChildContainer = pNextChildContainer->GetNodeItem(
-            XFA_NODEITEM_NextSibling, XFA_OBJECTTYPE_ContainerNode);
-        if (pSaveNode->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-          XFA_DeleteLayoutGeneratedNode(pSaveNode);
-        }
-      }
-      if (!pNextChildContainer) {
-        goto NoMoreChildContainer;
-      }
-      FX_BOOL bLastKeep = FALSE;
-      if (ProcessKeepNodesForCheckNext(pCurActionNode, nCurStage,
-                                       pNextChildContainer, bLastKeep)) {
-        return;
-      }
-      if (!m_bKeepBreakFinish && !bLastKeep &&
-          XFA_ItemLayoutProcessor_FindBreakNode(
-              pNextChildContainer->GetNodeItem(XFA_NODEITEM_FirstChild),
-              pCurActionNode, nCurStage, TRUE)) {
-        return;
-      }
-      pCurActionNode = pNextChildContainer;
-      if (m_bIsProcessKeep) {
-        nCurStage = XFA_ItemLayoutProcessorStages_Keep;
-      } else {
-        nCurStage = XFA_ItemLayoutProcessorStages_Container;
-      }
-      return;
-    }
-    NoMoreChildContainer : {
-      pCurActionNode = XFA_LAYOUT_INVALIDNODE;
-      case XFA_ItemLayoutProcessorStages_BookendTrailer:
-        for (CXFA_Node* pBookendNode =
-                 pCurActionNode == XFA_LAYOUT_INVALIDNODE
-                     ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
-                     : pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-             pBookendNode; pBookendNode = pBookendNode->GetNodeItem(
-                               XFA_NODEITEM_NextSibling)) {
-          switch (pBookendNode->GetClassID()) {
-            case XFA_ELEMENT_Bookend:
-            case XFA_ELEMENT_Break:
-              pCurActionNode = pBookendNode;
-              nCurStage = XFA_ItemLayoutProcessorStages_BookendTrailer;
-              return;
-            default:
-              break;
-          }
-        }
-    }
-    default:
-      pCurActionNode = NULL;
-      nCurStage = XFA_ItemLayoutProcessorStages_Done;
-  }
-}
-FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepNodesForCheckNext(
-    CXFA_Node*& pCurActionNode,
-    XFA_ItemLayoutProcessorStages& nCurStage,
-    CXFA_Node*& pNextContainer,
-    FX_BOOL& bLastKeepNode) {
-  const bool bCanSplit = pNextContainer->GetIntact() == XFA_ATTRIBUTEENUM_None;
-  FX_BOOL bNextKeep = FALSE;
-  if (XFA_ExistContainerKeep(pNextContainer, FALSE)) {
-    bNextKeep = TRUE;
-  }
-  if (bNextKeep && !bCanSplit) {
-    if (!m_bIsProcessKeep && !m_bKeepBreakFinish) {
-      m_pKeepHeadNode = pNextContainer;
-      m_bIsProcessKeep = TRUE;
-    }
-  } else {
-    if (m_bIsProcessKeep && m_pKeepHeadNode) {
-      m_pKeepTailNode = pNextContainer;
-      if (!m_bKeepBreakFinish &&
-          XFA_ItemLayoutProcessor_FindBreakNode(
-              pNextContainer->GetNodeItem(XFA_NODEITEM_FirstChild),
-              pCurActionNode, nCurStage, TRUE)) {
-        return TRUE;
-      } else {
-        pNextContainer = m_pKeepHeadNode;
-        m_bKeepBreakFinish = TRUE;
-        m_pKeepHeadNode = NULL;
-        m_pKeepTailNode = NULL;
-        m_bIsProcessKeep = FALSE;
-      }
-    } else {
-      if (m_bKeepBreakFinish) {
-        bLastKeepNode = TRUE;
-      }
-      m_bKeepBreakFinish = FALSE;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepNodesForBreakBefore(
-    CXFA_Node*& pCurActionNode,
-    XFA_ItemLayoutProcessorStages& nCurStage,
-    CXFA_Node* pContainerNode) {
-  if (m_pKeepTailNode == pContainerNode) {
-    pCurActionNode = m_pKeepHeadNode;
-    m_bKeepBreakFinish = TRUE;
-    m_pKeepHeadNode = NULL;
-    m_pKeepTailNode = NULL;
-    m_bIsProcessKeep = FALSE;
-    nCurStage = XFA_ItemLayoutProcessorStages_Container;
-    return TRUE;
-  }
-  CXFA_Node* pBreakAfterNode =
-      pContainerNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  if (XFA_ItemLayoutProcessor_FindBreakNode(pBreakAfterNode, pCurActionNode,
-                                            nCurStage, FALSE)) {
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL XFA_ItemLayoutProcessor_IsTakingSpace(CXFA_Node* pNode) {
-  XFA_ATTRIBUTEENUM ePresence = pNode->GetEnum(XFA_ATTRIBUTE_Presence);
-  return ePresence == XFA_ATTRIBUTEENUM_Visible ||
-         ePresence == XFA_ATTRIBUTEENUM_Invisible;
-}
-static inline void XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
-    CXFA_Node* pFormNode,
-    FX_FLOAT& fContainerWidth,
-    FX_FLOAT& fContainerHeight,
-    FX_BOOL& bContainerWidthAutoSize,
-    FX_BOOL& bContainerHeightAutoSize) {
-  fContainerWidth = 0;
-  fContainerHeight = 0;
-  bContainerWidthAutoSize = TRUE;
-  bContainerHeightAutoSize = TRUE;
-  XFA_ELEMENT eClassID = pFormNode->GetClassID();
-  CXFA_Measurement mTmpValue;
-  if (bContainerWidthAutoSize &&
-      (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup) &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_W, mTmpValue, FALSE) &&
-      mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
-    fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerWidthAutoSize = FALSE;
-  }
-  if (bContainerHeightAutoSize &&
-      (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup) &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_H, mTmpValue, FALSE) &&
-      mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
-    fContainerHeight = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerHeightAutoSize = FALSE;
-  }
-  if (bContainerWidthAutoSize && eClassID == XFA_ELEMENT_Subform &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxW, mTmpValue, FALSE) &&
-      mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
-    fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerWidthAutoSize = FALSE;
-  }
-  if (bContainerHeightAutoSize && eClassID == XFA_ELEMENT_Subform &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxH, mTmpValue, FALSE) &&
-      mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
-    fContainerHeight = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerHeightAutoSize = FALSE;
-  }
-}
-static inline void
-XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
-    CXFA_Node* pFormNode,
-    FX_BOOL bContainerWidthAutoSize,
-    FX_FLOAT fContentCalculatedWidth,
-    FX_FLOAT& fContainerWidth,
-    FX_BOOL bContainerHeightAutoSize,
-    FX_FLOAT fContentCalculatedHeight,
-    FX_FLOAT& fContainerHeight) {
-  CXFA_Node* pMarginNode = pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  CXFA_Measurement mTmpValue;
-  if (bContainerWidthAutoSize) {
-    fContainerWidth = fContentCalculatedWidth;
-    if (pMarginNode) {
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_LeftInset, mTmpValue, FALSE)) {
-        fContainerWidth += mTmpValue.ToUnit(XFA_UNIT_Pt);
-      }
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_RightInset, mTmpValue, FALSE)) {
-        fContainerWidth += mTmpValue.ToUnit(XFA_UNIT_Pt);
-      }
-    }
-  }
-  if (bContainerHeightAutoSize) {
-    fContainerHeight = fContentCalculatedHeight;
-    if (pMarginNode) {
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_TopInset, mTmpValue, FALSE)) {
-        fContainerHeight += mTmpValue.ToUnit(XFA_UNIT_Pt);
-      }
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_BottomInset, mTmpValue,
-                                  FALSE)) {
-        fContainerHeight += mTmpValue.ToUnit(XFA_UNIT_Pt);
-      }
-    }
-  }
-}
-void CXFA_ItemLayoutProcessor::CalculatePositionedContainerPos(
-    CXFA_Node* pNode,
-    FX_FLOAT fWidth,
-    FX_FLOAT fHeight,
-    FX_FLOAT& fAbsoluteX,
-    FX_FLOAT& fAbsoluteY) {
-  XFA_ATTRIBUTEENUM eAnchorType = pNode->GetEnum(XFA_ATTRIBUTE_AnchorType);
-  int32_t nAnchorType = 0;
-  switch (eAnchorType) {
-    case XFA_ATTRIBUTEENUM_TopLeft:
-      nAnchorType = 0;
-      break;
-    case XFA_ATTRIBUTEENUM_TopCenter:
-      nAnchorType = 1;
-      break;
-    case XFA_ATTRIBUTEENUM_TopRight:
-      nAnchorType = 2;
-      break;
-    case XFA_ATTRIBUTEENUM_MiddleLeft:
-      nAnchorType = 3;
-      break;
-    case XFA_ATTRIBUTEENUM_MiddleCenter:
-      nAnchorType = 4;
-      break;
-    case XFA_ATTRIBUTEENUM_MiddleRight:
-      nAnchorType = 5;
-      break;
-    case XFA_ATTRIBUTEENUM_BottomLeft:
-      nAnchorType = 6;
-      break;
-    case XFA_ATTRIBUTEENUM_BottomCenter:
-      nAnchorType = 7;
-      break;
-    case XFA_ATTRIBUTEENUM_BottomRight:
-      nAnchorType = 8;
-      break;
-    default:
-      break;
-  }
-  static const uint8_t nNextPos[4][9] = {{0, 1, 2, 3, 4, 5, 6, 7, 8},
-                                         {6, 3, 0, 7, 4, 1, 8, 5, 2},
-                                         {8, 7, 6, 5, 4, 3, 2, 1, 0},
-                                         {2, 5, 8, 1, 4, 7, 0, 3, 6}};
-
-  FX_FLOAT fAnchorX = pNode->GetMeasure(XFA_ATTRIBUTE_X).ToUnit(XFA_UNIT_Pt);
-  FX_FLOAT fAnchorY = pNode->GetMeasure(XFA_ATTRIBUTE_Y).ToUnit(XFA_UNIT_Pt);
-  int32_t nRotate =
-      FXSYS_round(pNode->GetMeasure(XFA_ATTRIBUTE_Rotate).GetValue());
-  nRotate = XFA_MapRotation(nRotate) / 90;
-  int32_t nAbsoluteAnchorType = nNextPos[nRotate][nAnchorType];
-  fAbsoluteX = fAnchorX;
-  fAbsoluteY = fAnchorY;
-  switch (nAbsoluteAnchorType / 3) {
-    case 1:
-      fAbsoluteY -= fHeight / 2;
-      break;
-    case 2:
-      fAbsoluteY -= fHeight;
-      break;
-    default:
-      break;
-  }
-  switch (nAbsoluteAnchorType % 3) {
-    case 1:
-      fAbsoluteX -= fWidth / 2;
-      break;
-    case 2:
-      fAbsoluteX -= fWidth;
-      break;
-    default:
-      break;
-  }
-}
-FX_BOOL CXFA_ItemLayoutProcessor::IncrementRelayoutNode(
-    CXFA_LayoutProcessor* pLayoutProcessor,
-    CXFA_Node* pNode,
-    CXFA_Node* pParentNode) {
-  return FALSE;
-}
-void CXFA_ItemLayoutProcessor::DoLayoutPageArea(
-    CXFA_ContainerLayoutItem* pPageAreaLayoutItem) {
-  CXFA_Node* pFormNode = pPageAreaLayoutItem->m_pFormNode;
-  CXFA_Node* pCurChildNode = XFA_LAYOUT_INVALIDNODE;
-  XFA_ItemLayoutProcessorStages nCurChildNodeStage =
-      XFA_ItemLayoutProcessorStages_None;
-  CXFA_LayoutItem* pBeforeItem = NULL;
-  for (XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           pCurChildNode, nCurChildNodeStage, pFormNode, FALSE);
-       pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           pCurChildNode, nCurChildNodeStage, pFormNode, FALSE)) {
-    if (nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
-      continue;
-    }
-    if (pCurChildNode->GetClassID() == XFA_ELEMENT_Variables) {
-      continue;
-    }
-    CXFA_ItemLayoutProcessor* pProcessor =
-        new CXFA_ItemLayoutProcessor(pCurChildNode, NULL);
-    pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
-    if (!pProcessor->HasLayoutItem()) {
-      delete pProcessor;
-      continue;
-    }
-    FX_FLOAT fWidth, fHeight;
-    pProcessor->GetCurrentComponentSize(fWidth, fHeight);
-    FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
-    CalculatePositionedContainerPos(pCurChildNode, fWidth, fHeight, fAbsoluteX,
-                                    fAbsoluteY);
-    pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
-    CXFA_LayoutItem* pProcessItem = pProcessor->ExtractLayoutItem();
-    if (pBeforeItem == NULL) {
-      pPageAreaLayoutItem->AddHeadChild(pProcessItem);
-    } else {
-      pPageAreaLayoutItem->InsertChild(pBeforeItem, pProcessItem);
-    }
-    pBeforeItem = pProcessItem;
-    delete pProcessor;
-  }
-  pBeforeItem = NULL;
-  CXFA_LayoutItem* pLayoutItem = pPageAreaLayoutItem->m_pFirstChild;
-  while (pLayoutItem) {
-    if (!pLayoutItem->IsContentLayoutItem() ||
-        pLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_Draw) {
-      pLayoutItem = pLayoutItem->m_pNextSibling;
-      continue;
-    }
-    if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_Draw) {
-      CXFA_LayoutItem* pNextLayoutItem = pLayoutItem->m_pNextSibling;
-      pPageAreaLayoutItem->RemoveChild(pLayoutItem);
-      if (pBeforeItem == NULL) {
-        pPageAreaLayoutItem->AddHeadChild(pLayoutItem);
-      } else {
-        pPageAreaLayoutItem->InsertChild(pBeforeItem, pLayoutItem);
-      }
-      pBeforeItem = pLayoutItem;
-      pLayoutItem = pNextLayoutItem;
-    }
-  }
-}
-void CXFA_ItemLayoutProcessor::DoLayoutPositionedContainer(
-    CXFA_LayoutContext* pContext) {
-  if (m_pLayoutItem)
-    return;
-
-  m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-  FX_BOOL bIgnoreXY = (m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout) !=
-                       XFA_ATTRIBUTEENUM_Position);
-  FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
-  XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
-      m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
-      bContainerHeightAutoSize);
-  FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
-  FX_FLOAT fHiddenContentCalculatedWidth = 0,
-           fHiddenContentCalculatedHeight = 0;
-  if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
-    XFA_ItemLayoutProcessor_GotoNextContainerNode(
-        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
-  }
-  int32_t iColIndex = 0;
-  for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
-    if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
-      continue;
-    }
-    if (m_pCurChildNode->GetClassID() == XFA_ELEMENT_Variables) {
-      continue;
-    }
-    CXFA_ItemLayoutProcessor* pProcessor =
-        new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
-    if (pContext && pContext->m_prgSpecifiedColumnWidths) {
-      int32_t iColSpan = m_pCurChildNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
-      if (iColSpan <=
-          pContext->m_prgSpecifiedColumnWidths->GetSize() - iColIndex) {
-        pContext->m_fCurColumnWidth = 0;
-        pContext->m_bCurColumnWidthAvaiable = TRUE;
-        if (iColSpan == -1)
-          iColSpan = pContext->m_prgSpecifiedColumnWidths->GetSize();
-        for (int32_t i = 0; iColIndex + i < iColSpan; ++i) {
-          pContext->m_fCurColumnWidth +=
-              pContext->m_prgSpecifiedColumnWidths->GetAt(iColIndex + i);
-        }
-        if (pContext->m_fCurColumnWidth == 0)
-          pContext->m_bCurColumnWidthAvaiable = FALSE;
-        iColIndex += iColSpan >= 0 ? iColSpan : 0;
-      }
-    }
-    pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX,
-                         pContext);
-    if (!pProcessor->HasLayoutItem()) {
-      delete pProcessor;
-      continue;
-    }
-    FX_FLOAT fWidth, fHeight;
-    pProcessor->GetCurrentComponentSize(fWidth, fHeight);
-    FX_BOOL bChangeParentSize = FALSE;
-    if (XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
-      bChangeParentSize = TRUE;
-    }
-    FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
-    if (!bIgnoreXY) {
-      CalculatePositionedContainerPos(m_pCurChildNode, fWidth, fHeight,
-                                      fAbsoluteX, fAbsoluteY);
-    }
-    pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
-    if (bContainerWidthAutoSize) {
-      FX_FLOAT fChildSuppliedWidth = fAbsoluteX + fWidth;
-      if (bChangeParentSize) {
-        if (fContentCalculatedWidth < fChildSuppliedWidth) {
-          fContentCalculatedWidth = fChildSuppliedWidth;
-        }
-      } else {
-        if (fHiddenContentCalculatedWidth < fChildSuppliedWidth &&
-            m_pCurChildNode->GetClassID() != XFA_ELEMENT_Subform) {
-          fHiddenContentCalculatedWidth = fChildSuppliedWidth;
-        }
-      }
-    }
-    if (bContainerHeightAutoSize) {
-      FX_FLOAT fChildSuppliedHeight = fAbsoluteY + fHeight;
-      if (bChangeParentSize) {
-        if (fContentCalculatedHeight < fChildSuppliedHeight) {
-          fContentCalculatedHeight = fChildSuppliedHeight;
-        }
-      } else {
-        if (fHiddenContentCalculatedHeight < fChildSuppliedHeight &&
-            m_pCurChildNode->GetClassID() != XFA_ELEMENT_Subform) {
-          fHiddenContentCalculatedHeight = fChildSuppliedHeight;
-        }
-      }
-    }
-    m_pLayoutItem->AddChild(pProcessor->ExtractLayoutItem());
-    delete pProcessor;
-  }
-  XFA_VERSION eVersion = m_pFormNode->GetDocument()->GetCurVersionMode();
-  if (fContentCalculatedWidth == 0 && eVersion < XFA_VERSION_207) {
-    fContentCalculatedWidth = fHiddenContentCalculatedWidth;
-  }
-  if (fContentCalculatedHeight == 0 && eVersion < XFA_VERSION_207) {
-    fContentCalculatedHeight = fHiddenContentCalculatedHeight;
-  }
-  XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
-      m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
-      fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
-      fContainerHeight);
-  SetCurrentComponentSize(fContainerWidth, fContainerHeight);
-}
-static inline void XFA_ItemLayoutProcessor_UpdateWidgetSize(
-    CXFA_ContentLayoutItem* pLayoutItem,
-    FX_FLOAT& fWidth,
-    FX_FLOAT& fHeight) {
-  CXFA_Node* pNode = pLayoutItem->m_pFormNode;
-  ASSERT(pNode);
-  XFA_ELEMENT eClassID = pNode->GetClassID();
-  switch (eClassID) {
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_SubformSet: {
-      if (fWidth < -XFA_LAYOUT_FLOAT_PERCISION) {
-        fWidth = pLayoutItem->m_sSize.x;
-      }
-      if (fHeight < -XFA_LAYOUT_FLOAT_PERCISION) {
-        fHeight = pLayoutItem->m_sSize.y;
-      }
-      break;
-    }
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_Field: {
-      pNode->GetDocument()->GetParser()->GetNotify()->StartFieldDrawLayout(
-          pNode, fWidth, fHeight);
-      break;
-    }
-    default:
-      ASSERT(FALSE);
-  }
-}
-static inline void XFA_ItemLayoutProcessor_RelocateTableRowCells(
-    CXFA_ContentLayoutItem* pLayoutRow,
-    const CFX_ArrayTemplate<FX_FLOAT>& rgSpecifiedColumnWidths,
-    XFA_ATTRIBUTEENUM eLayout) {
-  FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
-  XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
-      pLayoutRow->m_pFormNode, fContainerWidth, fContainerHeight,
-      bContainerWidthAutoSize, bContainerHeightAutoSize);
-  CXFA_Node* pMarginNode =
-      pLayoutRow->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
-  if (pMarginNode) {
-    fLeftInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
-    fTopInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
-    fRightInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
-    fBottomInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
-  }
-  FX_FLOAT fContentWidthLimit =
-      bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
-                              : fContainerWidth - fLeftInset - fRightInset;
-  FX_FLOAT fContentCurrentHeight =
-      pLayoutRow->m_sSize.y - fTopInset - fBottomInset;
-  FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
-  FX_FLOAT fCurrentColX = 0;
-  int32_t nCurrentColIdx = 0;
-  FX_BOOL bMetWholeRowCell = FALSE;
-  for (CXFA_ContentLayoutItem* pLayoutChild =
-           (CXFA_ContentLayoutItem*)pLayoutRow->m_pFirstChild;
-       pLayoutChild;
-       pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-    int32_t nOriginalColSpan =
-        pLayoutChild->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
-    int32_t nColSpan = nOriginalColSpan;
-    FX_FLOAT fColSpanWidth = 0;
-    if (nColSpan == -1 ||
-        nCurrentColIdx + nColSpan > rgSpecifiedColumnWidths.GetSize()) {
-      nColSpan = rgSpecifiedColumnWidths.GetSize() - nCurrentColIdx;
-    }
-    for (int32_t i = 0; i < nColSpan; i++) {
-      fColSpanWidth += rgSpecifiedColumnWidths[nCurrentColIdx + i];
-    }
-    if (nColSpan != nOriginalColSpan) {
-      fColSpanWidth = bMetWholeRowCell ? 0 : std::max(fColSpanWidth,
-                                                      pLayoutChild->m_sSize.y);
-    }
-    if (nOriginalColSpan == -1) {
-      bMetWholeRowCell = TRUE;
-    }
-    pLayoutChild->m_sPos = CFX_PointF(fCurrentColX, 0);
-    pLayoutChild->m_sSize.x = fColSpanWidth;
-    if (XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
-      fCurrentColX += fColSpanWidth;
-      nCurrentColIdx += nColSpan;
-      FX_FLOAT fNewHeight =
-          bContainerHeightAutoSize ? -1 : fContentCurrentHeight;
-      XFA_ItemLayoutProcessor_UpdateWidgetSize(pLayoutChild, fColSpanWidth,
-                                               fNewHeight);
-      pLayoutChild->m_sSize.y = fNewHeight;
-      if (bContainerHeightAutoSize) {
-        FX_FLOAT fChildSuppliedHeight = pLayoutChild->m_sSize.y;
-        if (fContentCalculatedHeight < fChildSuppliedHeight) {
-          fContentCalculatedHeight = fChildSuppliedHeight;
-        }
-      }
-    }
-  }
-  if (bContainerHeightAutoSize) {
-    for (CXFA_ContentLayoutItem* pLayoutChild =
-             (CXFA_ContentLayoutItem*)pLayoutRow->m_pFirstChild;
-         pLayoutChild;
-         pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-      XFA_ItemLayoutProcessor_UpdateWidgetSize(
-          pLayoutChild, pLayoutChild->m_sSize.x, fContentCalculatedHeight);
-      FX_FLOAT fOldChildHeight = pLayoutChild->m_sSize.y;
-      pLayoutChild->m_sSize.y = fContentCalculatedHeight;
-      CXFA_Node* pParaNode =
-          pLayoutChild->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Para);
-      if (pParaNode && pLayoutChild->m_pFirstChild) {
-        FX_FLOAT fOffHeight = fContentCalculatedHeight - fOldChildHeight;
-        XFA_ATTRIBUTEENUM eVType = pParaNode->GetEnum(XFA_ATTRIBUTE_VAlign);
-        switch (eVType) {
-          case XFA_ATTRIBUTEENUM_Middle:
-            fOffHeight = fOffHeight / 2;
-            break;
-          case XFA_ATTRIBUTEENUM_Bottom:
-            break;
-          case XFA_ATTRIBUTEENUM_Top:
-          default:
-            fOffHeight = 0;
-            break;
-        }
-        if (fOffHeight > 0) {
-          for (CXFA_ContentLayoutItem* pInnerLayoutChild =
-                   (CXFA_ContentLayoutItem*)pLayoutChild->m_pFirstChild;
-               pInnerLayoutChild;
-               pInnerLayoutChild =
-                   (CXFA_ContentLayoutItem*)pInnerLayoutChild->m_pNextSibling) {
-            pInnerLayoutChild->m_sPos.y += fOffHeight;
-          }
-        }
-      }
-    }
-  }
-  if (bContainerWidthAutoSize) {
-    FX_FLOAT fChildSuppliedWidth = fCurrentColX;
-    if (fContentWidthLimit < XFA_LAYOUT_FLOAT_MAX &&
-        fContentWidthLimit > fChildSuppliedWidth) {
-      fChildSuppliedWidth = fContentWidthLimit;
-    }
-    if (fContentCalculatedWidth < fChildSuppliedWidth) {
-      fContentCalculatedWidth = fChildSuppliedWidth;
-    }
-  } else {
-    fContentCalculatedWidth = fContainerWidth - fLeftInset - fRightInset;
-  }
-  if (pLayoutRow->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout) ==
-      XFA_ATTRIBUTEENUM_Rl_row) {
-    for (CXFA_ContentLayoutItem* pLayoutChild =
-             (CXFA_ContentLayoutItem*)pLayoutRow->m_pFirstChild;
-         pLayoutChild;
-         pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-      pLayoutChild->m_sPos.x = fContentCalculatedWidth -
-                               pLayoutChild->m_sPos.x - pLayoutChild->m_sSize.x;
-    }
-  }
-  XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
-      pLayoutRow->m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
-      fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
-      fContainerHeight);
-  pLayoutRow->m_sSize = CFX_SizeF(fContainerWidth, fContainerHeight);
-}
-void CXFA_ItemLayoutProcessor::DoLayoutTableContainer(CXFA_Node* pLayoutNode) {
-  if (m_pLayoutItem)
-    return;
-
-  if (pLayoutNode == NULL) {
-    pLayoutNode = m_pFormNode;
-  }
-  ASSERT(m_pCurChildNode == XFA_LAYOUT_INVALIDNODE);
-  m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-  FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
-  XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
-      m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
-      bContainerHeightAutoSize);
-  FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
-  CXFA_Node* pMarginNode =
-      m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  FX_FLOAT fLeftInset = 0;
-  FX_FLOAT fRightInset = 0;
-  if (pMarginNode) {
-    fLeftInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
-    fRightInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
-  }
-  FX_FLOAT fContentWidthLimit =
-      bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
-                              : fContainerWidth - fLeftInset - fRightInset;
-  CFX_WideStringC wsColumnWidths;
-  if (pLayoutNode->TryCData(XFA_ATTRIBUTE_ColumnWidths, wsColumnWidths)) {
-    CFX_WideStringArray widths;
-    if (FX_SeparateStringW(wsColumnWidths.GetPtr(), wsColumnWidths.GetLength(),
-                           L' ', widths) > 0) {
-      int32_t iCols = widths.GetSize();
-      CFX_WideString wsWidth;
-      for (int32_t i = 0; i < iCols; i++) {
-        wsWidth = widths[i];
-        wsWidth.TrimLeft(L' ');
-        if (!wsWidth.IsEmpty()) {
-          CXFA_Measurement measure(wsWidth);
-          m_rgSpecifiedColumnWidths.Add(measure.ToUnit(XFA_UNIT_Pt));
-        }
-      }
-    }
-  }
-  int32_t iSpecifiedColumnCount = m_rgSpecifiedColumnWidths.GetSize();
-  CXFA_LayoutContext layoutContext;
-  layoutContext.m_prgSpecifiedColumnWidths = &m_rgSpecifiedColumnWidths;
-  CXFA_LayoutContext* pLayoutContext =
-      iSpecifiedColumnCount > 0 ? &layoutContext : NULL;
-  if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
-    XFA_ItemLayoutProcessor_GotoNextContainerNode(
-        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
-  }
-  for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
-    layoutContext.m_bCurColumnWidthAvaiable = FALSE;
-    layoutContext.m_fCurColumnWidth = 0;
-    if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
-      continue;
-    }
-    CXFA_ItemLayoutProcessor* pProcessor =
-        new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
-    pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX,
-                         pLayoutContext);
-    if (!pProcessor->HasLayoutItem()) {
-      delete pProcessor;
-      continue;
-    }
-    m_pLayoutItem->AddChild(pProcessor->ExtractLayoutItem());
-    delete pProcessor;
-  }
-  int32_t iRowCount = 0, iColCount = 0;
-  {
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*> rgRowItems;
-    CFX_ArrayTemplate<int32_t> rgRowItemsSpan;
-    CFX_ArrayTemplate<FX_FLOAT> rgRowItemsWidth;
-    for (CXFA_ContentLayoutItem* pLayoutChild =
-             (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
-         pLayoutChild;
-         pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-      if (pLayoutChild->m_pFormNode->GetClassID() != XFA_ELEMENT_Subform) {
-        continue;
-      }
-      if (!XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
-        continue;
-      }
-      XFA_ATTRIBUTEENUM eLayout =
-          pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-      if (eLayout != XFA_ATTRIBUTEENUM_Row &&
-          eLayout != XFA_ATTRIBUTEENUM_Rl_row) {
-        continue;
-      }
-      if (CXFA_ContentLayoutItem* pRowLayoutCell =
-              (CXFA_ContentLayoutItem*)pLayoutChild->m_pFirstChild) {
-        rgRowItems.Add(pRowLayoutCell);
-        int32_t iColSpan =
-            pRowLayoutCell->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
-        rgRowItemsSpan.Add(iColSpan);
-        rgRowItemsWidth.Add(pRowLayoutCell->m_sSize.x);
-      }
-    }
-    iRowCount = rgRowItems.GetSize();
-    iColCount = 0;
-    FX_BOOL bMoreColumns = TRUE;
-    while (bMoreColumns) {
-      bMoreColumns = FALSE;
-      FX_BOOL bAutoCol = FALSE;
-      for (int32_t i = 0; i < iRowCount; i++) {
-        while (rgRowItems[i] && (rgRowItemsSpan[i] <= 0 ||
-                                 !XFA_ItemLayoutProcessor_IsTakingSpace(
-                                     rgRowItems[i]->m_pFormNode))) {
-          CXFA_ContentLayoutItem* pNewCell =
-              (CXFA_ContentLayoutItem*)rgRowItems[i]->m_pNextSibling;
-          if (rgRowItemsSpan[i] < 0 && XFA_ItemLayoutProcessor_IsTakingSpace(
-                                           rgRowItems[i]->m_pFormNode)) {
-            pNewCell = NULL;
-          }
-          rgRowItems[i] = pNewCell;
-          rgRowItemsSpan[i] =
-              pNewCell
-                  ? pNewCell->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan)
-                  : 0;
-          rgRowItemsWidth[i] = pNewCell ? pNewCell->m_sSize.x : 0;
-        }
-        CXFA_ContentLayoutItem* pCell = rgRowItems[i];
-        if (!pCell) {
-          continue;
-        }
-        bMoreColumns = TRUE;
-        if (rgRowItemsSpan[i] == 1) {
-          if (iColCount >= iSpecifiedColumnCount) {
-            for (int32_t j = 0, c = iColCount + 1 -
-                                    m_rgSpecifiedColumnWidths.GetSize();
-                 j < c; j++) {
-              m_rgSpecifiedColumnWidths.Add(0);
-            }
-          }
-          if (m_rgSpecifiedColumnWidths[iColCount] <
-              XFA_LAYOUT_FLOAT_PERCISION) {
-            bAutoCol = TRUE;
-          }
-          if (bAutoCol &&
-              m_rgSpecifiedColumnWidths[iColCount] < rgRowItemsWidth[i]) {
-            m_rgSpecifiedColumnWidths[iColCount] = rgRowItemsWidth[i];
-          }
-        }
-      }
-      if (bMoreColumns) {
-        FX_FLOAT fFinalColumnWidth = 0.0f;
-        if (iColCount < m_rgSpecifiedColumnWidths.GetSize())
-          fFinalColumnWidth = m_rgSpecifiedColumnWidths[iColCount];
-        for (int32_t i = 0; i < iRowCount; ++i) {
-          if (!rgRowItems[i])
-            continue;
-          --rgRowItemsSpan[i];
-          rgRowItemsWidth[i] -= fFinalColumnWidth;
-        }
-        ++iColCount;
-      }
-    }
-  }
-  FX_FLOAT fCurrentRowY = 0;
-  for (CXFA_ContentLayoutItem* pLayoutChild =
-           (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
-       pLayoutChild;
-       pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-    if (!XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
-      continue;
-    }
-    if (pLayoutChild->m_pFormNode->GetClassID() == XFA_ELEMENT_Subform) {
-      XFA_ATTRIBUTEENUM eSubformLayout =
-          pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-      if (eSubformLayout == XFA_ATTRIBUTEENUM_Row ||
-          eSubformLayout == XFA_ATTRIBUTEENUM_Rl_row) {
-        XFA_ItemLayoutProcessor_RelocateTableRowCells(
-            pLayoutChild, m_rgSpecifiedColumnWidths, eSubformLayout);
-      }
-    }
-    pLayoutChild->m_sPos.y = fCurrentRowY;
-    if (bContainerWidthAutoSize) {
-      pLayoutChild->m_sPos.x = 0;
-    } else {
-      switch (pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_HAlign)) {
-        case XFA_ATTRIBUTEENUM_Left:
-        default:
-          pLayoutChild->m_sPos.x = 0;
-          break;
-        case XFA_ATTRIBUTEENUM_Center:
-          pLayoutChild->m_sPos.x =
-              (fContentWidthLimit - pLayoutChild->m_sSize.x) / 2;
-          break;
-        case XFA_ATTRIBUTEENUM_Right:
-          pLayoutChild->m_sPos.x = fContentWidthLimit - pLayoutChild->m_sSize.x;
-          break;
-      }
-    }
-    if (bContainerWidthAutoSize) {
-      FX_FLOAT fChildSuppliedWidth =
-          pLayoutChild->m_sPos.x + pLayoutChild->m_sSize.x;
-      if (fContentWidthLimit < XFA_LAYOUT_FLOAT_MAX &&
-          fContentWidthLimit > fChildSuppliedWidth) {
-        fChildSuppliedWidth = fContentWidthLimit;
-      }
-      if (fContentCalculatedWidth < fChildSuppliedWidth) {
-        fContentCalculatedWidth = fChildSuppliedWidth;
-      }
-    }
-    fCurrentRowY += pLayoutChild->m_sSize.y;
-  }
-  if (bContainerHeightAutoSize) {
-    FX_FLOAT fChildSuppliedHeight = fCurrentRowY;
-    if (fContentCalculatedHeight < fChildSuppliedHeight) {
-      fContentCalculatedHeight = fChildSuppliedHeight;
-    }
-  }
-  XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
-      m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
-      fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
-      fContainerHeight);
-  SetCurrentComponentSize(fContainerWidth, fContainerHeight);
-}
-static uint8_t XFA_ItemLayoutProcessor_HAlignEnumToInt(
-    XFA_ATTRIBUTEENUM eHAlign) {
-  switch (eHAlign) {
-    case XFA_ATTRIBUTEENUM_Center:
-      return 1;
-    case XFA_ATTRIBUTEENUM_Right:
-      return 2;
-    case XFA_ATTRIBUTEENUM_Left:
-    default:
-      return 0;
-  }
-}
-static void XFA_ItemLayoutProcessor_UpdatePendedItemLayout(
-    CXFA_ItemLayoutProcessor* pProcessor,
-    CXFA_ContentLayoutItem* pLayoutItem) {
-  XFA_ATTRIBUTEENUM eLayout =
-      pLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-  switch (eLayout) {
-    case XFA_ATTRIBUTEENUM_Row:
-    case XFA_ATTRIBUTEENUM_Rl_row:
-      XFA_ItemLayoutProcessor_RelocateTableRowCells(
-          pLayoutItem, pProcessor->m_rgSpecifiedColumnWidths, eLayout);
-      break;
-    default:
-      break;
-  }
-}
-FX_BOOL CXFA_ItemLayoutProcessor::IsAddNewRowForTrailer(
-    CXFA_ContentLayoutItem* pTrailerItem) {
-  if (!pTrailerItem) {
-    return FALSE;
-  }
-  FX_FLOAT fWidth = pTrailerItem->m_sSize.x;
-  XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-  if (eLayout != XFA_ATTRIBUTEENUM_Tb && m_fWidthLimite > fWidth) {
-    return FALSE;
-  }
-  return TRUE;
-}
-static void XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
-    CXFA_ItemLayoutProcessor* pProcessor,
-    FX_FLOAT fSplitPos,
-    CXFA_ContentLayoutItem* pTrailerLayoutItem,
-    FX_BOOL bUseInherited = FALSE) {
-  if (!pTrailerLayoutItem) {
-    return;
-  }
-  FX_FLOAT fHeight = pTrailerLayoutItem->m_sSize.y;
-  if (bUseInherited) {
-    FX_FLOAT fNewSplitPos = 0;
-    if (fSplitPos - fHeight > XFA_LAYOUT_FLOAT_PERCISION) {
-      fNewSplitPos = pProcessor->FindSplitPos(fSplitPos - fHeight);
-    }
-    if (fNewSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
-      pProcessor->SplitLayoutItem(fNewSplitPos);
-    }
-    return;
-  }
-  XFA_ItemLayoutProcessor_UpdatePendedItemLayout(pProcessor,
-                                                 pTrailerLayoutItem);
-  CXFA_Node* pMarginNode =
-      pProcessor->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
-  if (pMarginNode) {
-    fLeftInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
-    fTopInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
-    fRightInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
-    fBottomInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
-  }
-  if (!pProcessor->IsAddNewRowForTrailer(pTrailerLayoutItem)) {
-    pTrailerLayoutItem->m_sPos.y = pProcessor->m_fLastRowY;
-    pTrailerLayoutItem->m_sPos.x = pProcessor->m_fLastRowWidth;
-    pProcessor->m_pLayoutItem->m_sSize.x += pTrailerLayoutItem->m_sSize.x;
-    pProcessor->m_pLayoutItem->AddChild(pTrailerLayoutItem);
-    return;
-  }
-  FX_FLOAT fNewSplitPos = 0;
-  if (fSplitPos - fHeight > XFA_LAYOUT_FLOAT_PERCISION) {
-    fNewSplitPos = pProcessor->FindSplitPos(fSplitPos - fHeight);
-  }
-  if (fNewSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
-    pProcessor->SplitLayoutItem(fNewSplitPos);
-    pTrailerLayoutItem->m_sPos.y = fNewSplitPos - fTopInset - fBottomInset;
-  } else {
-    pTrailerLayoutItem->m_sPos.y = fSplitPos - fTopInset - fBottomInset;
-  }
-  switch (pTrailerLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_HAlign)) {
-    case XFA_ATTRIBUTEENUM_Left:
-    default:
-      pTrailerLayoutItem->m_sPos.x = fLeftInset;
-      break;
-    case XFA_ATTRIBUTEENUM_Right:
-      pTrailerLayoutItem->m_sPos.x = pProcessor->m_pLayoutItem->m_sSize.x -
-                                     fRightInset -
-                                     pTrailerLayoutItem->m_sSize.x;
-      break;
-    case XFA_ATTRIBUTEENUM_Center:
-      pTrailerLayoutItem->m_sPos.x =
-          (pProcessor->m_pLayoutItem->m_sSize.x - fLeftInset - fRightInset -
-           pTrailerLayoutItem->m_sSize.x) /
-          2;
-      break;
-  }
-  pProcessor->m_pLayoutItem->m_sSize.y += fHeight;
-  pProcessor->m_pLayoutItem->AddChild(pTrailerLayoutItem);
-}
-static void XFA_ItemLayoutProcessor_AddLeaderAfterSplit(
-    CXFA_ItemLayoutProcessor* pProcessor,
-    CXFA_ContentLayoutItem* pLeaderLayoutItem) {
-  XFA_ItemLayoutProcessor_UpdatePendedItemLayout(pProcessor, pLeaderLayoutItem);
-  CXFA_Node* pMarginNode =
-      pProcessor->m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  FX_FLOAT fLeftInset = 0;
-  FX_FLOAT fRightInset = 0;
-  if (pMarginNode) {
-    fLeftInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
-    fRightInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
-  }
-  FX_FLOAT fHeight = pLeaderLayoutItem->m_sSize.y;
-  for (CXFA_ContentLayoutItem* pChildItem =
-           (CXFA_ContentLayoutItem*)pProcessor->m_pLayoutItem->m_pFirstChild;
-       pChildItem;
-       pChildItem = (CXFA_ContentLayoutItem*)pChildItem->m_pNextSibling) {
-    pChildItem->m_sPos.y += fHeight;
-  }
-  pLeaderLayoutItem->m_sPos.y = 0;
-  switch (pLeaderLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_HAlign)) {
-    case XFA_ATTRIBUTEENUM_Left:
-    default:
-      pLeaderLayoutItem->m_sPos.x = fLeftInset;
-      break;
-    case XFA_ATTRIBUTEENUM_Right:
-      pLeaderLayoutItem->m_sPos.x = pProcessor->m_pLayoutItem->m_sSize.x -
-                                    fRightInset - pLeaderLayoutItem->m_sSize.x;
-      break;
-    case XFA_ATTRIBUTEENUM_Center:
-      pLeaderLayoutItem->m_sPos.x =
-          (pProcessor->m_pLayoutItem->m_sSize.x - fLeftInset - fRightInset -
-           pLeaderLayoutItem->m_sSize.x) /
-          2;
-      break;
-  }
-  pProcessor->m_pLayoutItem->m_sSize.y += fHeight;
-  pProcessor->m_pLayoutItem->AddChild(pLeaderLayoutItem);
-}
-static void XFA_ItemLayoutProcessor_AddPendingNode(
-    CXFA_ItemLayoutProcessor* pProcessor,
-    CXFA_Node* pPendingNode,
-    FX_BOOL bBreakPending) {
-  pProcessor->m_PendingNodes.push_back(pPendingNode);
-  pProcessor->m_bBreakPending = bBreakPending;
-}
-static FX_FLOAT XFA_ItemLayoutProcessor_InsertPendingItems(
-    CXFA_ItemLayoutProcessor* pProcessor,
-    CXFA_Node* pCurChildNode) {
-  FX_FLOAT fTotalHeight = 0;
-  if (pProcessor->m_PendingNodes.empty()) {
-    return fTotalHeight;
-  }
-  if (!pProcessor->m_pLayoutItem) {
-    pProcessor->m_pLayoutItem =
-        pProcessor->CreateContentLayoutItem(pCurChildNode);
-    pProcessor->m_pLayoutItem->m_sSize.clear();
-  }
-  while (!pProcessor->m_PendingNodes.empty()) {
-    std::unique_ptr<CXFA_ItemLayoutProcessor> pPendingProcessor(
-        new CXFA_ItemLayoutProcessor(pProcessor->m_PendingNodes.front(),
-                                     nullptr));
-    pProcessor->m_PendingNodes.pop_front();
-    pPendingProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
-    CXFA_ContentLayoutItem* pPendingLayoutItem =
-        pPendingProcessor->HasLayoutItem()
-            ? pPendingProcessor->ExtractLayoutItem()
-            : nullptr;
-    if (pPendingLayoutItem) {
-      XFA_ItemLayoutProcessor_AddLeaderAfterSplit(pProcessor,
-                                                  pPendingLayoutItem);
-      if (pProcessor->m_bBreakPending) {
-        fTotalHeight += pPendingLayoutItem->m_sSize.y;
-      }
-    }
-  }
-  return fTotalHeight;
-}
-FX_FLOAT CXFA_ItemLayoutProcessor::InsertKeepLayoutItems() {
-  FX_FLOAT fTotalHeight = 0;
-  if (m_arrayKeepItems.GetSize()) {
-    if (!m_pLayoutItem) {
-      m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-      m_pLayoutItem->m_sSize.clear();
-    }
-    for (int32_t iIndex = m_arrayKeepItems.GetSize() - 1; iIndex >= 0;
-         iIndex--) {
-      XFA_ItemLayoutProcessor_AddLeaderAfterSplit(this,
-                                                  m_arrayKeepItems[iIndex]);
-      fTotalHeight += m_arrayKeepItems[iIndex]->m_sSize.y;
-    }
-    m_arrayKeepItems.RemoveAll();
-  }
-  return fTotalHeight;
-}
-FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepForSplite(
-    CXFA_ItemLayoutProcessor* pParentProcessor,
-    CXFA_ItemLayoutProcessor* pChildProcessor,
-    XFA_ItemLayoutProcessorResult eRetValue,
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& rgCurLineLayoutItem,
-    FX_FLOAT& fContentCurRowAvailWidth,
-    FX_FLOAT& fContentCurRowHeight,
-    FX_FLOAT& fContentCurRowY,
-    FX_BOOL& bAddedItemInRow,
-    FX_BOOL& bForceEndPage,
-    XFA_ItemLayoutProcessorResult& result) {
-  if (pParentProcessor == NULL || pChildProcessor == NULL) {
-    return FALSE;
-  }
-  if (pParentProcessor->m_pCurChildNode->GetIntact() !=
-          XFA_ATTRIBUTEENUM_None ||
-      !pChildProcessor->m_bHasAvailHeight) {
-    if (XFA_ExistContainerKeep(pParentProcessor->m_pCurChildNode, TRUE)) {
-      FX_FLOAT fChildWidth, fChildHeight;
-      pChildProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
-      CFX_ArrayTemplate<CXFA_ContentLayoutItem*> keepLayoutItems;
-      if (pParentProcessor->JudgePutNextPage(pParentProcessor->m_pLayoutItem,
-                                             fChildHeight, keepLayoutItems)) {
-        m_arrayKeepItems.RemoveAll();
-        for (int32_t iIndex = 0; iIndex < keepLayoutItems.GetSize(); iIndex++) {
-          CXFA_ContentLayoutItem* pItem = keepLayoutItems.GetAt(iIndex);
-          pParentProcessor->m_pLayoutItem->RemoveChild(pItem);
-          fContentCurRowY -= pItem->m_sSize.y;
-          m_arrayKeepItems.Add(pItem);
-        }
-        bAddedItemInRow = TRUE;
-        bForceEndPage = TRUE;
-        result = XFA_ItemLayoutProcessorResult_PageFullBreak;
-        return TRUE;
-      }
-      rgCurLineLayoutItem.Add(pChildProcessor->ExtractLayoutItem());
-      bAddedItemInRow = TRUE;
-      fContentCurRowAvailWidth -= fChildWidth;
-      if (fContentCurRowHeight < fChildHeight) {
-        fContentCurRowHeight = fChildHeight;
-      }
-      result = eRetValue;
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_ItemLayoutProcessor::JudgePutNextPage(
-    CXFA_ContentLayoutItem* pParentLayoutItem,
-    FX_FLOAT fChildHeight,
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& pKeepItems) {
-  if (pParentLayoutItem == NULL) {
-    return FALSE;
-  }
-  FX_FLOAT fItemsHeight = 0;
-  for (CXFA_ContentLayoutItem* pChildLayoutItem =
-           (CXFA_ContentLayoutItem*)pParentLayoutItem->m_pFirstChild;
-       pChildLayoutItem;
-       pChildLayoutItem =
-           (CXFA_ContentLayoutItem*)pChildLayoutItem->m_pNextSibling) {
-    if (XFA_ExistContainerKeep(pChildLayoutItem->m_pFormNode, FALSE)) {
-      pKeepItems.Add(pChildLayoutItem);
-      fItemsHeight += pChildLayoutItem->m_sSize.y;
-    } else {
-      pKeepItems.RemoveAll();
-      fItemsHeight = 0;
-    }
-  }
-  fItemsHeight += fChildHeight;
-  if (m_pPageMgr->GetNextAvailContentHeight(fItemsHeight)) {
-    return TRUE;
-  }
-  return FALSE;
-}
-void CXFA_ItemLayoutProcessor::ProcessUnUseBinds(CXFA_Node* pFormNode) {
-  if (!pFormNode) {
-    return;
-  }
-  CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> sIterator(
-      pFormNode);
-  for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
-       pNode = sIterator.MoveToNext()) {
-    if (pNode->IsContainerNode()) {
-      CXFA_Node* pBindNode = pNode->GetBindData();
-      if (pBindNode) {
-        pBindNode->RemoveBindItem(pNode);
-        pNode->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
-      }
-    }
-    pNode->SetFlag(XFA_NODEFLAG_UnusedNode);
-  }
-}
-void CXFA_ItemLayoutProcessor::ProcessUnUseOverFlow(
-    CXFA_Node* pLeaderNode,
-    CXFA_Node* pTrailerNode,
-    CXFA_ContentLayoutItem* pTrailerItem,
-    CXFA_Node* pFormNode) {
-  ProcessUnUseBinds(pLeaderNode);
-  ProcessUnUseBinds(pTrailerNode);
-  if (pFormNode == NULL) {
-    return;
-  }
-  if (pFormNode->GetClassID() == XFA_ELEMENT_Overflow ||
-      pFormNode->GetClassID() == XFA_ELEMENT_Break) {
-    pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-  if (pLeaderNode && pFormNode) {
-    pFormNode->RemoveChild(pLeaderNode);
-  }
-  if (pTrailerNode && pFormNode) {
-    pFormNode->RemoveChild(pTrailerNode);
-  }
-  if (pTrailerItem) {
-    XFA_ReleaseLayoutItem(pTrailerItem);
-  }
-}
-static XFA_ItemLayoutProcessorResult XFA_ItemLayoutProcessor_InsertFlowedItem(
-    CXFA_ItemLayoutProcessor* pThis,
-    CXFA_ItemLayoutProcessor*& pProcessor,
-    FX_BOOL bContainerWidthAutoSize,
-    FX_BOOL bContainerHeightAutoSize,
-    FX_FLOAT fContainerHeight,
-    XFA_ATTRIBUTEENUM eFlowStrategy,
-    uint8_t& uCurHAlignState,
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*>(&rgCurLineLayoutItems)[3],
-    FX_BOOL bUseBreakControl,
-    FX_FLOAT fAvailHeight,
-    FX_FLOAT fRealHeight,
-    FX_FLOAT& fContentCurRowY,
-    FX_FLOAT& fContentWidthLimit,
-    FX_FLOAT& fContentCurRowAvailWidth,
-    FX_FLOAT& fContentCurRowHeight,
-    FX_BOOL& bAddedItemInRow,
-    FX_BOOL& bForceEndPage,
-    CXFA_LayoutContext* pLayoutContext = NULL,
-    FX_BOOL bNewRow = FALSE) {
-  FX_BOOL bTakeSpace =
-      XFA_ItemLayoutProcessor_IsTakingSpace(pProcessor->m_pFormNode);
-  uint8_t uHAlign = XFA_ItemLayoutProcessor_HAlignEnumToInt(
-      pThis->m_pCurChildNode->GetEnum(XFA_ATTRIBUTE_HAlign));
-  if (bContainerWidthAutoSize) {
-    uHAlign = 0;
-  }
-  if ((eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb && uHAlign < uCurHAlignState) ||
-      (eFlowStrategy == XFA_ATTRIBUTEENUM_Rl_tb && uHAlign > uCurHAlignState)) {
-    return XFA_ItemLayoutProcessorResult_RowFullBreak;
-  }
-  uCurHAlignState = uHAlign;
-  FX_BOOL bIsOwnSplite =
-      pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None;
-  FX_BOOL bUseRealHeight =
-      bTakeSpace && bContainerHeightAutoSize && bIsOwnSplite &&
-      pProcessor->m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)->GetIntact() ==
-          XFA_ATTRIBUTEENUM_None;
-  FX_BOOL bIsTransHeight = bTakeSpace;
-  if (bIsTransHeight && !bIsOwnSplite) {
-    FX_BOOL bRootForceTb = FALSE;
-    XFA_ATTRIBUTEENUM eLayoutStrategy = XFA_ItemLayoutProcessor_GetLayout(
-        pProcessor->m_pFormNode, bRootForceTb);
-    if (eLayoutStrategy == XFA_ATTRIBUTEENUM_Lr_tb ||
-        eLayoutStrategy == XFA_ATTRIBUTEENUM_Rl_tb) {
-      bIsTransHeight = FALSE;
-    }
-  }
-  FX_BOOL bUseInherited = FALSE;
-  CXFA_LayoutContext layoutContext;
-  if (pThis->m_pPageMgr) {
-    CXFA_Node* pOverflowNode =
-        pThis->m_pPageMgr->QueryOverflow(pThis->m_pFormNode);
-    if (pOverflowNode) {
-      layoutContext.m_pOverflowNode = pOverflowNode;
-      layoutContext.m_pOverflowProcessor = pThis;
-      pLayoutContext = &layoutContext;
-    }
-  }
-  XFA_ItemLayoutProcessorResult eRetValue = XFA_ItemLayoutProcessorResult_Done;
-  if (!bNewRow ||
-      pProcessor->m_ePreProcessRs == XFA_ItemLayoutProcessorResult_Done) {
-    eRetValue = pProcessor->DoLayout(
-        bTakeSpace ? bUseBreakControl : FALSE,
-        bUseRealHeight ? fRealHeight - fContentCurRowY : XFA_LAYOUT_FLOAT_MAX,
-        bIsTransHeight ? fRealHeight - fContentCurRowY : XFA_LAYOUT_FLOAT_MAX,
-        pLayoutContext);
-    pProcessor->m_ePreProcessRs = eRetValue;
-  } else {
-    eRetValue = pProcessor->m_ePreProcessRs;
-    pProcessor->m_ePreProcessRs = XFA_ItemLayoutProcessorResult_Done;
-  }
-  if (pProcessor->HasLayoutItem() == FALSE) {
-    return eRetValue;
-  }
-  FX_FLOAT fChildWidth, fChildHeight;
-  pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
-  if (bUseRealHeight && fRealHeight < XFA_LAYOUT_FLOAT_PERCISION) {
-    fRealHeight = XFA_LAYOUT_FLOAT_MAX;
-    fAvailHeight = XFA_LAYOUT_FLOAT_MAX;
-  }
-  if (!bTakeSpace ||
-      (fChildWidth <= fContentCurRowAvailWidth + XFA_LAYOUT_FLOAT_PERCISION) ||
-      (fContentWidthLimit - fContentCurRowAvailWidth <=
-       XFA_LAYOUT_FLOAT_PERCISION)) {
-    CXFA_Node *pOverflowLeaderNode = NULL, *pOverflowTrailerNode = NULL,
-              *pFormNode = NULL;
-    CXFA_ContentLayoutItem* pTrailerLayoutItem = NULL;
-    FX_BOOL bIsAddTrailerHeight = FALSE;
-    if (pThis->m_pPageMgr &&
-        pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
-      pFormNode = pThis->m_pPageMgr->QueryOverflow(pProcessor->m_pFormNode);
-      if (pFormNode == NULL && pLayoutContext &&
-          pLayoutContext->m_pOverflowProcessor) {
-        pFormNode = pLayoutContext->m_pOverflowNode;
-        bUseInherited = TRUE;
-      }
-      if (pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                             pOverflowTrailerNode, FALSE,
-                                             FALSE)) {
-        if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowTrailerNode)) {
-          if (pOverflowTrailerNode) {
-            CXFA_ItemLayoutProcessor* pOverflowLeaderProcessor =
-                new CXFA_ItemLayoutProcessor(pOverflowTrailerNode, NULL);
-            pOverflowLeaderProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
-            pTrailerLayoutItem =
-                pOverflowLeaderProcessor->HasLayoutItem()
-                    ? pOverflowLeaderProcessor->ExtractLayoutItem()
-                    : NULL;
-            delete pOverflowLeaderProcessor;
-          }
-          if (bUseInherited) {
-            bIsAddTrailerHeight =
-                pThis->IsAddNewRowForTrailer(pTrailerLayoutItem);
-          } else {
-            bIsAddTrailerHeight =
-                pProcessor->IsAddNewRowForTrailer(pTrailerLayoutItem);
-          }
-          if (bIsAddTrailerHeight) {
-            FX_FLOAT fTrailerHeight = pTrailerLayoutItem->m_sSize.y;
-            fChildHeight += fTrailerHeight;
-            bIsAddTrailerHeight = TRUE;
-          }
-        }
-      }
-    }
-    if (!bTakeSpace ||
-        fContentCurRowY + fChildHeight <=
-            fAvailHeight + XFA_LAYOUT_FLOAT_PERCISION ||
-        (!bContainerHeightAutoSize &&
-         pThis->m_fUsedSize + fAvailHeight + XFA_LAYOUT_FLOAT_PERCISION >=
-             fContainerHeight)) {
-      if (!bTakeSpace || eRetValue == XFA_ItemLayoutProcessorResult_Done) {
-        if (pProcessor->m_bUseInheriated) {
-          if (pTrailerLayoutItem) {
-            XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
-                pProcessor, fChildHeight, pTrailerLayoutItem);
-          }
-          if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
-            XFA_ItemLayoutProcessor_AddPendingNode(pProcessor,
-                                                   pOverflowLeaderNode, FALSE);
-          }
-          pProcessor->m_bUseInheriated = FALSE;
-        } else {
-          if (bIsAddTrailerHeight) {
-            fChildHeight -= pTrailerLayoutItem->m_sSize.y;
-          }
-          pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                           pOverflowTrailerNode,
-                                           pTrailerLayoutItem, pFormNode);
-        }
-        CXFA_ContentLayoutItem* pChildLayoutItem =
-            pProcessor->ExtractLayoutItem();
-        if (XFA_ExistContainerKeep(pProcessor->m_pFormNode, FALSE) &&
-            pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
-          pThis->m_arrayKeepItems.Add(pChildLayoutItem);
-        } else {
-          pThis->m_arrayKeepItems.RemoveAll();
-        }
-        rgCurLineLayoutItems[uHAlign].Add(pChildLayoutItem);
-        bAddedItemInRow = TRUE;
-        if (bTakeSpace) {
-          fContentCurRowAvailWidth -= fChildWidth;
-          if (fContentCurRowHeight < fChildHeight) {
-            fContentCurRowHeight = fChildHeight;
-          }
-        }
-        return XFA_ItemLayoutProcessorResult_Done;
-      } else {
-        if (eRetValue == XFA_ItemLayoutProcessorResult_PageFullBreak) {
-          if (pProcessor->m_bUseInheriated) {
-            if (pTrailerLayoutItem) {
-              XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
-                  pProcessor, fChildHeight, pTrailerLayoutItem);
-            }
-            if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
-              XFA_ItemLayoutProcessor_AddPendingNode(
-                  pProcessor, pOverflowLeaderNode, FALSE);
-            }
-            pProcessor->m_bUseInheriated = FALSE;
-          } else {
-            if (bIsAddTrailerHeight) {
-              fChildHeight -= pTrailerLayoutItem->m_sSize.y;
-            }
-            pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                             pOverflowTrailerNode,
-                                             pTrailerLayoutItem, pFormNode);
-          }
-        }
-        rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-        bAddedItemInRow = TRUE;
-        fContentCurRowAvailWidth -= fChildWidth;
-        if (fContentCurRowHeight < fChildHeight) {
-          fContentCurRowHeight = fChildHeight;
-        }
-        return eRetValue;
-      }
-    } else {
-      XFA_ItemLayoutProcessorResult eResult;
-      if (pThis->ProcessKeepForSplite(
-              pThis, pProcessor, eRetValue, rgCurLineLayoutItems[uHAlign],
-              fContentCurRowAvailWidth, fContentCurRowHeight, fContentCurRowY,
-              bAddedItemInRow, bForceEndPage, eResult)) {
-        return eResult;
-      }
-      bForceEndPage = TRUE;
-      FX_FLOAT fSplitPos =
-          pProcessor->FindSplitPos(fAvailHeight - fContentCurRowY);
-      if (fSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
-        XFA_ATTRIBUTEENUM eLayout =
-            pProcessor->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-        if (eLayout == XFA_ATTRIBUTEENUM_Tb &&
-            eRetValue == XFA_ItemLayoutProcessorResult_Done) {
-          pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                           pOverflowTrailerNode,
-                                           pTrailerLayoutItem, pFormNode);
-          rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-          bAddedItemInRow = TRUE;
-          if (bTakeSpace) {
-            fContentCurRowAvailWidth -= fChildWidth;
-            if (fContentCurRowHeight < fChildHeight) {
-              fContentCurRowHeight = fChildHeight;
-            }
-          }
-          return XFA_ItemLayoutProcessorResult_PageFullBreak;
-        }
-        CXFA_Node *pTempLeaderNode = NULL, *pTempTrailerNode = NULL;
-        if (pThis->m_pPageMgr && !pProcessor->m_bUseInheriated &&
-            eRetValue != XFA_ItemLayoutProcessorResult_PageFullBreak) {
-          pThis->m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
-                                             pTempTrailerNode, FALSE, TRUE);
-        }
-        if (pTrailerLayoutItem && bIsAddTrailerHeight) {
-          XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
-              pProcessor, fSplitPos, pTrailerLayoutItem, bUseInherited);
-        } else {
-          pProcessor->SplitLayoutItem(fSplitPos);
-        }
-        if (bUseInherited) {
-          pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                           pOverflowTrailerNode,
-                                           pTrailerLayoutItem, pFormNode);
-          pThis->m_bUseInheriated = TRUE;
-        } else {
-          if (pProcessor->m_pLayoutItem->m_pFirstChild &&
-              pProcessor->m_pLayoutItem->m_pFirstChild->m_pNextSibling ==
-                  NULL &&
-              pProcessor->m_pLayoutItem->m_pFirstChild->m_pFormNode->HasFlag(
-                  XFA_NODEFLAG_LayoutGeneratedNode)) {
-            pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                             pOverflowTrailerNode,
-                                             pTrailerLayoutItem, pFormNode);
-          } else {
-            if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
-              XFA_ItemLayoutProcessor_AddPendingNode(
-                  pProcessor, pOverflowLeaderNode, FALSE);
-            }
-          }
-        }
-        if (pProcessor->m_pLayoutItem->m_pNextSibling) {
-          pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
-          rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-          bAddedItemInRow = TRUE;
-          if (bTakeSpace) {
-            fContentCurRowAvailWidth -= fChildWidth;
-            if (fContentCurRowHeight < fChildHeight) {
-              fContentCurRowHeight = fChildHeight;
-            }
-          }
-        }
-        return XFA_ItemLayoutProcessorResult_PageFullBreak;
-      } else if (fContentCurRowY <= XFA_LAYOUT_FLOAT_PERCISION) {
-        pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
-        if (pProcessor->m_pPageMgr->GetNextAvailContentHeight(fChildHeight)) {
-          CXFA_Node *pTempLeaderNode = NULL, *pTempTrailerNode = NULL;
-          if (pThis->m_pPageMgr) {
-            if (pFormNode == NULL && pLayoutContext) {
-              pFormNode = pLayoutContext->m_pOverflowProcessor->m_pFormNode;
-            }
-            pThis->m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
-                                               pTempTrailerNode, FALSE, TRUE);
-          }
-          if (bUseInherited) {
-            pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                             pOverflowTrailerNode,
-                                             pTrailerLayoutItem, pFormNode);
-            pThis->m_bUseInheriated = TRUE;
-          }
-          return XFA_ItemLayoutProcessorResult_PageFullBreak;
-        }
-        rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-        bAddedItemInRow = TRUE;
-        if (bTakeSpace) {
-          fContentCurRowAvailWidth -= fChildWidth;
-          if (fContentCurRowHeight < fChildHeight) {
-            fContentCurRowHeight = fChildHeight;
-          }
-        }
-        if (eRetValue == XFA_ItemLayoutProcessorResult_Done) {
-          bForceEndPage = FALSE;
-        }
-        return eRetValue;
-      } else {
-        XFA_ATTRIBUTEENUM eLayout =
-            pProcessor->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-        if (pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None &&
-            eLayout == XFA_ATTRIBUTEENUM_Tb) {
-          if (pThis->m_pPageMgr) {
-            pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                               pOverflowTrailerNode, FALSE,
-                                               TRUE);
-          }
-          if (pTrailerLayoutItem) {
-            XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(pProcessor, fSplitPos,
-                                                          pTrailerLayoutItem);
-          }
-          if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
-            XFA_ItemLayoutProcessor_AddPendingNode(pProcessor,
-                                                   pOverflowLeaderNode, FALSE);
-          }
-        } else {
-          if (eRetValue == XFA_ItemLayoutProcessorResult_Done) {
-            if (pFormNode == NULL && pLayoutContext) {
-              pFormNode = pLayoutContext->m_pOverflowProcessor->m_pFormNode;
-            }
-            if (pThis->m_pPageMgr) {
-              pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                                 pOverflowTrailerNode, FALSE,
-                                                 TRUE);
-            }
-            if (bUseInherited) {
-              pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
-                                               pOverflowTrailerNode,
-                                               pTrailerLayoutItem, pFormNode);
-              pThis->m_bUseInheriated = TRUE;
-            }
-          }
-        }
-        return XFA_ItemLayoutProcessorResult_PageFullBreak;
-      }
-    }
-  } else {
-    return XFA_ItemLayoutProcessorResult_RowFullBreak;
-  }
-  return XFA_ItemLayoutProcessorResult_Done;
-}
-XFA_ItemLayoutProcessorResult CXFA_ItemLayoutProcessor::DoLayoutFlowedContainer(
-    FX_BOOL bUseBreakControl,
-    XFA_ATTRIBUTEENUM eFlowStrategy,
-    FX_FLOAT fHeightLimit,
-    FX_FLOAT fRealHeight,
-    CXFA_LayoutContext* pContext,
-    FX_BOOL bRootForceTb) {
-  m_bHasAvailHeight = TRUE;
-  FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bBreakDone = FALSE;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
-  FX_BOOL bForceEndPage = FALSE;
-  FX_BOOL bIsManualBreak = FALSE;
-  if (m_pCurChildPreprocessor) {
-    m_pCurChildPreprocessor->m_ePreProcessRs =
-        XFA_ItemLayoutProcessorResult_Done;
-  }
-  XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
-      m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
-      bContainerHeightAutoSize);
-  if (pContext && pContext->m_bCurColumnWidthAvaiable) {
-    bContainerWidthAutoSize = FALSE;
-    fContainerWidth = pContext->m_fCurColumnWidth;
-  }
-  if (!bContainerHeightAutoSize) {
-    fContainerHeight -= m_fUsedSize;
-  }
-  if (!bContainerHeightAutoSize) {
-    CXFA_Node* pParentNode = m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
-    FX_BOOL bFocrTb = FALSE;
-    if (pParentNode &&
-        XFA_ItemLayoutProcessor_GetLayout(pParentNode, bFocrTb) ==
-            XFA_ATTRIBUTEENUM_Row) {
-      CXFA_Node* pChildContainer = m_pFormNode->GetNodeItem(
-          XFA_NODEITEM_FirstChild, XFA_OBJECTTYPE_ContainerNode);
-      if (pChildContainer &&
-          pChildContainer->GetNodeItem(XFA_NODEITEM_NextSibling,
-                                       XFA_OBJECTTYPE_ContainerNode)) {
-        fContainerHeight = 0;
-        bContainerHeightAutoSize = TRUE;
-      }
-    }
-  }
-  CXFA_Node* pMarginNode =
-      m_pFormNode->GetFirstChildByClass(XFA_ELEMENT_Margin);
-  FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
-  if (pMarginNode) {
-    fLeftInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
-    fTopInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
-    fRightInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
-    fBottomInset =
-        pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
-  }
-  FX_FLOAT fContentWidthLimit =
-      bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
-                              : fContainerWidth - fLeftInset - fRightInset;
-  FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
-  FX_FLOAT fAvailHeight = fHeightLimit - fTopInset - fBottomInset;
-  if (fAvailHeight < 0) {
-    m_bHasAvailHeight = FALSE;
-  }
-  fRealHeight = fRealHeight - fTopInset - fBottomInset;
-  FX_FLOAT fContentCurRowY = 0;
-  CXFA_ContentLayoutItem* pLayoutChild = NULL;
-  if (m_pLayoutItem) {
-    if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done &&
-        eFlowStrategy != XFA_ATTRIBUTEENUM_Tb) {
-      pLayoutChild = (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
-      for (CXFA_ContentLayoutItem* pLayoutNext = pLayoutChild; pLayoutNext;
-           pLayoutNext = (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
-        if (pLayoutNext->m_sPos.y != pLayoutChild->m_sPos.y) {
-          pLayoutChild = pLayoutNext;
-        }
-      }
-    }
-    for (CXFA_ContentLayoutItem* pLayoutTempChild =
-             (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
-         pLayoutTempChild != pLayoutChild;
-         pLayoutTempChild =
-             (CXFA_ContentLayoutItem*)pLayoutTempChild->m_pNextSibling) {
-      if (XFA_ItemLayoutProcessor_IsTakingSpace(
-              pLayoutTempChild->m_pFormNode)) {
-        FX_FLOAT fChildContentWidth =
-            pLayoutTempChild->m_sPos.x + pLayoutTempChild->m_sSize.x;
-        FX_FLOAT fChildContentHeight =
-            pLayoutTempChild->m_sPos.y + pLayoutTempChild->m_sSize.y;
-        if (fContentCalculatedWidth < fChildContentWidth) {
-          fContentCalculatedWidth = fChildContentWidth;
-        }
-        if (fContentCalculatedHeight < fChildContentHeight) {
-          fContentCalculatedHeight = fChildContentHeight;
-        }
-      }
-    }
-    if (pLayoutChild) {
-      fContentCurRowY = pLayoutChild->m_sPos.y;
-    } else {
-      fContentCurRowY = fContentCalculatedHeight;
-    }
-  }
-  fContentCurRowY += InsertKeepLayoutItems();
-  if (m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_None) {
-    XFA_ItemLayoutProcessor_GotoNextContainerNode(
-        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
-  }
-  fContentCurRowY +=
-      XFA_ItemLayoutProcessor_InsertPendingItems(this, m_pFormNode);
-  if (m_pCurChildPreprocessor &&
-      m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Container) {
-    if (XFA_ExistContainerKeep(m_pCurChildPreprocessor->GetFormNode(), FALSE)) {
-      m_pKeepHeadNode = m_pCurChildNode;
-      m_bIsProcessKeep = TRUE;
-      m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Keep;
-    }
-  }
-  while (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done) {
-    FX_FLOAT fContentCurRowHeight = 0;
-    FX_FLOAT fContentCurRowAvailWidth = fContentWidthLimit;
-    m_fWidthLimite = fContentCurRowAvailWidth;
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*> rgCurLineLayoutItems[3];
-    uint8_t uCurHAlignState =
-        (eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb ? 0 : 2);
-    if (pLayoutChild) {
-      for (CXFA_ContentLayoutItem* pLayoutNext = pLayoutChild; pLayoutNext;
-           pLayoutNext = (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
-        if (pLayoutNext->m_pNextSibling == NULL && m_pCurChildPreprocessor &&
-            m_pCurChildPreprocessor->m_pFormNode == pLayoutNext->m_pFormNode) {
-          pLayoutNext->m_pNext = m_pCurChildPreprocessor->m_pLayoutItem;
-          m_pCurChildPreprocessor->m_pLayoutItem = pLayoutNext;
-          break;
-        }
-        uint8_t uHAlign = XFA_ItemLayoutProcessor_HAlignEnumToInt(
-            pLayoutNext->m_pFormNode->GetEnum(XFA_ATTRIBUTE_HAlign));
-        rgCurLineLayoutItems[uHAlign].Add(pLayoutNext);
-        if (eFlowStrategy == XFA_ATTRIBUTEENUM_Lr_tb) {
-          if (uHAlign > uCurHAlignState) {
-            uCurHAlignState = uHAlign;
-          }
-        } else if (uHAlign < uCurHAlignState) {
-          uCurHAlignState = uHAlign;
-        }
-        if (XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutNext->m_pFormNode)) {
-          if (pLayoutNext->m_sSize.y > fContentCurRowHeight) {
-            fContentCurRowHeight = pLayoutNext->m_sSize.y;
-          }
-          fContentCurRowAvailWidth -= pLayoutNext->m_sSize.x;
-        }
-      }
-      if ((CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild ==
-          pLayoutChild) {
-        m_pLayoutItem->m_pFirstChild = NULL;
-      } else {
-        CXFA_ContentLayoutItem* pLayoutNext =
-            (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
-        for (; pLayoutNext;
-             pLayoutNext =
-                 (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
-          if ((CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling ==
-              pLayoutChild) {
-            pLayoutNext->m_pNextSibling = NULL;
-            break;
-          }
-        }
-      }
-      CXFA_ContentLayoutItem* pLayoutNextTemp =
-          (CXFA_ContentLayoutItem*)pLayoutChild;
-      while (pLayoutNextTemp) {
-        pLayoutNextTemp->m_pParent = NULL;
-        CXFA_ContentLayoutItem* pSaveLayoutNext =
-            (CXFA_ContentLayoutItem*)pLayoutNextTemp->m_pNextSibling;
-        pLayoutNextTemp->m_pNextSibling = NULL;
-        pLayoutNextTemp = pSaveLayoutNext;
-      }
-      pLayoutChild = NULL;
-    }
-    while (m_pCurChildNode) {
-      CXFA_ItemLayoutProcessor* pProcessor = NULL;
-      FX_BOOL bAddedItemInRow = FALSE;
-      fContentCurRowY +=
-          XFA_ItemLayoutProcessor_InsertPendingItems(this, m_pFormNode);
-      switch (m_nCurChildNodeStage) {
-        case XFA_ItemLayoutProcessorStages_Keep:
-        case XFA_ItemLayoutProcessorStages_None:
-          break;
-        case XFA_ItemLayoutProcessorStages_BreakBefore: {
-          for (int32_t iIndex = 0; iIndex < m_arrayKeepItems.GetSize();
-               iIndex++) {
-            CXFA_ContentLayoutItem* pItem = m_arrayKeepItems.GetAt(iIndex);
-            m_pLayoutItem->RemoveChild(pItem);
-            fContentCalculatedHeight -= pItem->m_sSize.y;
-          }
-          CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
-          FX_BOOL bCreatePage = FALSE;
-          if (bUseBreakControl && m_pPageMgr &&
-              m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, TRUE,
-                                                    pLeaderNode, pTrailerNode,
-                                                    bCreatePage) &&
-              m_pFormNode->GetClassID() != XFA_ELEMENT_Form && bCreatePage) {
-            if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
-              XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
-            }
-            if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
-              if (m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)->GetClassID() ==
-                      XFA_ELEMENT_Form &&
-                  m_pLayoutItem == NULL) {
-                XFA_ItemLayoutProcessor_AddPendingNode(this, pTrailerNode,
-                                                       TRUE);
-              } else {
-                CXFA_ItemLayoutProcessor* pProcessor =
-                    new CXFA_ItemLayoutProcessor(pTrailerNode, NULL);
-                XFA_ItemLayoutProcessor_InsertFlowedItem(
-                    this, pProcessor, bContainerWidthAutoSize,
-                    bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, FALSE,
-                    XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
-                    fContentWidthLimit, fContentCurRowAvailWidth,
-                    fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
-                    pContext);
-                delete pProcessor;
-                pProcessor = NULL;
-              }
-            }
-            XFA_ItemLayoutProcessor_GotoNextContainerNode(
-                m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
-            bForceEndPage = TRUE;
-            bIsManualBreak = TRUE;
-            goto SuspendAndCreateNewRow;
-          }
-        } break;
-        case XFA_ItemLayoutProcessorStages_BreakAfter: {
-          CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
-          FX_BOOL bCreatePage = FALSE;
-          if (bUseBreakControl && m_pPageMgr &&
-              m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, FALSE,
-                                                    pLeaderNode, pTrailerNode,
-                                                    bCreatePage) &&
-              m_pFormNode->GetClassID() != XFA_ELEMENT_Form) {
-            if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
-              CXFA_ItemLayoutProcessor* pProcessor =
-                  new CXFA_ItemLayoutProcessor(pTrailerNode, NULL);
-              XFA_ItemLayoutProcessor_InsertFlowedItem(
-                  this, pProcessor, bContainerWidthAutoSize,
-                  bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                  uCurHAlignState, rgCurLineLayoutItems, FALSE,
-                  XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
-                  fContentWidthLimit, fContentCurRowAvailWidth,
-                  fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
-                  pContext);
-              delete pProcessor;
-              pProcessor = NULL;
-            }
-            if (!bCreatePage) {
-              if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
-                CalculateRowChildPosition(
-                    rgCurLineLayoutItems, eFlowStrategy,
-                    bContainerHeightAutoSize, bContainerWidthAutoSize,
-                    fContentCalculatedWidth, fContentCalculatedHeight,
-                    fContentCurRowY, fContentCurRowHeight, fContentWidthLimit);
-                rgCurLineLayoutItems->RemoveAll();
-                CXFA_ItemLayoutProcessor* pProcessor =
-                    new CXFA_ItemLayoutProcessor(pLeaderNode, NULL);
-                XFA_ItemLayoutProcessor_InsertFlowedItem(
-                    this, pProcessor, bContainerWidthAutoSize,
-                    bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, FALSE,
-                    XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
-                    fContentWidthLimit, fContentCurRowAvailWidth,
-                    fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
-                    pContext);
-                delete pProcessor;
-                pProcessor = NULL;
-              }
-            } else {
-              if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
-                XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
-              }
-            }
-            XFA_ItemLayoutProcessor_GotoNextContainerNode(
-                m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
-            if (bCreatePage) {
-              bForceEndPage = TRUE;
-              bIsManualBreak = TRUE;
-              if (m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done) {
-                bBreakDone = TRUE;
-              }
-            }
-            goto SuspendAndCreateNewRow;
-          }
-        } break;
-        case XFA_ItemLayoutProcessorStages_BookendLeader: {
-          CXFA_Node* pLeaderNode = NULL;
-          if (m_pCurChildPreprocessor) {
-            pProcessor = m_pCurChildPreprocessor;
-            m_pCurChildPreprocessor = NULL;
-          } else if (m_pPageMgr &&
-                     m_pPageMgr->ProcessBookendLeaderOrTrailer(
-                         m_pCurChildNode, TRUE, pLeaderNode)) {
-            pProcessor = new CXFA_ItemLayoutProcessor(pLeaderNode, m_pPageMgr);
-          }
-          if (pProcessor) {
-            if (XFA_ItemLayoutProcessor_InsertFlowedItem(
-                    this, pProcessor, bContainerWidthAutoSize,
-                    bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
-                    fAvailHeight, fRealHeight, fContentCurRowY,
-                    fContentWidthLimit, fContentCurRowAvailWidth,
-                    fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
-                    pContext) != XFA_ItemLayoutProcessorResult_Done) {
-              goto SuspendAndCreateNewRow;
-            } else {
-              delete pProcessor;
-              pProcessor = NULL;
-            }
-          }
-        } break;
-        case XFA_ItemLayoutProcessorStages_BookendTrailer: {
-          CXFA_Node* pTrailerNode = NULL;
-          if (m_pCurChildPreprocessor) {
-            pProcessor = m_pCurChildPreprocessor;
-            m_pCurChildPreprocessor = NULL;
-          } else if (m_pPageMgr &&
-                     m_pPageMgr->ProcessBookendLeaderOrTrailer(
-                         m_pCurChildNode, FALSE, pTrailerNode)) {
-            pProcessor = new CXFA_ItemLayoutProcessor(pTrailerNode, m_pPageMgr);
-          }
-          if (pProcessor) {
-            if (XFA_ItemLayoutProcessor_InsertFlowedItem(
-                    this, pProcessor, bContainerWidthAutoSize,
-                    bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
-                    fAvailHeight, fRealHeight, fContentCurRowY,
-                    fContentWidthLimit, fContentCurRowAvailWidth,
-                    fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
-                    pContext) != XFA_ItemLayoutProcessorResult_Done) {
-              goto SuspendAndCreateNewRow;
-            } else {
-              delete pProcessor;
-              pProcessor = NULL;
-            }
-          }
-        } break;
-        case XFA_ItemLayoutProcessorStages_Container:
-          ASSERT(m_pCurChildNode->IsContainerNode());
-          if (m_pCurChildNode->GetClassID() == XFA_ELEMENT_Variables) {
-            break;
-          }
-          if (fContentCurRowY >= fHeightLimit + XFA_LAYOUT_FLOAT_PERCISION &&
-              XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
-            bForceEndPage = TRUE;
-            goto SuspendAndCreateNewRow;
-          }
-          if (m_pCurChildNode->IsContainerNode()) {
-            FX_BOOL bNewRow = FALSE;
-            if (m_pCurChildPreprocessor) {
-              pProcessor = m_pCurChildPreprocessor;
-              m_pCurChildPreprocessor = NULL;
-              bNewRow = TRUE;
-            } else {
-              pProcessor =
-                  new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
-            }
-            XFA_ItemLayoutProcessor_InsertPendingItems(pProcessor,
-                                                       m_pCurChildNode);
-            XFA_ItemLayoutProcessorResult rs =
-                XFA_ItemLayoutProcessor_InsertFlowedItem(
-                    this, pProcessor, bContainerWidthAutoSize,
-                    bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
-                    fAvailHeight, fRealHeight, fContentCurRowY,
-                    fContentWidthLimit, fContentCurRowAvailWidth,
-                    fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
-                    pContext, bNewRow);
-            switch (rs) {
-              case XFA_ItemLayoutProcessorResult_ManualBreak:
-                bIsManualBreak = TRUE;
-              case XFA_ItemLayoutProcessorResult_PageFullBreak:
-                bForceEndPage = TRUE;
-              case XFA_ItemLayoutProcessorResult_RowFullBreak:
-                goto SuspendAndCreateNewRow;
-              case XFA_ItemLayoutProcessorResult_Done:
-              default:
-                fContentCurRowY += XFA_ItemLayoutProcessor_InsertPendingItems(
-                    pProcessor, m_pCurChildNode);
-                delete pProcessor;
-                pProcessor = NULL;
-            }
-          }
-          break;
-        case XFA_ItemLayoutProcessorStages_Done:
-          break;
-        default:
-          break;
-      }
-      XFA_ItemLayoutProcessor_GotoNextContainerNode(
-          m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
-      if (bAddedItemInRow && eFlowStrategy == XFA_ATTRIBUTEENUM_Tb) {
-        break;
-      } else {
-        continue;
-      }
-    SuspendAndCreateNewRow:
-      if (pProcessor) {
-        m_pCurChildPreprocessor = pProcessor;
-      }
-      break;
-    }
-    CalculateRowChildPosition(rgCurLineLayoutItems, eFlowStrategy,
-                              bContainerHeightAutoSize, bContainerWidthAutoSize,
-                              fContentCalculatedWidth, fContentCalculatedHeight,
-                              fContentCurRowY, fContentCurRowHeight,
-                              fContentWidthLimit, bRootForceTb);
-    m_fWidthLimite = fContentCurRowAvailWidth;
-    if (bForceEndPage) {
-      break;
-    }
-  }
-  FX_BOOL bRetValue =
-      m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done &&
-      m_PendingNodes.empty();
-  if (bBreakDone) {
-    bRetValue = FALSE;
-  }
-  XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
-      m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
-      fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
-      fContainerHeight);
-  if (fContainerHeight >= XFA_LAYOUT_FLOAT_PERCISION || m_pLayoutItem ||
-      bRetValue) {
-    if (m_pLayoutItem == NULL) {
-      m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-    }
-    if (fContainerHeight < 0) {
-      fContainerHeight = 0;
-    }
-    SetCurrentComponentSize(fContainerWidth, fContainerHeight);
-    if (bForceEndPage) {
-      m_fUsedSize = 0;
-    } else {
-      m_fUsedSize += m_pLayoutItem->m_sSize.y;
-    }
-  }
-  return bRetValue
-             ? XFA_ItemLayoutProcessorResult_Done
-             : (bIsManualBreak ? XFA_ItemLayoutProcessorResult_ManualBreak
-                               : XFA_ItemLayoutProcessorResult_PageFullBreak);
-}
-FX_BOOL CXFA_ItemLayoutProcessor::CalculateRowChildPosition(
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*>(&rgCurLineLayoutItems)[3],
-    XFA_ATTRIBUTEENUM eFlowStrategy,
-    FX_BOOL bContainerHeightAutoSize,
-    FX_BOOL bContainerWidthAutoSize,
-    FX_FLOAT& fContentCalculatedWidth,
-    FX_FLOAT& fContentCalculatedHeight,
-    FX_FLOAT& fContentCurRowY,
-    FX_FLOAT fContentCurRowHeight,
-    FX_FLOAT fContentWidthLimit,
-    FX_BOOL bRootForceTb) {
-  int32_t nGroupLengths[3] = {0, 0, 0};
-  FX_FLOAT fGroupWidths[3] = {0, 0, 0};
-  int32_t nTotalLength = 0;
-  for (int32_t i = 0; i < 3; i++) {
-    nGroupLengths[i] = rgCurLineLayoutItems[i].GetSize();
-    for (int32_t c = nGroupLengths[i], j = 0; j < c; j++) {
-      nTotalLength++;
-      if (XFA_ItemLayoutProcessor_IsTakingSpace(
-              rgCurLineLayoutItems[i][j]->m_pFormNode)) {
-        fGroupWidths[i] += rgCurLineLayoutItems[i][j]->m_sSize.x;
-      }
-    }
-  }
-  if (!nTotalLength) {
-    if (bContainerHeightAutoSize) {
-      FX_FLOAT fNewHeight = fContentCurRowY;
-      if (fContentCalculatedHeight > fNewHeight) {
-        fContentCalculatedHeight = fNewHeight;
-      }
-    }
-    return FALSE;
-  }
-  if (m_pLayoutItem == NULL) {
-    m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-  }
-  if (eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb) {
-    FX_FLOAT fCurPos;
-    fCurPos = 0;
-    for (int32_t c = nGroupLengths[0], j = 0; j < c; j++) {
-      if (bRootForceTb) {
-        FX_FLOAT fAbsoluteX, fAbsoluteY;
-        CalculatePositionedContainerPos(rgCurLineLayoutItems[0][j]->m_pFormNode,
-                                        rgCurLineLayoutItems[0][j]->m_sSize.x,
-                                        rgCurLineLayoutItems[0][j]->m_sSize.y,
-                                        fAbsoluteX, fAbsoluteY);
-        rgCurLineLayoutItems[0][j]->m_sPos = CFX_PointF(fAbsoluteX, fAbsoluteY);
-      } else {
-        rgCurLineLayoutItems[0][j]->m_sPos =
-            CFX_PointF(fCurPos, fContentCurRowY);
-        if (XFA_ItemLayoutProcessor_IsTakingSpace(
-                rgCurLineLayoutItems[0][j]->m_pFormNode)) {
-          fCurPos += rgCurLineLayoutItems[0][j]->m_sSize.x;
-        }
-      }
-      m_pLayoutItem->AddChild(rgCurLineLayoutItems[0][j]);
-      m_fLastRowWidth = fCurPos;
-    }
-    fCurPos = (fContentWidthLimit + fGroupWidths[0] - fGroupWidths[1] -
-               fGroupWidths[2]) /
-              2;
-    for (int32_t c = nGroupLengths[1], j = 0; j < c; j++) {
-      if (bRootForceTb) {
-        FX_FLOAT fAbsoluteX, fAbsoluteY;
-        CalculatePositionedContainerPos(rgCurLineLayoutItems[1][j]->m_pFormNode,
-                                        rgCurLineLayoutItems[1][j]->m_sSize.x,
-                                        rgCurLineLayoutItems[1][j]->m_sSize.y,
-                                        fAbsoluteX, fAbsoluteY);
-        rgCurLineLayoutItems[1][j]->m_sPos = CFX_PointF(fAbsoluteX, fAbsoluteY);
-      } else {
-        rgCurLineLayoutItems[1][j]->m_sPos =
-            CFX_PointF(fCurPos, fContentCurRowY);
-        if (XFA_ItemLayoutProcessor_IsTakingSpace(
-                rgCurLineLayoutItems[1][j]->m_pFormNode)) {
-          fCurPos += rgCurLineLayoutItems[1][j]->m_sSize.x;
-        }
-      }
-      m_pLayoutItem->AddChild(rgCurLineLayoutItems[1][j]);
-      m_fLastRowWidth = fCurPos;
-    }
-    fCurPos = fContentWidthLimit - fGroupWidths[2];
-    for (int32_t c = nGroupLengths[2], j = 0; j < c; j++) {
-      if (bRootForceTb) {
-        FX_FLOAT fAbsoluteX, fAbsoluteY;
-        CalculatePositionedContainerPos(rgCurLineLayoutItems[2][j]->m_pFormNode,
-                                        rgCurLineLayoutItems[2][j]->m_sSize.x,
-                                        rgCurLineLayoutItems[2][j]->m_sSize.y,
-                                        fAbsoluteX, fAbsoluteY);
-        rgCurLineLayoutItems[2][j]->m_sPos = CFX_PointF(fAbsoluteX, fAbsoluteY);
-      } else {
-        rgCurLineLayoutItems[2][j]->m_sPos =
-            CFX_PointF(fCurPos, fContentCurRowY);
-        if (XFA_ItemLayoutProcessor_IsTakingSpace(
-                rgCurLineLayoutItems[2][j]->m_pFormNode)) {
-          fCurPos += rgCurLineLayoutItems[2][j]->m_sSize.x;
-        }
-      }
-      m_pLayoutItem->AddChild(rgCurLineLayoutItems[2][j]);
-      m_fLastRowWidth = fCurPos;
-    }
-  } else {
-    FX_FLOAT fCurPos;
-    fCurPos = fGroupWidths[0];
-    for (int32_t c = nGroupLengths[0], j = 0; j < c; j++) {
-      if (XFA_ItemLayoutProcessor_IsTakingSpace(
-              rgCurLineLayoutItems[0][j]->m_pFormNode)) {
-        fCurPos -= rgCurLineLayoutItems[0][j]->m_sSize.x;
-      }
-      rgCurLineLayoutItems[0][j]->m_sPos = CFX_PointF(fCurPos, fContentCurRowY);
-      m_pLayoutItem->AddChild(rgCurLineLayoutItems[0][j]);
-      m_fLastRowWidth = fCurPos;
-    }
-    fCurPos = (fContentWidthLimit + fGroupWidths[0] + fGroupWidths[1] -
-               fGroupWidths[2]) /
-              2;
-    for (int32_t c = nGroupLengths[1], j = 0; j < c; j++) {
-      if (XFA_ItemLayoutProcessor_IsTakingSpace(
-              rgCurLineLayoutItems[1][j]->m_pFormNode)) {
-        fCurPos -= rgCurLineLayoutItems[1][j]->m_sSize.x;
-      }
-      rgCurLineLayoutItems[1][j]->m_sPos = CFX_PointF(fCurPos, fContentCurRowY);
-      m_pLayoutItem->AddChild(rgCurLineLayoutItems[1][j]);
-      m_fLastRowWidth = fCurPos;
-    }
-    fCurPos = fContentWidthLimit;
-    for (int32_t c = nGroupLengths[2], j = 0; j < c; j++) {
-      if (XFA_ItemLayoutProcessor_IsTakingSpace(
-              rgCurLineLayoutItems[2][j]->m_pFormNode)) {
-        fCurPos -= rgCurLineLayoutItems[2][j]->m_sSize.x;
-      }
-      rgCurLineLayoutItems[2][j]->m_sPos = CFX_PointF(fCurPos, fContentCurRowY);
-      m_pLayoutItem->AddChild(rgCurLineLayoutItems[2][j]);
-      m_fLastRowWidth = fCurPos;
-    }
-  }
-  m_fLastRowY = fContentCurRowY;
-  fContentCurRowY += fContentCurRowHeight;
-  if (bContainerWidthAutoSize) {
-    FX_FLOAT fChildSuppliedWidth = fGroupWidths[0];
-    if (fContentWidthLimit < XFA_LAYOUT_FLOAT_MAX &&
-        fContentWidthLimit > fChildSuppliedWidth) {
-      fChildSuppliedWidth = fContentWidthLimit;
-    }
-    if (fContentCalculatedWidth < fChildSuppliedWidth) {
-      fContentCalculatedWidth = fChildSuppliedWidth;
-    }
-  }
-  if (bContainerHeightAutoSize) {
-    FX_FLOAT fChildSuppliedHeight = fContentCurRowY;
-    if (fContentCalculatedHeight < fChildSuppliedHeight) {
-      fContentCalculatedHeight = fChildSuppliedHeight;
-    }
-  }
-  return TRUE;
-}
-CXFA_Node* CXFA_ItemLayoutProcessor::GetSubformSetParent(
-    CXFA_Node* pSubformSet) {
-  if (pSubformSet && pSubformSet->GetClassID() == XFA_ELEMENT_SubformSet) {
-    CXFA_Node* pParent = pSubformSet->GetNodeItem(XFA_NODEITEM_Parent);
-    while (pParent) {
-      if (pParent->GetClassID() != XFA_ELEMENT_SubformSet) {
-        return pParent;
-      }
-      pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
-    }
-  }
-  return pSubformSet;
-}
-void CXFA_ItemLayoutProcessor::DoLayoutField() {
-  if (m_pLayoutItem)
-    return;
-
-  ASSERT(m_pCurChildNode == XFA_LAYOUT_INVALIDNODE);
-  m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-  if (!m_pLayoutItem) {
-    return;
-  }
-  CXFA_Document* pDocument = m_pFormNode->GetDocument();
-  IXFA_Notify* pNotify = pDocument->GetParser()->GetNotify();
-  FX_FLOAT fHeight = -1;
-  FX_FLOAT fWidth = -1;
-  pNotify->StartFieldDrawLayout(m_pFormNode, fWidth, fHeight);
-  int32_t nRotate =
-      FXSYS_round(m_pFormNode->GetMeasure(XFA_ATTRIBUTE_Rotate).GetValue());
-  nRotate = XFA_MapRotation(nRotate);
-  if (nRotate == 90 || nRotate == 270) {
-    FX_FLOAT fTmp = fWidth;
-    fWidth = fHeight;
-    fHeight = fTmp;
-  }
-  SetCurrentComponentSize(fWidth, fHeight);
-}
-XFA_ItemLayoutProcessorResult CXFA_ItemLayoutProcessor::DoLayout(
-    FX_BOOL bUseBreakControl,
-    FX_FLOAT fHeightLimit,
-    FX_FLOAT fRealHeight,
-    CXFA_LayoutContext* pContext) {
-  XFA_ELEMENT eClassID = m_pFormNode->GetClassID();
-  switch (eClassID) {
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_SubformSet: {
-      FX_BOOL bRootForceTb = FALSE;
-      CXFA_Node* pLayoutNode = GetSubformSetParent(m_pFormNode);
-      XFA_ATTRIBUTEENUM eLayoutStrategy =
-          XFA_ItemLayoutProcessor_GetLayout(pLayoutNode, bRootForceTb);
-      switch (eLayoutStrategy) {
-        case XFA_ATTRIBUTEENUM_Tb:
-        case XFA_ATTRIBUTEENUM_Lr_tb:
-        case XFA_ATTRIBUTEENUM_Rl_tb:
-          return DoLayoutFlowedContainer(bUseBreakControl, eLayoutStrategy,
-                                         fHeightLimit, fRealHeight, pContext,
-                                         bRootForceTb);
-        case XFA_ATTRIBUTEENUM_Position:
-        case XFA_ATTRIBUTEENUM_Row:
-        case XFA_ATTRIBUTEENUM_Rl_row:
-        default:
-          DoLayoutPositionedContainer(pContext);
-          m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Done;
-          return XFA_ItemLayoutProcessorResult_Done;
-        case XFA_ATTRIBUTEENUM_Table:
-          DoLayoutTableContainer(pLayoutNode);
-          m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Done;
-          return XFA_ItemLayoutProcessorResult_Done;
-      }
-    }
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_Field:
-      DoLayoutField();
-      m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Done;
-      return XFA_ItemLayoutProcessorResult_Done;
-    case XFA_ELEMENT_ContentArea:
-      return XFA_ItemLayoutProcessorResult_Done;
-    default:
-      return XFA_ItemLayoutProcessorResult_Done;
-  }
-}
-void CXFA_ItemLayoutProcessor::GetCurrentComponentPos(FX_FLOAT& fAbsoluteX,
-                                                      FX_FLOAT& fAbsoluteY) {
-  ASSERT(m_pLayoutItem);
-  fAbsoluteX = m_pLayoutItem->m_sPos.x;
-  fAbsoluteY = m_pLayoutItem->m_sPos.y;
-}
-void CXFA_ItemLayoutProcessor::GetCurrentComponentSize(FX_FLOAT& fWidth,
-                                                       FX_FLOAT& fHeight) {
-  ASSERT(m_pLayoutItem);
-  fWidth = m_pLayoutItem->m_sSize.x;
-  fHeight = m_pLayoutItem->m_sSize.y;
-}
-void CXFA_ItemLayoutProcessor::SetCurrentComponentPos(FX_FLOAT fAbsoluteX,
-                                                      FX_FLOAT fAbsoluteY) {
-  m_pLayoutItem->m_sPos = CFX_PointF(fAbsoluteX, fAbsoluteY);
-}
-void CXFA_ItemLayoutProcessor::SetCurrentComponentSize(FX_FLOAT fWidth,
-                                                       FX_FLOAT fHeight) {
-  m_pLayoutItem->m_sSize = CFX_SizeF(fWidth, fHeight);
-}
-FX_BOOL CXFA_ItemLayoutProcessor::JudgeLeaderOrTrailerForOccur(
-    CXFA_Node* pFormNode) {
-  if (pFormNode == NULL) {
-    return FALSE;
-  }
-  CXFA_Node* pTemplate = pFormNode->GetTemplateNode();
-  if (!pTemplate) {
-    pTemplate = pFormNode;
-  }
-  CXFA_Occur NodeOccur(pTemplate->GetFirstChildByClass(XFA_ELEMENT_Occur));
-  int32_t iMax = NodeOccur.GetMax();
-  if (iMax > -1) {
-    int32_t iCount =
-        (int32_t)(uintptr_t)m_PendingNodesCount.GetValueAt(pTemplate);
-    if (iCount >= iMax) {
-      return FALSE;
-    }
-    iCount++;
-    m_PendingNodesCount.SetAt(pTemplate, (void*)(uintptr_t)(iCount));
-    return TRUE;
-  }
-  return TRUE;
-}
diff --git a/xfa/src/fxfa/parser/xfa_layout_itemlayout.h b/xfa/src/fxfa/parser/xfa_layout_itemlayout.h
deleted file mode 100644
index 16a91d4f03..0000000000
--- a/xfa/src/fxfa/parser/xfa_layout_itemlayout.h
+++ /dev/null
@@ -1,195 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_LAYOUT_ITEMLAYOUT_H_
-#define XFA_SRC_FXFA_PARSER_XFA_LAYOUT_ITEMLAYOUT_H_
-
-#include <float.h>
-
-#include <list>
-
-#include "core/include/fxcrt/fx_basic.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-
-#define XFA_LAYOUT_INVALIDNODE ((CXFA_Node*)(intptr_t)-1)
-#define XFA_LAYOUT_FLOAT_PERCISION (0.0005f)
-#define XFA_LAYOUT_FLOAT_MAX FLT_MAX
-
-class CXFA_ContainerLayoutItem;
-class CXFA_ContentLayoutItem;
-class CXFA_ItemLayoutProcessor;
-class CXFA_LayoutPageMgr;
-class CXFA_Node;
-
-enum XFA_ItemLayoutProcessorResult {
-  XFA_ItemLayoutProcessorResult_Done,
-  XFA_ItemLayoutProcessorResult_PageFullBreak,
-  XFA_ItemLayoutProcessorResult_RowFullBreak,
-  XFA_ItemLayoutProcessorResult_ManualBreak,
-};
-
-enum XFA_ItemLayoutProcessorStages {
-  XFA_ItemLayoutProcessorStages_None,
-  XFA_ItemLayoutProcessorStages_BookendLeader,
-  XFA_ItemLayoutProcessorStages_BreakBefore,
-  XFA_ItemLayoutProcessorStages_Keep,
-  XFA_ItemLayoutProcessorStages_Container,
-  XFA_ItemLayoutProcessorStages_BreakAfter,
-  XFA_ItemLayoutProcessorStages_BookendTrailer,
-  XFA_ItemLayoutProcessorStages_Done,
-};
-
-class CXFA_LayoutContext {
- public:
-  CXFA_LayoutContext()
-      : m_prgSpecifiedColumnWidths(NULL),
-        m_fCurColumnWidth(0),
-        m_bCurColumnWidthAvaiable(FALSE),
-        m_pOverflowProcessor(NULL),
-        m_pOverflowNode(NULL) {}
-  ~CXFA_LayoutContext() { m_pOverflowProcessor = NULL; }
-  CFX_ArrayTemplate<FX_FLOAT>* m_prgSpecifiedColumnWidths;
-  FX_FLOAT m_fCurColumnWidth;
-  FX_BOOL m_bCurColumnWidthAvaiable;
-  CXFA_ItemLayoutProcessor* m_pOverflowProcessor;
-  CXFA_Node* m_pOverflowNode;
-};
-
-class CXFA_ItemLayoutProcessor {
- public:
-  CXFA_ItemLayoutProcessor(CXFA_Node* pNode, CXFA_LayoutPageMgr* pPageMgr);
-
-  XFA_ItemLayoutProcessorResult DoLayout(
-      FX_BOOL bUseBreakControl,
-      FX_FLOAT fHeightLimit,
-      FX_FLOAT fRealHeight = XFA_LAYOUT_FLOAT_MAX,
-      CXFA_LayoutContext* pContext = NULL);
-
-  void GetCurrentComponentPos(FX_FLOAT& fAbsoluteX, FX_FLOAT& fAbsoluteY);
-
-  void GetCurrentComponentSize(FX_FLOAT& fWidth, FX_FLOAT& fHeight);
-
-  void SetCurrentComponentPos(FX_FLOAT fAbsoluteX, FX_FLOAT fAbsoluteY);
-
-  void SetCurrentComponentSize(FX_FLOAT fWidth, FX_FLOAT fHeight);
-  inline CXFA_Node* GetFormNode() { return m_pFormNode; }
-  inline FX_BOOL HasLayoutItem() { return m_pLayoutItem != NULL; }
-  CXFA_ContentLayoutItem* ExtractLayoutItem();
-
-  static FX_BOOL IncrementRelayoutNode(CXFA_LayoutProcessor* pLayoutProcessor,
-                                       CXFA_Node* pNode,
-                                       CXFA_Node* pParentNode);
-  static void CalculatePositionedContainerPos(CXFA_Node* pNode,
-                                              FX_FLOAT fWidth,
-                                              FX_FLOAT fHeight,
-                                              FX_FLOAT& fAbsoluteX,
-                                              FX_FLOAT& fAbsoluteY);
-  static FX_BOOL FindLayoutItemSplitPos(CXFA_ContentLayoutItem* pLayoutItem,
-                                        FX_FLOAT fCurVerticalOffset,
-                                        FX_FLOAT& fProposedSplitPos,
-                                        FX_BOOL& bAppChange,
-                                        FX_BOOL bCalculateMargin = TRUE);
-  FX_FLOAT FindSplitPos(FX_FLOAT fProposedSplitPos);
-  void SplitLayoutItem(CXFA_ContentLayoutItem* pLayoutItem,
-                       CXFA_ContentLayoutItem* pSecondParent,
-                       FX_FLOAT fSplitPos);
-  void SplitLayoutItem(FX_FLOAT fSplitPos);
-  FX_BOOL JudgePutNextPage(
-      CXFA_ContentLayoutItem* pParentLayoutItem,
-      FX_FLOAT fChildHeight,
-      CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& pKeepItems);
-  FX_BOOL ProcessKeepForSplite(
-      CXFA_ItemLayoutProcessor* pParentProcessor,
-      CXFA_ItemLayoutProcessor* pChildProcessor,
-      XFA_ItemLayoutProcessorResult eRetValue,
-      CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& rgCurLineLayoutItem,
-      FX_FLOAT& fContentCurRowAvailWidth,
-      FX_FLOAT& fContentCurRowHeight,
-      FX_FLOAT& fContentCurRowY,
-      FX_BOOL& bAddedItemInRow,
-      FX_BOOL& bForceEndPage,
-      XFA_ItemLayoutProcessorResult& result);
-  FX_FLOAT InsertKeepLayoutItems();
-  void DoLayoutPageArea(CXFA_ContainerLayoutItem* pPageAreaLayoutItem);
-  FX_BOOL CalculateRowChildPosition(
-      CFX_ArrayTemplate<CXFA_ContentLayoutItem*>(&rgCurLineLayoutItems)[3],
-      XFA_ATTRIBUTEENUM eFlowStrategy,
-      FX_BOOL bContainerHeightAutoSize,
-      FX_BOOL bContainerWidthAutoSize,
-      FX_FLOAT& fContentCalculatedWidth,
-      FX_FLOAT& fContentCalculatedHeight,
-      FX_FLOAT& fContentCurRowY,
-      FX_FLOAT fContentCurRowHeight,
-      FX_FLOAT fContentWidthLimit,
-      FX_BOOL bRootForceTb = FALSE);
-
-  void ProcessUnUseOverFlow(CXFA_Node* pLeaderNode,
-                            CXFA_Node* pTrailerNode,
-                            CXFA_ContentLayoutItem* pTrailerItem,
-                            CXFA_Node* pFormNode);
-  void ProcessUnUseBinds(CXFA_Node* pFormNode);
-  FX_BOOL IsAddNewRowForTrailer(CXFA_ContentLayoutItem* pTrailerItem);
-  FX_BOOL JudgeLeaderOrTrailerForOccur(CXFA_Node* pFormNode);
-  CXFA_ContentLayoutItem* CreateContentLayoutItem(CXFA_Node* pFormNode);
-
- protected:
-  void DoLayoutPositionedContainer(CXFA_LayoutContext* pContext = NULL);
-  void DoLayoutTableContainer(CXFA_Node* pLayoutNode);
-  XFA_ItemLayoutProcessorResult DoLayoutFlowedContainer(
-      FX_BOOL bUseBreakControl,
-      XFA_ATTRIBUTEENUM eFlowStrategy,
-      FX_FLOAT fHeightLimit,
-      FX_FLOAT fRealHeight,
-      CXFA_LayoutContext* pContext = NULL,
-      FX_BOOL bRootForceTb = FALSE);
-  void DoLayoutField();
-  void XFA_ItemLayoutProcessor_GotoNextContainerNode(
-      CXFA_Node*& pCurActionNode,
-      XFA_ItemLayoutProcessorStages& nCurStage,
-      CXFA_Node* pParentContainer,
-      FX_BOOL bUsePageBreak);
-
-  FX_BOOL ProcessKeepNodesForCheckNext(CXFA_Node*& pCurActionNode,
-                                       XFA_ItemLayoutProcessorStages& nCurStage,
-                                       CXFA_Node*& pNextContainer,
-                                       FX_BOOL& bLastKeepNode);
-
-  FX_BOOL ProcessKeepNodesForBreakBefore(
-      CXFA_Node*& pCurActionNode,
-      XFA_ItemLayoutProcessorStages& nCurStage,
-      CXFA_Node* pContainerNode);
-
-  CXFA_Node* GetSubformSetParent(CXFA_Node* pSubformSet);
-
- public:
-  FX_BOOL m_bKeepBreakFinish;
-  FX_BOOL m_bIsProcessKeep;
-  CXFA_Node* m_pKeepHeadNode;
-  CXFA_Node* m_pKeepTailNode;
-  CXFA_Node* m_pFormNode;
-  CXFA_ContentLayoutItem* m_pLayoutItem;
-  CXFA_ContentLayoutItem* m_pOldLayoutItem;
-  CXFA_Node* m_pCurChildNode;
-  CXFA_ItemLayoutProcessor* m_pCurChildPreprocessor;
-  XFA_ItemLayoutProcessorStages m_nCurChildNodeStage;
-  FX_FLOAT m_fUsedSize;
-  CXFA_LayoutPageMgr* m_pPageMgr;
-  std::list<CXFA_Node*> m_PendingNodes;
-  FX_BOOL m_bBreakPending;
-  CFX_ArrayTemplate<FX_FLOAT> m_rgSpecifiedColumnWidths;
-  CFX_ArrayTemplate<CXFA_ContentLayoutItem*> m_arrayKeepItems;
-  CFX_MapPtrToPtr m_PendingNodesCount;
-  FX_FLOAT m_fLastRowWidth;
-  FX_FLOAT m_fLastRowY;
-  FX_FLOAT m_fWidthLimite;
-  FX_BOOL m_bUseInheriated;
-  XFA_ItemLayoutProcessorResult m_ePreProcessRs;
-  FX_BOOL m_bHasAvailHeight;
-};
-FX_BOOL XFA_ItemLayoutProcessor_IsTakingSpace(CXFA_Node* pNode);
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_LAYOUT_ITEMLAYOUT_H_
diff --git a/xfa/src/fxfa/parser/xfa_layout_pagemgr_new.cpp b/xfa/src/fxfa/parser/xfa_layout_pagemgr_new.cpp
deleted file mode 100644
index 0ca5af5ca4..0000000000
--- a/xfa/src/fxfa/parser/xfa_layout_pagemgr_new.cpp
+++ /dev/null
@@ -1,1931 +0,0 @@
-// 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/src/fxfa/parser/xfa_layout_pagemgr_new.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_datamerger_imp.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_layout_appadapter.h"
-#include "xfa/src/fxfa/parser/xfa_layout_itemlayout.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_LayoutPageMgr::CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor)
-    : m_pLayoutProcessor(pLayoutProcessor),
-      m_pTemplatePageSetRoot(nullptr),
-      m_pPageSetLayoutItemRoot(nullptr),
-      m_pPageSetCurRoot(nullptr),
-      m_pCurrentContainerRecord(nullptr),
-      m_pCurPageArea(nullptr),
-      m_nAvailPages(0),
-      m_nCurPageCount(0),
-      m_ePageSetMode(XFA_ATTRIBUTEENUM_OrderedOccurrence),
-      m_bCreateOverFlowPage(FALSE) {}
-CXFA_LayoutPageMgr::~CXFA_LayoutPageMgr() {
-  ClearData();
-  CXFA_LayoutItem* pLayoutItem = GetRootLayoutItem();
-  CXFA_LayoutItem* pNextLayout = NULL;
-  for (; pLayoutItem; pLayoutItem = pNextLayout) {
-    pNextLayout = pLayoutItem->m_pNextSibling;
-    XFA_ReleaseLayoutItem(pLayoutItem);
-  }
-}
-FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) {
-  PrepareLayout();
-  CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
-  if (!pTemplateNode) {
-    return FALSE;
-  }
-  m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_ELEMENT_PageSet);
-  ASSERT(m_pTemplatePageSetRoot);
-  if (m_pPageSetLayoutItemRoot) {
-    m_pPageSetLayoutItemRoot->m_pParent = NULL;
-    m_pPageSetLayoutItemRoot->m_pFirstChild = NULL;
-    m_pPageSetLayoutItemRoot->m_pNextSibling = NULL;
-    m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot;
-  } else {
-    m_pPageSetLayoutItemRoot =
-        new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot);
-  }
-  m_pPageSetCurRoot = m_pPageSetLayoutItemRoot;
-  m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY,
-                                      (void*)m_pPageSetLayoutItemRoot);
-  XFA_ATTRIBUTEENUM eRelation =
-      m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation);
-  if (eRelation != XFA_ATTRIBUTEENUM_Unknown) {
-    m_ePageSetMode = eRelation;
-  }
-  InitPageSetMap();
-  CXFA_Node* pPageArea = NULL;
-  int32_t iCount = 0;
-  for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pPageArea;
-       pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pPageArea->GetClassID() == XFA_ELEMENT_PageArea) {
-      iCount++;
-      if (pPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea)) {
-        return TRUE;
-      }
-    }
-  }
-  if (iCount > 0) {
-    return FALSE;
-  }
-  CXFA_Document* pDocument = pTemplateNode->GetDocument();
-  IXFA_ObjFactory* pObjFactory = pDocument->GetParser()->GetFactory();
-  pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_ELEMENT_PageArea);
-  if (!pPageArea) {
-    pPageArea = pObjFactory->CreateNode(m_pTemplatePageSetRoot->GetPacketID(),
-                                        XFA_ELEMENT_PageArea);
-    if (!pPageArea) {
-      return FALSE;
-    }
-    m_pTemplatePageSetRoot->InsertChild(pPageArea, NULL);
-    pPageArea->SetFlag(XFA_NODEFLAG_Initialized);
-  }
-  CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_ELEMENT_ContentArea);
-  if (!pContentArea) {
-    pContentArea = pObjFactory->CreateNode(pPageArea->GetPacketID(),
-                                           XFA_ELEMENT_ContentArea);
-    if (!pContentArea) {
-      return FALSE;
-    }
-    pPageArea->InsertChild(pContentArea, NULL);
-    pContentArea->SetFlag(XFA_NODEFLAG_Initialized);
-    pContentArea->SetMeasure(XFA_ATTRIBUTE_X,
-                             CXFA_Measurement(0.25f, XFA_UNIT_In));
-    pContentArea->SetMeasure(XFA_ATTRIBUTE_Y,
-                             CXFA_Measurement(0.25f, XFA_UNIT_In));
-    pContentArea->SetMeasure(XFA_ATTRIBUTE_W,
-                             CXFA_Measurement(8.0f, XFA_UNIT_In));
-    pContentArea->SetMeasure(XFA_ATTRIBUTE_H,
-                             CXFA_Measurement(10.5f, XFA_UNIT_In));
-  }
-  CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_ELEMENT_Medium);
-  if (!pMedium) {
-    pMedium =
-        pObjFactory->CreateNode(pPageArea->GetPacketID(), XFA_ELEMENT_Medium);
-    if (!pContentArea) {
-      return FALSE;
-    }
-    pPageArea->InsertChild(pMedium, NULL);
-    pMedium->SetFlag(XFA_NODEFLAG_Initialized);
-    pMedium->SetMeasure(XFA_ATTRIBUTE_Short,
-                        CXFA_Measurement(8.5f, XFA_UNIT_In));
-    pMedium->SetMeasure(XFA_ATTRIBUTE_Long,
-                        CXFA_Measurement(11.0f, XFA_UNIT_In));
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) {
-  FX_BOOL bProBreakBefore = FALSE;
-  CXFA_Node* pBreakBeforeNode = NULL;
-  while (pRootSubform) {
-    for (CXFA_Node* pBreakNode =
-             pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild);
-         pBreakNode;
-         pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      XFA_ELEMENT eType = pBreakNode->GetClassID();
-      if (eType == XFA_ELEMENT_BreakBefore ||
-          (eType == XFA_ELEMENT_Break &&
-           pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) !=
-               XFA_ATTRIBUTEENUM_Auto)) {
-        bProBreakBefore = TRUE;
-        pBreakBeforeNode = pBreakNode;
-        break;
-      }
-    }
-    if (bProBreakBefore) {
-      break;
-    }
-    bProBreakBefore = TRUE;
-    pRootSubform = pRootSubform->GetFirstChildByClass(XFA_ELEMENT_Subform);
-    while (pRootSubform &&
-           !XFA_ItemLayoutProcessor_IsTakingSpace(pRootSubform)) {
-      pRootSubform = pRootSubform->GetNextSameClassSibling(XFA_ELEMENT_Subform);
-    }
-  }
-  CXFA_Node *pLeader, *pTrailer;
-  if (pBreakBeforeNode &&
-      ExecuteBreakBeforeOrAfter(pBreakBeforeNode, TRUE, pLeader, pTrailer)) {
-    m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
-    return TRUE;
-  }
-  return AppendNewPage(TRUE);
-}
-FX_BOOL CXFA_LayoutPageMgr::AppendNewPage(FX_BOOL bFirstTemPage) {
-  if (m_pCurrentContainerRecord !=
-      m_rgProposedContainerRecord.GetTailPosition()) {
-    return TRUE;
-  }
-  CXFA_Node* pPageNode = GetNextAvailPageArea(NULL);
-  if (!pPageNode) {
-    return FALSE;
-  }
-  if (bFirstTemPage && m_pCurrentContainerRecord == NULL) {
-    m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
-  }
-  return !bFirstTemPage || m_pCurrentContainerRecord;
-}
-static void XFA_LayoutItemMgr_ReorderLayoutItemToTail(
-    CXFA_ContainerLayoutItem* pLayoutItem) {
-  CXFA_ContainerLayoutItem* pParentLayoutItem =
-      (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent;
-  if (!pParentLayoutItem) {
-    return;
-  }
-  pParentLayoutItem->RemoveChild(pLayoutItem);
-  pParentLayoutItem->AddChild(pLayoutItem);
-}
-static void XFA_LayoutItemMgr_RemoveLayoutItem(
-    CXFA_ContainerLayoutItem* pLayoutItem) {
-  CXFA_ContainerLayoutItem* pParentLayoutItem =
-      (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent;
-  if (!pParentLayoutItem) {
-    return;
-  }
-  pParentLayoutItem->RemoveChild(pLayoutItem);
-}
-void CXFA_LayoutPageMgr::RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord,
-                                            CXFA_ContainerRecord* pPrevRecord) {
-  if (!pNewRecord || !pPrevRecord) {
-    return;
-  }
-  if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) {
-    XFA_LayoutItemMgr_RemoveLayoutItem(pNewRecord->pCurPageSet);
-    return;
-  }
-  if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) {
-    XFA_LayoutItemMgr_RemoveLayoutItem(pNewRecord->pCurPageArea);
-    return;
-  }
-  if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) {
-    XFA_LayoutItemMgr_RemoveLayoutItem(pNewRecord->pCurContentArea);
-    return;
-  }
-}
-void CXFA_LayoutPageMgr::ReorderPendingLayoutRecordToTail(
-    CXFA_ContainerRecord* pNewRecord,
-    CXFA_ContainerRecord* pPrevRecord) {
-  if (!pNewRecord || !pPrevRecord) {
-    return;
-  }
-  if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) {
-    XFA_LayoutItemMgr_ReorderLayoutItemToTail(pNewRecord->pCurPageSet);
-    return;
-  }
-  if (pNewRecord->pCurPageArea != pPrevRecord->pCurPageArea) {
-    XFA_LayoutItemMgr_ReorderLayoutItemToTail(pNewRecord->pCurPageArea);
-    return;
-  }
-  if (pNewRecord->pCurContentArea != pPrevRecord->pCurContentArea) {
-    XFA_LayoutItemMgr_ReorderLayoutItemToTail(pNewRecord->pCurContentArea);
-    return;
-  }
-}
-void CXFA_LayoutPageMgr::SubmitContentItem(
-    CXFA_ContentLayoutItem* pContentLayoutItem,
-    XFA_ItemLayoutProcessorResult eStatus) {
-  if (pContentLayoutItem) {
-    GetCurrentContainerRecord()->pCurContentArea->AddChild(pContentLayoutItem);
-    m_bCreateOverFlowPage = FALSE;
-  }
-  if (eStatus != XFA_ItemLayoutProcessorResult_Done) {
-    if (eStatus == XFA_ItemLayoutProcessorResult_PageFullBreak &&
-        m_pCurrentContainerRecord ==
-            m_rgProposedContainerRecord.GetTailPosition()) {
-      AppendNewPage();
-    }
-    m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetTailPosition();
-    m_pCurPageArea = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode;
-  }
-}
-FX_FLOAT CXFA_LayoutPageMgr::GetAvailHeight() {
-  CXFA_ContainerLayoutItem* pLayoutItem =
-      GetCurrentContainerRecord()->pCurContentArea;
-  if (!pLayoutItem || !pLayoutItem->m_pFormNode)
-    return 0.0f;
-  FX_FLOAT fAvailHeight =
-      pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
-  if (fAvailHeight >= XFA_LAYOUT_FLOAT_PERCISION)
-    return fAvailHeight;
-  if (m_pCurrentContainerRecord ==
-      m_rgProposedContainerRecord.GetHeadPosition()) {
-    return 0.0f;
-  }
-  return XFA_LAYOUT_FLOAT_MAX;
-}
-static CXFA_Node* XFA_ResolveBreakTarget(CXFA_Node* pPageSetRoot,
-                                         FX_BOOL bNewExprStyle,
-                                         CFX_WideStringC& wsTargetExpr) {
-  CXFA_Document* pDocument = pPageSetRoot->GetDocument();
-  if (wsTargetExpr.IsEmpty()) {
-    return NULL;
-  }
-  CFX_WideString wsTargetAll = wsTargetExpr;
-  wsTargetAll.TrimLeft();
-  wsTargetAll.TrimRight();
-  int32_t iSpliteIndex = 0;
-  FX_BOOL bTargetAllFind = TRUE;
-  while (iSpliteIndex != -1) {
-    CFX_WideString wsTargetExpr;
-    int32_t iSpliteNextIndex = 0;
-    if (!bTargetAllFind) {
-      iSpliteNextIndex = wsTargetAll.Find(' ', iSpliteIndex);
-      wsTargetExpr =
-          wsTargetAll.Mid(iSpliteIndex, iSpliteNextIndex - iSpliteIndex);
-    } else {
-      wsTargetExpr = wsTargetAll;
-    }
-    if (wsTargetExpr.IsEmpty()) {
-      return NULL;
-    }
-    bTargetAllFind = FALSE;
-    if (wsTargetExpr.GetAt(0) == '#') {
-      CXFA_Node* pNode = pDocument->GetNodeByID(
-          ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Template)),
-          wsTargetExpr.Mid(1));
-      if (pNode) {
-        return pNode;
-      }
-    } else if (bNewExprStyle) {
-      CFX_WideString wsProcessedTarget = wsTargetExpr;
-      if (wsTargetExpr.Left(4) == FX_WSTRC(L"som(") &&
-          wsTargetExpr.Right(1) == FX_WSTRC(L")")) {
-        wsProcessedTarget = wsTargetExpr.Mid(4, wsTargetExpr.GetLength() - 5);
-      }
-      XFA_RESOLVENODE_RS rs;
-      int32_t iCount = pDocument->GetScriptContext()->ResolveObjects(
-          pPageSetRoot, wsProcessedTarget, rs,
-          XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
-              XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Siblings |
-              XFA_RESOLVENODE_Parent);
-      if (iCount > 0 && rs.nodes[0]->IsNode()) {
-        return rs.nodes[0]->AsNode();
-      }
-    }
-    iSpliteIndex = iSpliteNextIndex;
-  }
-  return NULL;
-}
-
-FX_BOOL XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) {
-  CFX_WideString wsExpression;
-  pTestScript->TryContent(wsExpression);
-  if (wsExpression.IsEmpty()) {
-    return TRUE;
-  }
-  return pTestScript->GetDocument()->GetParser()->GetNotify()->RunScript(
-      pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent,
-                                            XFA_OBJECTTYPE_ContainerNode));
-}
-CXFA_ContainerRecord* CXFA_LayoutPageMgr::CreateContainerRecord(
-    CXFA_Node* pPageNode,
-    FX_BOOL bCreateNew) {
-  CXFA_ContainerRecord* pNewRecord = new CXFA_ContainerRecord();
-  if (m_pCurrentContainerRecord) {
-    if (!IsPageSetRootOrderedOccurrence() || pPageNode == NULL) {
-      *pNewRecord = *GetCurrentContainerRecord();
-      m_rgProposedContainerRecord.AddTail(pNewRecord);
-      return pNewRecord;
-    }
-    CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent);
-    if (!bCreateNew) {
-      if (pPageSet == m_pTemplatePageSetRoot) {
-        pNewRecord->pCurPageSet = m_pPageSetCurRoot;
-      } else {
-        CXFA_ContainerLayoutItem* pParentLayoutItem =
-            (CXFA_ContainerLayoutItem*)pPageSet->GetUserData(XFA_LAYOUTITEMKEY);
-        if (pParentLayoutItem == NULL) {
-          pParentLayoutItem = m_pPageSetCurRoot;
-        }
-        pNewRecord->pCurPageSet = pParentLayoutItem;
-      }
-    } else {
-      CXFA_ContainerLayoutItem* pParentPageSetLayout = NULL;
-      if (pPageSet == GetCurrentContainerRecord()->pCurPageSet->m_pFormNode) {
-        pParentPageSetLayout =
-            (CXFA_ContainerLayoutItem*)GetCurrentContainerRecord()
-                ->pCurPageSet->m_pParent;
-      } else {
-        pParentPageSetLayout =
-            (CXFA_ContainerLayoutItem*)pPageSet->GetNodeItem(
-                                                   XFA_NODEITEM_Parent)
-                ->GetUserData(XFA_LAYOUTITEMKEY);
-      }
-      CXFA_ContainerLayoutItem* pPageSetLayoutItem =
-          new CXFA_ContainerLayoutItem(pPageSet);
-      pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem);
-      if (pParentPageSetLayout == NULL) {
-        CXFA_ContainerLayoutItem* pPrePageSet = m_pPageSetLayoutItemRoot;
-        while (pPrePageSet->m_pNextSibling) {
-          pPrePageSet = (CXFA_ContainerLayoutItem*)pPrePageSet->m_pNextSibling;
-        }
-        pPrePageSet->m_pNextSibling = pPageSetLayoutItem;
-        m_pPageSetCurRoot = pPageSetLayoutItem;
-      } else {
-        pParentPageSetLayout->AddChild(pPageSetLayoutItem);
-      }
-      pNewRecord->pCurPageSet = pPageSetLayoutItem;
-    }
-  } else {
-    if (pPageNode) {
-      CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent);
-      if (pPageSet == m_pTemplatePageSetRoot) {
-        pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot;
-      } else {
-        CXFA_ContainerLayoutItem* pPageSetLayoutItem =
-            new CXFA_ContainerLayoutItem(pPageSet);
-        pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem);
-        m_pPageSetLayoutItemRoot->AddChild(pPageSetLayoutItem);
-        pNewRecord->pCurPageSet = pPageSetLayoutItem;
-      }
-    } else {
-      pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot;
-    }
-  }
-  m_rgProposedContainerRecord.AddTail(pNewRecord);
-  return pNewRecord;
-}
-void CXFA_LayoutPageMgr::AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord,
-                                               CXFA_Node* pNewPageArea) {
-  CXFA_ContainerLayoutItem* pNewPageAreaLayoutItem = NULL;
-  if (m_PageArray.GetSize() > m_nAvailPages) {
-    CXFA_ContainerLayoutItem* pContainerItem = m_PageArray[m_nAvailPages];
-    pContainerItem->m_pFormNode = pNewPageArea;
-    m_nAvailPages++;
-    pNewPageAreaLayoutItem = pContainerItem;
-  } else {
-    IXFA_Notify* pNotify =
-        pNewPageArea->GetDocument()->GetParser()->GetNotify();
-    CXFA_ContainerLayoutItem* pContainerItem =
-        (CXFA_ContainerLayoutItem*)pNotify->OnCreateLayoutItem(pNewPageArea);
-    m_PageArray.Add(pContainerItem);
-    m_nAvailPages++;
-    pNotify->OnPageEvent(pContainerItem, XFA_PAGEEVENT_PageAdded,
-                         (void*)(uintptr_t)m_nAvailPages);
-    pNewPageAreaLayoutItem = pContainerItem;
-  }
-  pNewRecord->pCurPageSet->AddChild(pNewPageAreaLayoutItem);
-  pNewRecord->pCurPageArea = pNewPageAreaLayoutItem;
-  pNewRecord->pCurContentArea = NULL;
-}
-void CXFA_LayoutPageMgr::AddContentAreaLayoutItem(
-    CXFA_ContainerRecord* pNewRecord,
-    CXFA_Node* pContentArea) {
-  if (pContentArea == NULL) {
-    pNewRecord->pCurContentArea = NULL;
-    return;
-  }
-  CXFA_ContainerLayoutItem* pNewContentAreaLayoutItem =
-      new CXFA_ContainerLayoutItem(pContentArea);
-  ASSERT(pNewRecord->pCurPageArea);
-  pNewRecord->pCurPageArea->AddChild(pNewContentAreaLayoutItem);
-  pNewRecord->pCurContentArea = pNewContentAreaLayoutItem;
-}
-class CXFA_TraverseStrategy_PageSetContainerLayoutItem {
- public:
-  static inline CXFA_ContainerLayoutItem* GetFirstChild(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    if (pLayoutItem->m_pFormNode->GetClassID() == XFA_ELEMENT_PageSet) {
-      CXFA_ContainerLayoutItem* pChildItem =
-          (CXFA_ContainerLayoutItem*)pLayoutItem->m_pFirstChild;
-      while (pChildItem &&
-             pChildItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageSet) {
-        pChildItem = (CXFA_ContainerLayoutItem*)pChildItem->m_pNextSibling;
-      }
-      return pChildItem;
-    }
-    return NULL;
-  }
-  static inline CXFA_ContainerLayoutItem* GetNextSibling(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    CXFA_ContainerLayoutItem* pChildItem =
-        (CXFA_ContainerLayoutItem*)pLayoutItem->m_pNextSibling;
-    while (pChildItem &&
-           pChildItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageSet) {
-      pChildItem = (CXFA_ContainerLayoutItem*)pChildItem->m_pNextSibling;
-    }
-    return pChildItem;
-  }
-  static inline CXFA_ContainerLayoutItem* GetParent(
-      CXFA_ContainerLayoutItem* pLayoutItem) {
-    return (CXFA_ContainerLayoutItem*)pLayoutItem->m_pParent;
-  }
-};
-void CXFA_LayoutPageMgr::FinishPaginatedPageSets() {
-  CXFA_ContainerLayoutItem* pRootPageSetLayoutItem = m_pPageSetLayoutItemRoot;
-  for (; pRootPageSetLayoutItem;
-       pRootPageSetLayoutItem =
-           (CXFA_ContainerLayoutItem*)pRootPageSetLayoutItem->m_pNextSibling) {
-    CXFA_NodeIteratorTemplate<CXFA_ContainerLayoutItem,
-                              CXFA_TraverseStrategy_PageSetContainerLayoutItem>
-        sIterator(pRootPageSetLayoutItem);
-    for (CXFA_ContainerLayoutItem* pPageSetLayoutItem = sIterator.GetCurrent();
-         pPageSetLayoutItem; pPageSetLayoutItem = sIterator.MoveToNext()) {
-      XFA_ATTRIBUTEENUM ePageRelation =
-          pPageSetLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Relation);
-      switch (ePageRelation) {
-        case XFA_ATTRIBUTEENUM_OrderedOccurrence:
-        default: { ProcessLastPageSet(); } break;
-        case XFA_ATTRIBUTEENUM_SimplexPaginated:
-        case XFA_ATTRIBUTEENUM_DuplexPaginated: {
-          CXFA_LayoutItem* pLastPageAreaLayoutItem = NULL;
-          int32_t nPageAreaCount = 0;
-          for (CXFA_LayoutItem* pPageAreaLayoutItem =
-                   pPageSetLayoutItem->m_pFirstChild;
-               pPageAreaLayoutItem;
-               pPageAreaLayoutItem = pPageAreaLayoutItem->m_pNextSibling) {
-            if (pPageAreaLayoutItem->m_pFormNode->GetClassID() !=
-                XFA_ELEMENT_PageArea) {
-              continue;
-            }
-            nPageAreaCount++;
-            pLastPageAreaLayoutItem = pPageAreaLayoutItem;
-          }
-          if (!pLastPageAreaLayoutItem) {
-            break;
-          }
-          if (!FindPageAreaFromPageSet_SimplexDuplex(
-                  pPageSetLayoutItem->m_pFormNode, NULL, NULL, NULL, TRUE, TRUE,
-                  nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only
-                                      : XFA_ATTRIBUTEENUM_Last) &&
-              (nPageAreaCount == 1 &&
-               !FindPageAreaFromPageSet_SimplexDuplex(
-                   pPageSetLayoutItem->m_pFormNode, NULL, NULL, NULL, TRUE,
-                   TRUE, XFA_ATTRIBUTEENUM_Last))) {
-            break;
-          }
-          CXFA_Node* pNode = m_pCurPageArea;
-          XFA_ATTRIBUTEENUM eCurChoice =
-              pNode->GetEnum(XFA_ATTRIBUTE_PagePosition);
-          if (eCurChoice == XFA_ATTRIBUTEENUM_Last) {
-            XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any;
-            pNode->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven);
-            XFA_ATTRIBUTEENUM eLastChoice =
-                pLastPageAreaLayoutItem->m_pFormNode->GetEnum(
-                    XFA_ATTRIBUTE_PagePosition);
-            if (eLastChoice == XFA_ATTRIBUTEENUM_First &&
-                (ePageRelation == XFA_ATTRIBUTEENUM_SimplexPaginated ||
-                 eOddOrEven != XFA_ATTRIBUTEENUM_Odd)) {
-              CXFA_ContainerRecord* pRecord = CreateContainerRecord();
-              AddPageAreaLayoutItem(pRecord, pNode);
-              break;
-            }
-          }
-          FX_BOOL bUsable = TRUE;
-          CFX_ArrayTemplate<FX_FLOAT> rgUsedHeights;
-          for (CXFA_LayoutItem* pChildLayoutItem =
-                   pLastPageAreaLayoutItem->m_pFirstChild;
-               pChildLayoutItem;
-               pChildLayoutItem = pChildLayoutItem->m_pNextSibling) {
-            if (pChildLayoutItem->m_pFormNode->GetClassID() !=
-                XFA_ELEMENT_ContentArea) {
-              continue;
-            }
-            FX_FLOAT fUsedHeight = 0;
-            for (CXFA_LayoutItem* pContentChildLayoutItem =
-                     pChildLayoutItem->m_pFirstChild;
-                 pContentChildLayoutItem;
-                 pContentChildLayoutItem =
-                     pContentChildLayoutItem->m_pNextSibling) {
-              if (CXFA_ContentLayoutItem* pContent =
-                      pContentChildLayoutItem->AsContentLayoutItem()) {
-                fUsedHeight += pContent->m_sSize.y;
-              }
-            }
-            rgUsedHeights.Add(fUsedHeight);
-          }
-          int32_t iCurContentAreaIndex = -1;
-          for (CXFA_Node* pContentAreaNode =
-                   pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-               pContentAreaNode;
-               pContentAreaNode =
-                   pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-            if (pContentAreaNode->GetClassID() != XFA_ELEMENT_ContentArea) {
-              continue;
-            }
-            iCurContentAreaIndex++;
-            if (rgUsedHeights[iCurContentAreaIndex] >
-                pContentAreaNode->GetMeasure(XFA_ATTRIBUTE_H)
-                        .ToUnit(XFA_UNIT_Pt) +
-                    XFA_LAYOUT_FLOAT_PERCISION) {
-              bUsable = FALSE;
-              break;
-            }
-          }
-          if (bUsable) {
-            CXFA_LayoutItem* pChildLayoutItem =
-                pLastPageAreaLayoutItem->m_pFirstChild;
-            CXFA_Node* pContentAreaNode =
-                pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-            pLastPageAreaLayoutItem->m_pFormNode = pNode;
-            while (pChildLayoutItem && pContentAreaNode) {
-              if (pChildLayoutItem->m_pFormNode->GetClassID() !=
-                  XFA_ELEMENT_ContentArea) {
-                pChildLayoutItem = pChildLayoutItem->m_pNextSibling;
-                continue;
-              }
-              if (pContentAreaNode->GetClassID() != XFA_ELEMENT_ContentArea) {
-                pContentAreaNode =
-                    pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-                continue;
-              }
-              pChildLayoutItem->m_pFormNode = pContentAreaNode;
-              pChildLayoutItem = pChildLayoutItem->m_pNextSibling;
-              pContentAreaNode =
-                  pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-            }
-          } else if (pNode->GetEnum(XFA_ATTRIBUTE_PagePosition) ==
-                     XFA_ATTRIBUTEENUM_Last) {
-            CXFA_ContainerRecord* pRecord = CreateContainerRecord();
-            AddPageAreaLayoutItem(pRecord, pNode);
-          }
-        } break;
-      }
-    }
-  }
-}
-int32_t CXFA_LayoutPageMgr::GetPageCount() const {
-  return m_PageArray.GetSize();
-}
-IXFA_LayoutPage* CXFA_LayoutPageMgr::GetPage(int32_t index) const {
-  if (index < 0 || index >= m_PageArray.GetSize())
-    return nullptr;
-  return m_PageArray[index];
-}
-int32_t CXFA_LayoutPageMgr::GetPageIndex(const IXFA_LayoutPage* pPage) const {
-  // FIXME: Find() method should take const.
-  return m_PageArray.Find(static_cast<CXFA_ContainerLayoutItem*>(
-      const_cast<IXFA_LayoutPage*>(pPage)));
-}
-FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_ELEMENT eBreakType,
-                                     XFA_ATTRIBUTEENUM eTargetType,
-                                     CXFA_Node* pTarget,
-                                     FX_BOOL bStartNew) {
-  FX_BOOL bRet = FALSE;
-  switch (eTargetType) {
-    case XFA_ATTRIBUTEENUM_ContentArea:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_ContentArea) {
-        pTarget = NULL;
-      }
-      if (!pTarget || !m_pCurrentContainerRecord ||
-          pTarget !=
-              GetCurrentContainerRecord()->pCurContentArea->m_pFormNode ||
-          bStartNew) {
-        CXFA_Node* pPageArea = NULL;
-        if (pTarget) {
-          pPageArea = pTarget->GetNodeItem(XFA_NODEITEM_Parent);
-        }
-        pPageArea = GetNextAvailPageArea(pPageArea, pTarget);
-        bRet = pPageArea != NULL;
-      }
-      break;
-    case XFA_ATTRIBUTEENUM_PageArea:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_PageArea) {
-        pTarget = NULL;
-      }
-      if (!pTarget || !m_pCurrentContainerRecord ||
-          pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode ||
-          bStartNew) {
-        CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, NULL, TRUE);
-        bRet = pPageArea != NULL;
-      }
-      break;
-    case XFA_ATTRIBUTEENUM_PageOdd:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_PageArea) {
-        pTarget = NULL;
-      }
-      if (m_nAvailPages % 2 != 1 || !m_pCurrentContainerRecord ||
-          (pTarget &&
-           pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode) ||
-          bStartNew) {
-        if (m_nAvailPages % 2 == 1) {
-        }
-      }
-      break;
-    case XFA_ATTRIBUTEENUM_PageEven:
-      if (pTarget && pTarget->GetClassID() != XFA_ELEMENT_PageArea) {
-        pTarget = NULL;
-      }
-      if (m_nAvailPages % 2 != 0 || !m_pCurrentContainerRecord ||
-          (pTarget &&
-           pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode) ||
-          bStartNew) {
-        if (m_nAvailPages % 2 == 0) {
-        }
-      }
-      break;
-    case XFA_ATTRIBUTEENUM_Auto:
-    default:
-      break;
-  }
-  return bRet;
-}
-FX_BOOL CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter(
-    CXFA_Node* pCurNode,
-    FX_BOOL bBefore,
-    CXFA_Node*& pBreakLeaderTemplate,
-    CXFA_Node*& pBreakTrailerTemplate) {
-  XFA_ELEMENT eType = pCurNode->GetClassID();
-  switch (eType) {
-    case XFA_ELEMENT_BreakBefore:
-    case XFA_ELEMENT_BreakAfter: {
-      CFX_WideStringC wsBreakLeader, wsBreakTrailer;
-      CXFA_Node* pFormNode = pCurNode->GetNodeItem(
-          XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
-      CXFA_Node* pContainer = pFormNode->GetTemplateNode();
-      FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
-      CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_ELEMENT_Script);
-      if (pScript && !XFA_LayoutPageMgr_RunBreakTestScript(pScript)) {
-        return FALSE;
-      }
-      CFX_WideStringC wsTarget = pCurNode->GetCData(XFA_ATTRIBUTE_Target);
-      CXFA_Node* pTarget =
-          XFA_ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
-      wsBreakTrailer = pCurNode->GetCData(XFA_ATTRIBUTE_Trailer);
-      wsBreakLeader = pCurNode->GetCData(XFA_ATTRIBUTE_Leader);
-      pBreakLeaderTemplate =
-          XFA_ResolveBreakTarget(pContainer, TRUE, wsBreakLeader);
-      pBreakTrailerTemplate =
-          XFA_ResolveBreakTarget(pContainer, TRUE, wsBreakTrailer);
-      if (RunBreak(eType, pCurNode->GetEnum(XFA_ATTRIBUTE_TargetType), pTarget,
-                   bStartNew)) {
-        return TRUE;
-      } else {
-        if (m_rgProposedContainerRecord.GetCount() > 0 &&
-            m_pCurrentContainerRecord ==
-                m_rgProposedContainerRecord.GetHeadPosition() &&
-            eType == XFA_ELEMENT_BreakBefore) {
-          CXFA_Node* pParentNode = pFormNode->GetNodeItem(
-              XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
-          if (!pParentNode ||
-              pFormNode !=
-                  pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild,
-                                           XFA_OBJECTTYPE_ContainerNode)) {
-            break;
-          }
-          pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
-          if (!pParentNode || pParentNode->GetClassID() != XFA_ELEMENT_Form) {
-            break;
-          }
-          return TRUE;
-        }
-      }
-    } break;
-    case XFA_ELEMENT_Break: {
-      FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
-      CFX_WideStringC wsTarget = pCurNode->GetCData(
-          bBefore ? XFA_ATTRIBUTE_BeforeTarget : XFA_ATTRIBUTE_AfterTarget);
-      CXFA_Node* pTarget =
-          XFA_ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
-      if (RunBreak(bBefore ? XFA_ELEMENT_BreakBefore : XFA_ELEMENT_BreakAfter,
-                   pCurNode->GetEnum(bBefore ? XFA_ATTRIBUTE_Before
-                                             : XFA_ATTRIBUTE_After),
-                   pTarget, bStartNew)) {
-        return TRUE;
-      }
-    } break;
-    default:
-      break;
-  }
-  return FALSE;
-}
-static void XFA_SetLayoutGeneratedNodeFlag(CXFA_Node* pNode) {
-  pNode->SetFlag(XFA_NODEFLAG_LayoutGeneratedNode, TRUE, FALSE);
-  pNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE, FALSE);
-}
-FX_BOOL CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter(
-    CXFA_Node* pBreakNode,
-    FX_BOOL bBefore,
-    CXFA_Node*& pBreakLeaderNode,
-    CXFA_Node*& pBreakTrailerNode,
-    FX_BOOL& bCreatePage) {
-  CXFA_Node *pLeaderTemplate = NULL, *pTrailerTemplate = NULL;
-  CXFA_Node* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                                 XFA_OBJECTTYPE_ContainerNode);
-  if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) {
-    bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore,
-                                            pLeaderTemplate, pTrailerTemplate);
-    CXFA_Document* pDocument = pBreakNode->GetDocument();
-    CXFA_Node* pDataScope = NULL;
-    pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                       XFA_OBJECTTYPE_ContainerNode);
-    if (pLeaderTemplate) {
-      if (!pDataScope) {
-        pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
-      }
-      pBreakLeaderNode = pDocument->DataMerge_CopyContainer(
-          pLeaderTemplate, pFormNode, pDataScope, TRUE);
-      pDocument->DataMerge_UpdateBindingRelations(pBreakLeaderNode);
-      XFA_SetLayoutGeneratedNodeFlag(pBreakLeaderNode);
-    }
-    if (pTrailerTemplate) {
-      if (!pDataScope) {
-        pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
-      }
-      pBreakTrailerNode = pDocument->DataMerge_CopyContainer(
-          pTrailerTemplate, pFormNode, pDataScope, TRUE);
-      pDocument->DataMerge_UpdateBindingRelations(pBreakTrailerNode);
-      XFA_SetLayoutGeneratedNodeFlag(pBreakTrailerNode);
-    }
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer(
-    CXFA_Node* pBookendNode,
-    FX_BOOL bLeader,
-    CXFA_Node*& pBookendAppendNode) {
-  CXFA_Node* pLeaderTemplate = NULL;
-  CXFA_Node* pFormNode = pBookendNode->GetNodeItem(
-      XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
-  if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) {
-    CXFA_Document* pDocument = pBookendNode->GetDocument();
-    CXFA_Node* pDataScope = NULL;
-    if (pLeaderTemplate) {
-      if (!pDataScope) {
-        pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
-      }
-      pBookendAppendNode = pDocument->DataMerge_CopyContainer(
-          pLeaderTemplate, pFormNode, pDataScope, TRUE);
-      pDocument->DataMerge_UpdateBindingRelations(pBookendAppendNode);
-      XFA_SetLayoutGeneratedNodeFlag(pBookendAppendNode);
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode,
-                                             CXFA_Node*& pLeaderTemplate,
-                                             CXFA_Node*& pTrailerTemplate,
-                                             FX_BOOL bCreatePage) {
-  CFX_WideStringC wsOverflowLeader, wsOverflowTrailer;
-  CXFA_Node* pContainer =
-      pOverflowNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                 XFA_OBJECTTYPE_ContainerNode)
-          ->GetTemplateNode();
-  if (pOverflowNode->GetClassID() == XFA_ELEMENT_Break) {
-    CFX_WideStringC wsOverflowLeader;
-    CFX_WideStringC wsOverflowTarget;
-    CFX_WideStringC wsOverflowTrailer;
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
-    if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
-        !wsOverflowTarget.IsEmpty()) {
-      if (!wsOverflowTarget.IsEmpty() && bCreatePage &&
-          !m_bCreateOverFlowPage) {
-        CXFA_Node* pTarget = XFA_ResolveBreakTarget(m_pTemplatePageSetRoot,
-                                                    TRUE, wsOverflowTarget);
-        if (pTarget) {
-          m_bCreateOverFlowPage = TRUE;
-          switch (pTarget->GetClassID()) {
-            case XFA_ELEMENT_PageArea:
-              RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_PageArea,
-                       pTarget, TRUE);
-              break;
-            case XFA_ELEMENT_ContentArea:
-              RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_ContentArea,
-                       pTarget, TRUE);
-              break;
-            default:
-              break;
-          }
-        }
-      }
-      if (!bCreatePage) {
-        pLeaderTemplate =
-            XFA_ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
-        pTrailerTemplate =
-            XFA_ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
-      }
-      return pOverflowNode;
-    }
-    return NULL;
-  } else if (pOverflowNode->GetClassID() == XFA_ELEMENT_Overflow) {
-    CFX_WideStringC wsOverflowTarget;
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader);
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer);
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget);
-    if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) {
-      CXFA_Node* pTarget = XFA_ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE,
-                                                  wsOverflowTarget);
-      if (pTarget) {
-        m_bCreateOverFlowPage = TRUE;
-        switch (pTarget->GetClassID()) {
-          case XFA_ELEMENT_PageArea:
-            RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget,
-                     TRUE);
-            break;
-          case XFA_ELEMENT_ContentArea:
-            RunBreak(XFA_ELEMENT_Overflow, XFA_ATTRIBUTEENUM_ContentArea,
-                     pTarget, TRUE);
-            break;
-          default:
-            break;
-        }
-      }
-    }
-    if (!bCreatePage) {
-      pLeaderTemplate =
-          XFA_ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
-      pTrailerTemplate =
-          XFA_ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
-    }
-    return pOverflowNode;
-  }
-  return NULL;
-}
-FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode,
-                                            CXFA_Node*& pLeaderNode,
-                                            CXFA_Node*& pTrailerNode,
-                                            FX_BOOL bDataMerge,
-                                            FX_BOOL bCreatePage) {
-  if (pFormNode == NULL) {
-    return FALSE;
-  }
-  CXFA_Node *pLeaderTemplate = NULL, *pTrailerTemplate = NULL;
-  FX_BOOL bIsOverflowNode = FALSE;
-  if (pFormNode->GetClassID() == XFA_ELEMENT_Overflow ||
-      pFormNode->GetClassID() == XFA_ELEMENT_Break) {
-    bIsOverflowNode = TRUE;
-  }
-  for (CXFA_Node* pCurNode =
-           bIsOverflowNode ? pFormNode
-                           : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
-    if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate,
-                      bCreatePage)) {
-      if (bIsOverflowNode) {
-        pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent);
-      }
-      CXFA_Document* pDocument = pCurNode->GetDocument();
-      CXFA_Node* pDataScope = NULL;
-      if (pLeaderTemplate) {
-        if (!pDataScope) {
-          pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
-        }
-        pLeaderNode = pDocument->DataMerge_CopyContainer(
-            pLeaderTemplate, pFormNode, pDataScope, TRUE);
-        pDocument->DataMerge_UpdateBindingRelations(pLeaderNode);
-        XFA_SetLayoutGeneratedNodeFlag(pLeaderNode);
-      }
-      if (pTrailerTemplate) {
-        if (!pDataScope) {
-          pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
-        }
-        pTrailerNode = pDocument->DataMerge_CopyContainer(
-            pTrailerTemplate, pFormNode, pDataScope, TRUE);
-        pDocument->DataMerge_UpdateBindingRelations(pTrailerNode);
-        XFA_SetLayoutGeneratedNodeFlag(pTrailerNode);
-      }
-      return TRUE;
-    }
-    if (bIsOverflowNode) {
-      break;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer(
-    CXFA_Node* pBookendNode,
-    FX_BOOL bLeader,
-    CXFA_Node*& pBookendAppendTemplate) {
-  CFX_WideStringC wsBookendLeader;
-  CXFA_Node* pContainer =
-      pBookendNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                XFA_OBJECTTYPE_ContainerNode)
-          ->GetTemplateNode();
-  if (pBookendNode->GetClassID() == XFA_ELEMENT_Break) {
-    pBookendNode->TryCData(
-        bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer,
-        wsBookendLeader);
-    if (!wsBookendLeader.IsEmpty()) {
-      pBookendAppendTemplate =
-          XFA_ResolveBreakTarget(pContainer, FALSE, wsBookendLeader);
-      return TRUE;
-    }
-    return FALSE;
-  } else if (pBookendNode->GetClassID() == XFA_ELEMENT_Bookend) {
-    pBookendNode->TryCData(
-        bLeader ? XFA_ATTRIBUTE_Leader : XFA_ATTRIBUTE_Trailer,
-        wsBookendLeader);
-    pBookendAppendTemplate =
-        XFA_ResolveBreakTarget(pContainer, TRUE, wsBookendLeader);
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet(
-    CXFA_Node* pPageSet,
-    CXFA_Node* pStartChild,
-    CXFA_Node* pTargetPageArea,
-    CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery) {
-  if (pPageSet == NULL && pStartChild == NULL) {
-    return FALSE;
-  }
-  if (IsPageSetRootOrderedOccurrence()) {
-    return FindPageAreaFromPageSet_Ordered(pPageSet, pStartChild,
-                                           pTargetPageArea, pTargetContentArea,
-                                           bNewPage, bQuery);
-  }
-  XFA_ATTRIBUTEENUM ePreferredPosition = m_pCurrentContainerRecord
-                                             ? XFA_ATTRIBUTEENUM_Rest
-                                             : XFA_ATTRIBUTEENUM_First;
-  return FindPageAreaFromPageSet_SimplexDuplex(
-      pPageSet, pStartChild, pTargetPageArea, pTargetContentArea, bNewPage,
-      bQuery, ePreferredPosition);
-}
-FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_Ordered(
-    CXFA_Node* pPageSet,
-    CXFA_Node* pStartChild,
-    CXFA_Node* pTargetPageArea,
-    CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery) {
-  int32_t iPageSetCount = 0;
-  if (!pStartChild && !bQuery) {
-    m_pPageSetMap.Lookup(pPageSet, iPageSetCount);
-    int32_t iMax = -1;
-    CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_ELEMENT_Occur);
-    if (pOccurNode) {
-      pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
-    }
-    if (iMax >= 0 && iMax <= iPageSetCount) {
-      return FALSE;
-    }
-  }
-  FX_BOOL bRes = FALSE;
-  CXFA_Node* pCurrentNode =
-      pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling)
-                  : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pCurrentNode;
-       pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageArea) {
-      if ((pTargetPageArea == pCurrentNode || pTargetPageArea == NULL)) {
-        if (pCurrentNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea) ==
-            NULL) {
-          if (pTargetPageArea == pCurrentNode) {
-            CreateMinPageRecord(pCurrentNode, TRUE);
-            pTargetPageArea = NULL;
-          }
-          continue;
-        }
-        if (!bQuery) {
-          CXFA_ContainerRecord* pNewRecord =
-              CreateContainerRecord(pCurrentNode, pStartChild == NULL);
-          AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
-          if (pTargetContentArea == NULL) {
-            pTargetContentArea =
-                pCurrentNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
-          }
-          AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
-        }
-        m_pCurPageArea = pCurrentNode;
-        m_nCurPageCount = 1;
-        bRes = TRUE;
-        break;
-      }
-      if (!bQuery) {
-        CreateMinPageRecord(pCurrentNode, FALSE);
-      }
-    } else if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageSet) {
-      if (FindPageAreaFromPageSet_Ordered(pCurrentNode, NULL, pTargetPageArea,
-                                          pTargetContentArea, bNewPage,
-                                          bQuery)) {
-        bRes = TRUE;
-        break;
-      }
-      if (!bQuery) {
-        CreateMinPageSetRecord(pCurrentNode, TRUE);
-      }
-    }
-  }
-  if (!pStartChild && bRes && !bQuery) {
-    m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount);
-  }
-  return bRes;
-}
-FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex(
-    CXFA_Node* pPageSet,
-    CXFA_Node* pStartChild,
-    CXFA_Node* pTargetPageArea,
-    CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery,
-    XFA_ATTRIBUTEENUM ePreferredPosition) {
-  const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any;
-  CXFA_Node *pPreferredPageArea = NULL, *pFallbackPageArea = NULL;
-  CXFA_Node* pCurrentNode = NULL;
-  if (!pStartChild || pStartChild->GetClassID() == XFA_ELEMENT_PageArea) {
-    pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
-  } else {
-    pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  for (; pCurrentNode;
-       pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageArea) {
-      if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE)) {
-        continue;
-      }
-      XFA_ATTRIBUTEENUM eCurPagePosition =
-          pCurrentNode->GetEnum(XFA_ATTRIBUTE_PagePosition);
-      if (ePreferredPosition == XFA_ATTRIBUTEENUM_Last) {
-        if (eCurPagePosition != ePreferredPosition) {
-          continue;
-        }
-        if (m_ePageSetMode == XFA_ATTRIBUTEENUM_SimplexPaginated ||
-            pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
-                XFA_ATTRIBUTEENUM_Any) {
-          pPreferredPageArea = pCurrentNode;
-          break;
-        }
-        CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-        AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
-        AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
-                                                 XFA_ELEMENT_ContentArea));
-        pPreferredPageArea = pCurrentNode;
-        return FALSE;
-      } else if (ePreferredPosition == XFA_ATTRIBUTEENUM_Only) {
-        if (eCurPagePosition != ePreferredPosition) {
-          continue;
-        }
-        if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated ||
-            pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
-                XFA_ATTRIBUTEENUM_Any) {
-          pPreferredPageArea = pCurrentNode;
-          break;
-        }
-        return FALSE;
-      }
-      if ((pTargetPageArea == pCurrentNode || pTargetPageArea == NULL)) {
-        if (pCurrentNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea) ==
-            NULL) {
-          if (pTargetPageArea == pCurrentNode) {
-            CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-            AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
-            pTargetPageArea = NULL;
-          }
-          continue;
-        }
-        if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest &&
-             eCurPagePosition == XFA_ATTRIBUTEENUM_Any) ||
-            eCurPagePosition == ePreferredPosition) {
-          pPreferredPageArea = pCurrentNode;
-          break;
-        } else if (eCurPagePosition == eFallbackPosition &&
-                   !pFallbackPageArea) {
-          pFallbackPageArea = pCurrentNode;
-        }
-      } else if (pTargetPageArea &&
-                 !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) {
-        CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-        AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
-        AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
-                                                 XFA_ELEMENT_ContentArea));
-      }
-    } else if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageSet) {
-      if (FindPageAreaFromPageSet_SimplexDuplex(
-              pCurrentNode, NULL, pTargetPageArea, pTargetContentArea, bNewPage,
-              bQuery, ePreferredPosition)) {
-        break;
-      }
-    }
-  }
-  CXFA_Node* pCurPageArea = NULL;
-  if (pPreferredPageArea) {
-    pCurPageArea = pPreferredPageArea;
-  } else if (pFallbackPageArea) {
-    pCurPageArea = pFallbackPageArea;
-  }
-  if (!pCurPageArea) {
-    return FALSE;
-  }
-  if (!bQuery) {
-    CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-    AddPageAreaLayoutItem(pNewRecord, pCurPageArea);
-    if (pTargetContentArea == NULL) {
-      pTargetContentArea =
-          pCurPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
-    }
-    AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
-  }
-  m_pCurPageArea = pCurPageArea;
-  return TRUE;
-}
-FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea,
-                                                   FX_BOOL bLastMatch) {
-  if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated) {
-    return TRUE;
-  }
-  XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any;
-  pPageArea->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven);
-  if (eOddOrEven != XFA_ATTRIBUTEENUM_Any) {
-    int32_t iPageCount = GetPageCount();
-    if (bLastMatch) {
-      return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 1
-                                                 : iPageCount % 2 == 0;
-    }
-    return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 0
-                                               : iPageCount % 2 == 1;
-  }
-  return TRUE;
-}
-CXFA_Node* CXFA_LayoutPageMgr::GetNextAvailPageArea(
-    CXFA_Node* pTargetPageArea,
-    CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery) {
-  if (m_pCurPageArea == NULL) {
-    FindPageAreaFromPageSet(m_pTemplatePageSetRoot, NULL, pTargetPageArea,
-                            pTargetContentArea, bNewPage, bQuery);
-    ASSERT(m_pCurPageArea);
-    return m_pCurPageArea;
-  }
-  if (pTargetPageArea == NULL || pTargetPageArea == m_pCurPageArea) {
-    if (!bNewPage && GetNextContentArea(pTargetContentArea)) {
-      return m_pCurPageArea;
-    }
-    if (IsPageSetRootOrderedOccurrence()) {
-      int32_t iMax = -1;
-      CXFA_Node* pOccurNode =
-          m_pCurPageArea->GetFirstChildByClass(XFA_ELEMENT_Occur);
-      if (pOccurNode) {
-        pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
-      }
-      if ((iMax < 0 || m_nCurPageCount < iMax)) {
-        if (!bQuery) {
-          CXFA_ContainerRecord* pNewRecord =
-              CreateContainerRecord(m_pCurPageArea);
-          AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea);
-          if (pTargetContentArea == NULL) {
-            pTargetContentArea =
-                m_pCurPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
-          }
-          AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
-        }
-        m_nCurPageCount++;
-        return m_pCurPageArea;
-      }
-    }
-  }
-  if (!bQuery && IsPageSetRootOrderedOccurrence()) {
-    CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
-  }
-  if (FindPageAreaFromPageSet(m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent),
-                              m_pCurPageArea, pTargetPageArea,
-                              pTargetContentArea, bNewPage, bQuery)) {
-    return m_pCurPageArea;
-  }
-  CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
-  while (TRUE) {
-    if (FindPageAreaFromPageSet(pPageSet, NULL, pTargetPageArea,
-                                pTargetContentArea, bNewPage, bQuery)) {
-      return m_pCurPageArea;
-    }
-    if (!bQuery && IsPageSetRootOrderedOccurrence()) {
-      CreateMinPageSetRecord(pPageSet);
-    }
-    if (FindPageAreaFromPageSet(NULL, pPageSet, pTargetPageArea,
-                                pTargetContentArea, bNewPage, bQuery)) {
-      return m_pCurPageArea;
-    }
-    if (pPageSet == m_pTemplatePageSetRoot) {
-      break;
-    }
-    pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-  return NULL;
-}
-static FX_BOOL XFA_LayoutPageMgr_CheckContentAreaNotUsed(
-    CXFA_ContainerLayoutItem* pPageAreaLayoutItem,
-    CXFA_Node* pContentArea,
-    CXFA_ContainerLayoutItem*& pContentAreaLayoutItem) {
-  for (CXFA_ContainerLayoutItem* pLayoutItem =
-           (CXFA_ContainerLayoutItem*)pPageAreaLayoutItem->m_pFirstChild;
-       pLayoutItem;
-       pLayoutItem = (CXFA_ContainerLayoutItem*)pLayoutItem->m_pNextSibling) {
-    if (pLayoutItem->m_pFormNode == pContentArea) {
-      if (pLayoutItem->m_pFirstChild == NULL) {
-        pContentAreaLayoutItem = pLayoutItem;
-        return TRUE;
-      }
-      return FALSE;
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) {
-  CXFA_Node* pCurContentNode =
-      GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
-  if (pContentArea == NULL) {
-    pContentArea =
-        pCurContentNode->GetNextSameClassSibling(XFA_ELEMENT_ContentArea);
-    if (pContentArea == NULL) {
-      return FALSE;
-    }
-  } else {
-    if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea) {
-      return FALSE;
-    }
-    CXFA_ContainerLayoutItem* pContentAreaLayout = NULL;
-    if (!XFA_LayoutPageMgr_CheckContentAreaNotUsed(
-            GetCurrentContainerRecord()->pCurPageArea, pContentArea,
-            pContentAreaLayout)) {
-      return FALSE;
-    }
-    if (pContentAreaLayout) {
-      if (pContentAreaLayout->m_pFormNode != pCurContentNode) {
-        CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-        pNewRecord->pCurContentArea = pContentAreaLayout;
-        return TRUE;
-      } else {
-        return FALSE;
-      }
-    }
-  }
-  CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-  AddContentAreaLayoutItem(pNewRecord, pContentArea);
-  return TRUE;
-}
-void CXFA_LayoutPageMgr::InitPageSetMap() {
-  if (!IsPageSetRootOrderedOccurrence()) {
-    return;
-  }
-  CXFA_NodeIterator sIterator(m_pTemplatePageSetRoot);
-  for (CXFA_Node* pPageSetNode = sIterator.GetCurrent(); pPageSetNode;
-       pPageSetNode = sIterator.MoveToNext()) {
-    if (pPageSetNode->GetClassID() == XFA_ELEMENT_PageSet) {
-      XFA_ATTRIBUTEENUM eRelation =
-          pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation);
-      if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence) {
-        m_pPageSetMap.SetAt(pPageSetNode, 0);
-      }
-    }
-  }
-}
-int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea,
-                                                FX_BOOL bTargetPageArea,
-                                                FX_BOOL bCreateLast) {
-  if (pPageArea == NULL) {
-    return 0;
-  }
-  CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_ELEMENT_Occur);
-  int32_t iMin = 0;
-  if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) ||
-      bTargetPageArea) {
-    CXFA_Node* pContentArea =
-        pPageArea->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
-    if (iMin < 1 && bTargetPageArea && !pContentArea) {
-      iMin = 1;
-    }
-    int32_t i = 0;
-    if (bCreateLast) {
-      i = m_nCurPageCount;
-    }
-    for (; i < iMin; i++) {
-      CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
-      AddPageAreaLayoutItem(pNewRecord, pPageArea);
-      AddContentAreaLayoutItem(pNewRecord, pContentArea);
-    }
-  }
-  return iMin;
-}
-void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet,
-                                                FX_BOOL bCreateAll) {
-  if (pPageSet == NULL) {
-    return;
-  }
-  int32_t iCurSetCount = 0;
-  if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount)) {
-    return;
-  }
-  if (bCreateAll) {
-    iCurSetCount = 0;
-  }
-  CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_ELEMENT_Occur);
-  int32_t iMin = 0;
-  if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) {
-    if (iCurSetCount < iMin) {
-      for (int32_t i = 0; i < iMin - iCurSetCount; i++) {
-        for (CXFA_Node* pCurrentPageNode =
-                 pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
-             pCurrentPageNode; pCurrentPageNode = pCurrentPageNode->GetNodeItem(
-                                   XFA_NODEITEM_NextSibling)) {
-          if (pCurrentPageNode->GetClassID() == XFA_ELEMENT_PageArea) {
-            CreateMinPageRecord(pCurrentPageNode, FALSE);
-          } else if (pCurrentPageNode->GetClassID() == XFA_ELEMENT_PageSet) {
-            CreateMinPageSetRecord(pCurrentPageNode, TRUE);
-          }
-        }
-      }
-      m_pPageSetMap.SetAt(pPageSet, iMin);
-    }
-  }
-}
-void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) {
-  if (pRecordNode == NULL) {
-    return;
-  }
-  for (CXFA_Node* pCurrentNode =
-           pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-       pCurrentNode;
-       pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageArea) {
-      CreateMinPageRecord(pCurrentNode, FALSE);
-    } else if (pCurrentNode->GetClassID() == XFA_ELEMENT_PageSet) {
-      CreateMinPageSetRecord(pCurrentNode, TRUE);
-    }
-  }
-}
-void CXFA_LayoutPageMgr::ProcessLastPageSet() {
-  CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
-  CreateNextMinRecord(m_pCurPageArea);
-  CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
-  while (TRUE) {
-    CreateMinPageSetRecord(pPageSet);
-    if (pPageSet == m_pTemplatePageSetRoot) {
-      break;
-    }
-    CreateNextMinRecord(pPageSet);
-    pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-}
-FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) {
-  CXFA_Node* pCurContentNode =
-      GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
-  if (pCurContentNode == NULL) {
-    return FALSE;
-  }
-  pCurContentNode =
-      pCurContentNode->GetNextSameClassSibling(XFA_ELEMENT_ContentArea);
-  if (pCurContentNode) {
-    FX_FLOAT fNextContentHeight =
-        pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
-    return fNextContentHeight > fChildHeight;
-  }
-  CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode;
-  CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
-  int32_t iMax = 0;
-  if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) {
-    if (m_nCurPageCount == iMax) {
-      CXFA_Node* pSrcPage = m_pCurPageArea;
-      int32_t nSrcPageCount = m_nCurPageCount;
-      FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition();
-      CXFA_Node* pNextPage = GetNextAvailPageArea(NULL, NULL, FALSE, TRUE);
-      m_pCurPageArea = pSrcPage;
-      m_nCurPageCount = nSrcPageCount;
-      CXFA_ContainerRecord* pPrevRecord =
-          (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(
-              psSrcRecord);
-      while (psSrcRecord) {
-        FX_POSITION psSaveRecord = psSrcRecord;
-        CXFA_ContainerRecord* pInsertRecord =
-            (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(
-                psSrcRecord);
-        RemoveLayoutRecord(pInsertRecord, pPrevRecord);
-        delete pInsertRecord;
-        m_rgProposedContainerRecord.RemoveAt(psSaveRecord);
-      }
-      if (pNextPage) {
-        CXFA_Node* pContentArea =
-            pNextPage->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
-        if (pContentArea) {
-          FX_FLOAT fNextContentHeight =
-              pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
-          if (fNextContentHeight > fChildHeight) {
-            return TRUE;
-          }
-        }
-      }
-      return FALSE;
-    }
-  }
-  CXFA_Node* pContentArea =
-      pPageNode->GetFirstChildByClass(XFA_ELEMENT_ContentArea);
-  FX_FLOAT fNextContentHeight =
-      pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
-  if (fNextContentHeight < XFA_LAYOUT_FLOAT_PERCISION) {
-    return TRUE;
-  }
-  if (fNextContentHeight > fChildHeight) {
-    return TRUE;
-  }
-  return FALSE;
-}
-void CXFA_LayoutPageMgr::ClearData() {
-  ClearRecordList();
-}
-void CXFA_LayoutPageMgr::ClearRecordList() {
-  if (!m_pTemplatePageSetRoot) {
-    return;
-  }
-  if (m_rgProposedContainerRecord.GetCount() > 0) {
-    FX_POSITION sPos;
-    sPos = m_rgProposedContainerRecord.GetHeadPosition();
-    while (sPos) {
-      CXFA_ContainerRecord* pRecord =
-          (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(sPos);
-      delete pRecord;
-    }
-    m_rgProposedContainerRecord.RemoveAll();
-  }
-  m_pCurrentContainerRecord = NULL;
-  m_pCurPageArea = NULL;
-  m_nCurPageCount = 0;
-  m_bCreateOverFlowPage = FALSE;
-  m_pPageSetMap.RemoveAll();
-}
-CXFA_LayoutItem* CXFA_LayoutPageMgr::FindOrCreateLayoutItem(
-    CXFA_Node* pFormNode) {
-  return pFormNode->GetDocument()->GetParser()->GetNotify()->OnCreateLayoutItem(
-      pFormNode);
-}
-static void XFA_SyncRemoveLayoutItem(CXFA_LayoutItem* pParentLayoutItem,
-                                     IXFA_Notify* pNotify,
-                                     IXFA_DocLayout* pDocLayout) {
-  CXFA_LayoutItem* pNextLayoutItem;
-  CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild;
-  while (pCurLayoutItem) {
-    pNextLayoutItem = pCurLayoutItem->m_pNextSibling;
-    if (pCurLayoutItem->m_pFirstChild) {
-      XFA_SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout);
-    }
-    pNotify->OnLayoutEvent(pDocLayout, pCurLayoutItem,
-                           XFA_LAYOUTEVENT_ItemRemoving);
-    delete pCurLayoutItem;
-    pCurLayoutItem = pNextLayoutItem;
-  }
-}
-void CXFA_LayoutPageMgr::SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem) {
-  CXFA_LayoutItem* pNextLayoutItem;
-  CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild;
-  while (pCurLayoutItem) {
-    pNextLayoutItem = pCurLayoutItem->m_pNextSibling;
-    if (pCurLayoutItem->IsContentLayoutItem()) {
-      FX_DWORD dwFlag = pCurLayoutItem->m_pFormNode->GetFlag();
-      if (dwFlag & (XFA_NODEFLAG_HasRemoved)) {
-        IXFA_Notify* pNotify =
-            m_pTemplatePageSetRoot->GetDocument()->GetParser()->GetNotify();
-        IXFA_DocLayout* pDocLayout =
-            m_pTemplatePageSetRoot->GetDocument()->GetDocLayout();
-        if (pCurLayoutItem->m_pFirstChild) {
-          XFA_SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout);
-        }
-        pNotify->OnLayoutEvent(pDocLayout, pCurLayoutItem,
-                               XFA_LAYOUTEVENT_ItemRemoving);
-        delete pCurLayoutItem;
-        pCurLayoutItem = pNextLayoutItem;
-        continue;
-      }
-      if (dwFlag & XFA_NODEFLAG_LayoutGeneratedNode) {
-        CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
-            sIterator(pCurLayoutItem->m_pFormNode);
-        for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-             pNode = sIterator.MoveToNext()) {
-          pNode->SetFlag(XFA_NODEFLAG_UnusedNode, TRUE, FALSE);
-        }
-      }
-    }
-    if (pCurLayoutItem->m_pFirstChild) {
-      SaveLayoutItem(pCurLayoutItem);
-    }
-    pCurLayoutItem->m_pParent = NULL;
-    pCurLayoutItem->m_pNextSibling = NULL;
-    pCurLayoutItem->m_pFirstChild = NULL;
-    if (!pCurLayoutItem->IsContentLayoutItem() &&
-        pCurLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageArea) {
-      delete pCurLayoutItem;
-    }
-    pCurLayoutItem = pNextLayoutItem;
-  }
-}
-CXFA_Node* CXFA_LayoutPageMgr::QueryOverflow(
-    CXFA_Node* pFormNode,
-    CXFA_LayoutContext* pLayoutContext) {
-  for (CXFA_Node* pCurNode = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
-    if (pCurNode->GetClassID() == XFA_ELEMENT_Break) {
-      CFX_WideStringC wsOverflowLeader;
-      CFX_WideStringC wsOverflowTarget;
-      CFX_WideStringC wsOverflowTrailer;
-      pCurNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
-      pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
-      pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
-      if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
-          !wsOverflowTarget.IsEmpty()) {
-        return pCurNode;
-      }
-      return NULL;
-    } else if (pCurNode->GetClassID() == XFA_ELEMENT_Overflow) {
-      return pCurNode;
-    }
-  }
-  return NULL;
-}
-void CXFA_LayoutPageMgr::MergePageSetContents() {
-  CXFA_Document* pDocument = m_pTemplatePageSetRoot->GetDocument();
-  IXFA_Notify* pNotify = pDocument->GetParser()->GetNotify();
-  IXFA_DocLayout* pDocLayout = pDocument->GetDocLayout();
-  CXFA_ContainerLayoutItem* pRootLayout = GetRootLayoutItem();
-  {
-    for (int32_t iIndex = 0; iIndex < pDocument->m_pPendingPageSet.GetSize();
-         iIndex++) {
-      CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
-          sIterator(pDocument->m_pPendingPageSet.GetAt(iIndex));
-      for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-           pNode = sIterator.MoveToNext()) {
-        if (pNode->IsContainerNode()) {
-          CXFA_Node* pBindNode = pNode->GetBindData();
-          if (pBindNode) {
-            pBindNode->RemoveBindItem(pNode);
-            pNode->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
-          }
-        }
-        pNode->SetFlag(XFA_NODEFLAG_UnusedNode);
-      }
-    }
-  }
-  int32_t iIndex = 0;
-  CXFA_Node* pPendingPageSet = NULL;
-  for (; pRootLayout;
-       pRootLayout = (CXFA_ContainerLayoutItem*)pRootLayout->m_pNextSibling) {
-    pPendingPageSet = NULL;
-    CXFA_NodeIteratorTemplate<
-        CXFA_ContainerLayoutItem,
-        CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
-        iterator(pRootLayout);
-    CXFA_ContainerLayoutItem* pRootPageSetContainerItem = iterator.GetCurrent();
-    ASSERT(pRootPageSetContainerItem->m_pFormNode->GetClassID() ==
-           XFA_ELEMENT_PageSet);
-    if (iIndex < pDocument->m_pPendingPageSet.GetSize()) {
-      pPendingPageSet = pDocument->m_pPendingPageSet.GetAt(iIndex);
-      iIndex++;
-    }
-    if (!pPendingPageSet) {
-      if (pRootPageSetContainerItem->m_pFormNode->GetPacketID() ==
-          XFA_XDPPACKET_Template) {
-        pPendingPageSet =
-            pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE);
-      } else {
-        pPendingPageSet = pRootPageSetContainerItem->m_pFormNode;
-      }
-    }
-    if (pRootPageSetContainerItem->m_pFormNode->GetUserData(
-            XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) {
-      pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY,
-                                                          NULL);
-    }
-    pRootPageSetContainerItem->m_pFormNode = pPendingPageSet;
-    pPendingPageSet->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-    for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext();
-         pContainerItem; pContainerItem = iterator.MoveToNext()) {
-      CXFA_Node* pNode = pContainerItem->m_pFormNode;
-      if (pNode->GetPacketID() != XFA_XDPPACKET_Template) {
-        continue;
-      }
-      switch (pNode->GetClassID()) {
-        case XFA_ELEMENT_PageSet: {
-          CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
-          pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer(
-              pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE);
-        } break;
-        case XFA_ELEMENT_PageArea: {
-          CXFA_ContainerLayoutItem* pFormLayout = pContainerItem;
-          CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
-          FX_BOOL bIsExistForm = TRUE;
-          for (int32_t iLevel = 0; iLevel < 3; iLevel++) {
-            pFormLayout = (CXFA_ContainerLayoutItem*)pFormLayout->m_pFirstChild;
-            if (iLevel == 2) {
-              while (pFormLayout &&
-                     !XFA_ItemLayoutProcessor_IsTakingSpace(
-                         pFormLayout->m_pFormNode)) {
-                pFormLayout =
-                    (CXFA_ContainerLayoutItem*)pFormLayout->m_pNextSibling;
-              }
-            }
-            if (pFormLayout == NULL) {
-              bIsExistForm = FALSE;
-              break;
-            }
-          }
-          if (bIsExistForm) {
-            CXFA_Node* pNewSubform = pFormLayout->m_pFormNode;
-            if (pContainerItem->m_pOldSubform &&
-                pContainerItem->m_pOldSubform != pNewSubform) {
-              CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
-                  pDocument, pContainerItem->m_pFormNode->GetClassID(),
-                  pContainerItem->m_pFormNode->GetNameHash(), pParentNode);
-              CXFA_ContainerIterator sIterator(pExistingNode);
-              for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
-                   pNode = sIterator.MoveToNext()) {
-                if (pNode->GetClassID() != XFA_ELEMENT_ContentArea) {
-                  CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
-                      pNode->GetUserData(XFA_LAYOUTITEMKEY));
-                  if (pLayoutItem) {
-                    pNotify->OnLayoutEvent(pDocLayout, pLayoutItem,
-                                           XFA_LAYOUTEVENT_ItemRemoving);
-                    delete pLayoutItem;
-                  }
-                }
-              }
-              if (pExistingNode) {
-                pParentNode->RemoveChild(pExistingNode);
-              }
-            }
-            pContainerItem->m_pOldSubform = pNewSubform;
-          }
-          pContainerItem->m_pFormNode = pDocument->DataMerge_CopyContainer(
-              pContainerItem->m_pFormNode, pParentNode,
-              ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)), TRUE);
-        } break;
-        case XFA_ELEMENT_ContentArea: {
-          CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
-          for (CXFA_Node* pChildNode =
-                   pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-               pChildNode;
-               pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-            if (pChildNode->GetTemplateNode() != pContainerItem->m_pFormNode) {
-              continue;
-            }
-            pContainerItem->m_pFormNode = pChildNode;
-            break;
-          }
-        } break;
-        default:
-          break;
-      }
-    }
-    if (!pPendingPageSet->GetNodeItem(XFA_NODEITEM_Parent)) {
-      CXFA_Node* pFormToplevelSubform =
-          pDocument->GetXFAObject(XFA_HASHCODE_Form)
-              ->AsNode()
-              ->GetFirstChildByClass(XFA_ELEMENT_Subform);
-      pFormToplevelSubform->InsertChild(pPendingPageSet);
-    }
-    pDocument->DataMerge_UpdateBindingRelations(pPendingPageSet);
-    pPendingPageSet->SetFlag(XFA_NODEFLAG_Initialized);
-  }
-  pPendingPageSet = GetRootLayoutItem()->m_pFormNode;
-  while (pPendingPageSet) {
-    CXFA_Node* pNextPendingPageSet =
-        pPendingPageSet->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
-    CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
-        sIterator(pPendingPageSet);
-    CXFA_Node* pNode = sIterator.GetCurrent();
-    while (pNode) {
-      if (pNode->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-        if (pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) {
-          XFA_ELEMENT eCurId = pNode->GetClassID();
-          if (eCurId == XFA_ELEMENT_PageArea || eCurId == XFA_ELEMENT_PageSet) {
-            CXFA_ContainerIterator iteChild(pNode);
-            CXFA_Node* pChildNode = iteChild.MoveToNext();
-            for (; pChildNode; pChildNode = iteChild.MoveToNext()) {
-              CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
-                  pChildNode->GetUserData(XFA_LAYOUTITEMKEY));
-              if (pLayoutItem) {
-                pNotify->OnLayoutEvent(pDocLayout, pLayoutItem,
-                                       XFA_LAYOUTEVENT_ItemRemoving);
-                delete pLayoutItem;
-              }
-            }
-          } else if (eCurId != XFA_ELEMENT_ContentArea) {
-            CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
-                pNode->GetUserData(XFA_LAYOUTITEMKEY));
-            if (pLayoutItem) {
-              pNotify->OnLayoutEvent(pDocLayout, pLayoutItem,
-                                     XFA_LAYOUTEVENT_ItemRemoving);
-              delete pLayoutItem;
-            }
-          }
-          CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
-          pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
-          pNode = pNext;
-        } else {
-          pNode->SetFlag(XFA_NODEFLAG_UnusedNode, FALSE);
-          pNode->SetFlag(XFA_NODEFLAG_Initialized);
-          pNode = sIterator.MoveToNext();
-        }
-      } else {
-        pNode->SetFlag(XFA_NODEFLAG_Initialized);
-        pNode = sIterator.MoveToNext();
-      }
-    }
-    pPendingPageSet = pNextPendingPageSet;
-  }
-}
-void CXFA_LayoutPageMgr::LayoutPageSetContents() {
-  CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem();
-  for (; pRootLayoutItem;
-       pRootLayoutItem =
-           (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) {
-    CXFA_NodeIteratorTemplate<
-        CXFA_ContainerLayoutItem,
-        CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
-        iterator(pRootLayoutItem);
-    for (CXFA_ContainerLayoutItem* pContainerItem = iterator.GetCurrent();
-         pContainerItem; pContainerItem = iterator.MoveToNext()) {
-      CXFA_Node* pNode = pContainerItem->m_pFormNode;
-      switch (pNode->GetClassID()) {
-        case XFA_ELEMENT_PageArea:
-          m_pLayoutProcessor->GetRootRootItemLayoutProcessor()
-              ->DoLayoutPageArea(pContainerItem);
-          break;
-        default:
-          break;
-      }
-    }
-  }
-}
-void XFA_SyncContainer(IXFA_Notify* pNotify,
-                       IXFA_DocLayout* pDocLayout,
-                       CXFA_LayoutItem* pContainerItem,
-                       FX_DWORD dwRelevant,
-                       FX_BOOL bVisible,
-                       int32_t nPageIndex) {
-  FX_BOOL bVisibleItem = FALSE;
-  FX_DWORD dwStatus = 0;
-  FX_DWORD dwRelevantContainer = 0;
-  if (bVisible) {
-    XFA_ATTRIBUTEENUM eAttributeValue =
-        pContainerItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence);
-    if (eAttributeValue == XFA_ATTRIBUTEENUM_Visible ||
-        eAttributeValue == XFA_ATTRIBUTEENUM_Unknown) {
-      bVisibleItem = TRUE;
-    }
-    dwRelevantContainer =
-        XFA_GetRelevant(pContainerItem->m_pFormNode, dwRelevant);
-    dwStatus =
-        (bVisibleItem ? XFA_LAYOUTSTATUS_Visible : 0) | dwRelevantContainer;
-  }
-  pNotify->OnLayoutEvent(pDocLayout, pContainerItem, XFA_LAYOUTEVENT_ItemAdded,
-                         (void*)(uintptr_t)nPageIndex,
-                         (void*)(uintptr_t)dwStatus);
-  for (CXFA_LayoutItem* pChild = pContainerItem->m_pFirstChild; pChild;
-       pChild = pChild->m_pNextSibling) {
-    if (pChild->IsContentLayoutItem()) {
-      XFA_SyncContainer(pNotify, pDocLayout, pChild, dwRelevantContainer,
-                        bVisibleItem, nPageIndex);
-    }
-  }
-}
-void CXFA_LayoutPageMgr::SyncLayoutData() {
-  MergePageSetContents();
-  LayoutPageSetContents();
-  IXFA_Notify* pNotify =
-      m_pTemplatePageSetRoot->GetDocument()->GetParser()->GetNotify();
-  int32_t nPageIdx = -1;
-  CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem();
-  for (; pRootLayoutItem;
-       pRootLayoutItem =
-           (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling) {
-    CXFA_NodeIteratorTemplate<
-        CXFA_ContainerLayoutItem,
-        CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
-        iteratorParent(pRootLayoutItem);
-    for (CXFA_ContainerLayoutItem* pContainerItem = iteratorParent.GetCurrent();
-         pContainerItem; pContainerItem = iteratorParent.MoveToNext()) {
-      switch (pContainerItem->m_pFormNode->GetClassID()) {
-        case XFA_ELEMENT_PageArea: {
-          nPageIdx++;
-          FX_DWORD dwRelevant =
-              XFA_LAYOUTSTATUS_Viewable | XFA_LAYOUTSTATUS_Printable;
-          CXFA_NodeIteratorTemplate<CXFA_LayoutItem,
-                                    CXFA_TraverseStrategy_LayoutItem>
-              iterator(pContainerItem);
-          CXFA_LayoutItem* pChildLayoutItem = iterator.GetCurrent();
-          while (pChildLayoutItem) {
-            CXFA_ContentLayoutItem* pContentItem =
-                pChildLayoutItem->AsContentLayoutItem();
-            if (!pContentItem) {
-              pChildLayoutItem = iterator.MoveToNext();
-              continue;
-            }
-            FX_BOOL bVisible =
-                (pContentItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence) ==
-                 XFA_ATTRIBUTEENUM_Visible);
-            FX_DWORD dwRelevantChild =
-                XFA_GetRelevant(pContentItem->m_pFormNode, dwRelevant);
-            XFA_SyncContainer(pNotify, m_pLayoutProcessor, pContentItem,
-                              dwRelevantChild, bVisible, nPageIdx);
-            pChildLayoutItem = iterator.SkipChildrenAndMoveToNext();
-          }
-        } break;
-        default:
-          break;
-      }
-    }
-  }
-  int32_t nPage = m_PageArray.GetSize();
-  for (int32_t i = nPage - 1; i >= m_nAvailPages; i--) {
-    CXFA_ContainerLayoutItem* pPage = m_PageArray[i];
-    m_PageArray.RemoveAt(i);
-    pNotify->OnPageEvent(pPage, XFA_PAGEEVENT_PageRemoved);
-    delete pPage;
-  }
-  ClearRecordList();
-}
-void XFA_ReleaseLayoutItem_NoPageArea(CXFA_LayoutItem* pLayoutItem) {
-  CXFA_LayoutItem *pNext, *pNode = pLayoutItem->m_pFirstChild;
-  while (pNode) {
-    pNext = pNode->m_pNextSibling;
-    pNode->m_pParent = NULL;
-    XFA_ReleaseLayoutItem_NoPageArea(pNode);
-    pNode = pNext;
-  }
-  if (pLayoutItem->m_pFormNode->GetClassID() != XFA_ELEMENT_PageArea) {
-    delete pLayoutItem;
-  }
-}
-void CXFA_LayoutPageMgr::PrepareLayout() {
-  m_pPageSetCurRoot = NULL;
-  m_ePageSetMode = XFA_ATTRIBUTEENUM_OrderedOccurrence;
-  m_nAvailPages = 0;
-  ClearRecordList();
-  if (!m_pPageSetLayoutItemRoot) {
-    return;
-  }
-  CXFA_ContainerLayoutItem* pRootLayoutItem = m_pPageSetLayoutItemRoot;
-  if (pRootLayoutItem &&
-      pRootLayoutItem->m_pFormNode->GetPacketID() == XFA_XDPPACKET_Form) {
-    CXFA_Node* pPageSetFormNode = pRootLayoutItem->m_pFormNode;
-    pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.RemoveAll();
-    if (pPageSetFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
-      XFA_ReleaseLayoutItem(pRootLayoutItem);
-      m_pPageSetLayoutItemRoot = NULL;
-      pRootLayoutItem = NULL;
-      pPageSetFormNode = NULL;
-      m_PageArray.RemoveAll();
-    }
-    while (pPageSetFormNode) {
-      CXFA_Node* pNextPageSet =
-          pPageSetFormNode->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
-      pPageSetFormNode->GetNodeItem(XFA_NODEITEM_Parent)
-          ->RemoveChild(pPageSetFormNode, FALSE);
-      pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.Add(
-          pPageSetFormNode);
-      pPageSetFormNode = pNextPageSet;
-    }
-  }
-  pRootLayoutItem = m_pPageSetLayoutItemRoot;
-  CXFA_ContainerLayoutItem* pNextLayout = NULL;
-  for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) {
-    pNextLayout = (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling;
-    SaveLayoutItem(pRootLayoutItem);
-    delete pRootLayoutItem;
-  }
-  m_pPageSetLayoutItemRoot = NULL;
-}
diff --git a/xfa/src/fxfa/parser/xfa_layout_pagemgr_new.h b/xfa/src/fxfa/parser/xfa_layout_pagemgr_new.h
deleted file mode 100644
index 5f6607f7cc..0000000000
--- a/xfa/src/fxfa/parser/xfa_layout_pagemgr_new.h
+++ /dev/null
@@ -1,152 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_LAYOUT_PAGEMGR_NEW_H_
-#define XFA_SRC_FXFA_PARSER_XFA_LAYOUT_PAGEMGR_NEW_H_
-
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_layout_itemlayout.h"
-
-class CXFA_ContainerRecord {
- public:
-  CXFA_ContainerRecord(CXFA_ContainerLayoutItem* pPageSet = NULL,
-                       CXFA_ContainerLayoutItem* pPageArea = NULL,
-                       CXFA_ContainerLayoutItem* pContentArea = NULL)
-      : pCurPageSet(pPageSet),
-        pCurPageArea(pPageArea),
-        pCurContentArea(pContentArea) {}
-  CXFA_ContainerLayoutItem* pCurPageSet;
-  CXFA_ContainerLayoutItem* pCurPageArea;
-  CXFA_ContainerLayoutItem* pCurContentArea;
-};
-class CXFA_LayoutPageMgr {
- public:
-  CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor);
-  ~CXFA_LayoutPageMgr();
-  FX_BOOL InitLayoutPage(CXFA_Node* pFormNode);
-  FX_BOOL PrepareFirstPage(CXFA_Node* pRootSubform);
-  FX_FLOAT GetAvailHeight();
-  FX_BOOL GetNextAvailContentHeight(FX_FLOAT fChildHeight);
-  void SubmitContentItem(CXFA_ContentLayoutItem* pContentLayoutItem,
-                         XFA_ItemLayoutProcessorResult eStatus);
-  void FinishPaginatedPageSets();
-  void SyncLayoutData();
-  int32_t GetPageCount() const;
-  IXFA_LayoutPage* GetPage(int32_t index) const;
-  int32_t GetPageIndex(const IXFA_LayoutPage* pPage) const;
-  inline CXFA_ContainerLayoutItem* GetRootLayoutItem() const {
-    return m_pPageSetLayoutItemRoot;
-  }
-  FX_BOOL ProcessBreakBeforeOrAfter(CXFA_Node* pBreakNode,
-                                    FX_BOOL bBefore,
-                                    CXFA_Node*& pBreakLeaderNode,
-                                    CXFA_Node*& pBreakTrailerNode,
-                                    FX_BOOL& bCreatePage);
-  FX_BOOL ProcessOverflow(CXFA_Node* pFormNode,
-                          CXFA_Node*& pLeaderNode,
-                          CXFA_Node*& pTrailerNode,
-                          FX_BOOL bDataMerge = FALSE,
-                          FX_BOOL bCreatePage = TRUE);
-  CXFA_Node* QueryOverflow(CXFA_Node* pFormNode,
-                           CXFA_LayoutContext* pLayoutContext = NULL);
-  FX_BOOL ProcessBookendLeaderOrTrailer(CXFA_Node* pBookendNode,
-                                        FX_BOOL bLeader,
-                                        CXFA_Node*& pBookendAppendNode);
-  CXFA_LayoutItem* FindOrCreateLayoutItem(CXFA_Node* pFormNode);
-
- protected:
-  FX_BOOL AppendNewPage(FX_BOOL bFirstTemPage = FALSE);
-  void ReorderPendingLayoutRecordToTail(CXFA_ContainerRecord* pNewRecord,
-                                        CXFA_ContainerRecord* pPrevRecord);
-  void RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord,
-                          CXFA_ContainerRecord* pPrevRecord);
-  inline CXFA_ContainerRecord* GetCurrentContainerRecord() {
-    CXFA_ContainerRecord* result =
-        ((CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetAt(
-            m_pCurrentContainerRecord));
-    ASSERT(result);
-    return result;
-  }
-  CXFA_ContainerRecord* CreateContainerRecord(CXFA_Node* pPageNode = NULL,
-                                              FX_BOOL bCreateNew = FALSE);
-  void AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord,
-                             CXFA_Node* pNewPageArea);
-  void AddContentAreaLayoutItem(CXFA_ContainerRecord* pNewRecord,
-                                CXFA_Node* pContentArea);
-  FX_BOOL RunBreak(XFA_ELEMENT eBreakType,
-                   XFA_ATTRIBUTEENUM eTargetType,
-                   CXFA_Node* pTarget,
-                   FX_BOOL bStartNew);
-  CXFA_Node* BreakOverflow(CXFA_Node* pOverflowNode,
-                           CXFA_Node*& pLeaderTemplate,
-                           CXFA_Node*& pTrailerTemplate,
-                           FX_BOOL bCreatePage = TRUE);
-  FX_BOOL ResolveBookendLeaderOrTrailer(CXFA_Node* pBookendNode,
-                                        FX_BOOL bLeader,
-                                        CXFA_Node*& pBookendAppendTemplate);
-  FX_BOOL ExecuteBreakBeforeOrAfter(CXFA_Node* pCurNode,
-                                    FX_BOOL bBefore,
-                                    CXFA_Node*& pBreakLeaderTemplate,
-                                    CXFA_Node*& pBreakTrailerTemplate);
-
-  int32_t CreateMinPageRecord(CXFA_Node* pPageArea,
-                              FX_BOOL bTargetPageArea,
-                              FX_BOOL bCreateLast = FALSE);
-  void CreateMinPageSetRecord(CXFA_Node* pPageSet, FX_BOOL bCreateAll = FALSE);
-  void CreateNextMinRecord(CXFA_Node* pRecordNode);
-  FX_BOOL FindPageAreaFromPageSet(CXFA_Node* pPageSet,
-                                  CXFA_Node* pStartChild,
-                                  CXFA_Node* pTargetPageArea = NULL,
-                                  CXFA_Node* pTargetContentArea = NULL,
-                                  FX_BOOL bNewPage = FALSE,
-                                  FX_BOOL bQuery = FALSE);
-  FX_BOOL FindPageAreaFromPageSet_Ordered(CXFA_Node* pPageSet,
-                                          CXFA_Node* pStartChild,
-                                          CXFA_Node* pTargetPageArea = NULL,
-                                          CXFA_Node* pTargetContentArea = NULL,
-                                          FX_BOOL bNewPage = FALSE,
-                                          FX_BOOL bQuery = FALSE);
-  FX_BOOL FindPageAreaFromPageSet_SimplexDuplex(
-      CXFA_Node* pPageSet,
-      CXFA_Node* pStartChild,
-      CXFA_Node* pTargetPageArea = NULL,
-      CXFA_Node* pTargetContentArea = NULL,
-      FX_BOOL bNewPage = FALSE,
-      FX_BOOL bQuery = FALSE,
-      XFA_ATTRIBUTEENUM ePreferredPosition = XFA_ATTRIBUTEENUM_First);
-  FX_BOOL MatchPageAreaOddOrEven(CXFA_Node* pPageArea, FX_BOOL bLastMatch);
-  CXFA_Node* GetNextAvailPageArea(CXFA_Node* pTargetPageArea,
-                                  CXFA_Node* pTargetContentArea = NULL,
-                                  FX_BOOL bNewPage = FALSE,
-                                  FX_BOOL bQuery = FALSE);
-  FX_BOOL GetNextContentArea(CXFA_Node* pTargetContentArea);
-  void InitPageSetMap();
-  void ProcessLastPageSet();
-  inline FX_BOOL IsPageSetRootOrderedOccurrence() {
-    return m_ePageSetMode == XFA_ATTRIBUTEENUM_OrderedOccurrence;
-  }
-  void ClearData();
-  void ClearRecordList();
-  void MergePageSetContents();
-  void LayoutPageSetContents();
-  void PrepareLayout();
-  void SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem);
-  CXFA_LayoutProcessor* m_pLayoutProcessor;
-  CXFA_Node* m_pTemplatePageSetRoot;
-  CXFA_ContainerLayoutItem* m_pPageSetLayoutItemRoot;
-  CXFA_ContainerLayoutItem* m_pPageSetCurRoot;
-  FX_POSITION m_pCurrentContainerRecord;
-  CFX_PtrList m_rgProposedContainerRecord;
-  CXFA_Node* m_pCurPageArea;
-  int32_t m_nAvailPages;
-  int32_t m_nCurPageCount;
-  XFA_ATTRIBUTEENUM m_ePageSetMode;
-  FX_BOOL m_bCreateOverFlowPage;
-  CFX_MapPtrTemplate<CXFA_Node*, int32_t> m_pPageSetMap;
-  CFX_ArrayTemplate<CXFA_ContainerLayoutItem*> m_PageArray;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_LAYOUT_PAGEMGR_NEW_H_
diff --git a/xfa/src/fxfa/parser/xfa_locale.cpp b/xfa/src/fxfa/parser/xfa_locale.cpp
deleted file mode 100644
index 5fc465f872..0000000000
--- a/xfa/src/fxfa/parser/xfa_locale.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-// 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/src/fxfa/parser/xfa_locale.h"
-
-#include "core/include/fxcrt/fx_xml.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-static const FX_WCHAR g_FX_Percent[] = L"z,zzz,zzz,zzz,zzz,zzz%";
-static const FX_WCHAR g_FX_Currency[] = L"$z,zzz,zzz,zzz,zzz,zz9.99";
-static const FX_WCHAR g_FX_Decimal[] = L"z,zzz,zzz,zzz,zzz,zz9.zzz";
-static const FX_WCHAR g_FX_Integer[] = L"z,zzz,zzz,zzz,zzz,zzz";
-
-CXFA_XMLLocale::CXFA_XMLLocale(CXML_Element* pLocaleData) {
-  m_pLocaleData = pLocaleData;
-}
-CXFA_XMLLocale::~CXFA_XMLLocale() {
-  if (m_pLocaleData) {
-    delete m_pLocaleData;
-  }
-}
-void CXFA_XMLLocale::Release() {
-  delete this;
-}
-CFX_WideString CXFA_XMLLocale::GetName() {
-  return m_pLocaleData ? m_pLocaleData->GetAttrValue("name") : CFX_WideString();
-}
-void CXFA_XMLLocale::GetNumbericSymbol(FX_LOCALENUMSYMBOL eType,
-                                       CFX_WideString& wsNumSymbol) const {
-  CFX_ByteString bsSymbols;
-  CFX_WideString wsName;
-  switch (eType) {
-    case FX_LOCALENUMSYMBOL_Decimal:
-      bsSymbols = "numberSymbols";
-      wsName = FX_WSTRC(L"decimal");
-      break;
-    case FX_LOCALENUMSYMBOL_Grouping:
-      bsSymbols = "numberSymbols";
-      wsName = FX_WSTRC(L"grouping");
-      break;
-    case FX_LOCALENUMSYMBOL_Percent:
-      bsSymbols = "numberSymbols";
-      wsName = FX_WSTRC(L"percent");
-      break;
-    case FX_LOCALENUMSYMBOL_Minus:
-      bsSymbols = "numberSymbols";
-      wsName = FX_WSTRC(L"minus");
-      break;
-    case FX_LOCALENUMSYMBOL_Zero:
-      bsSymbols = "numberSymbols";
-      wsName = FX_WSTRC(L"zero");
-      break;
-    case FX_LOCALENUMSYMBOL_CurrencySymbol:
-      bsSymbols = "currencySymbols";
-      wsName = FX_WSTRC(L"symbol");
-      break;
-    case FX_LOCALENUMSYMBOL_CurrencyName:
-      bsSymbols = "currencySymbols";
-      wsName = FX_WSTRC(L"isoname");
-      break;
-    default:
-      return;
-  }
-  CXML_Element* pElement = m_pLocaleData->GetElement("", bsSymbols);
-  if (!pElement) {
-    return;
-  }
-  GetPattern(pElement, CFX_ByteStringC((const FX_CHAR*)bsSymbols,
-                                       bsSymbols.GetLength() - 1),
-             wsName, wsNumSymbol);
-}
-void CXFA_XMLLocale::GetDateTimeSymbols(CFX_WideString& wsDtSymbol) const {
-  if (!m_pLocaleData) {
-    return;
-  }
-  CFX_ByteString bsSpace;
-  CXML_Element* pNumberSymbols =
-      m_pLocaleData->GetElement(bsSpace, "dateTimeSymbols");
-  if (!pNumberSymbols) {
-    return;
-  }
-  wsDtSymbol = pNumberSymbols->GetContent(0);
-}
-void CXFA_XMLLocale::GetMonthName(int32_t nMonth,
-                                  CFX_WideString& wsMonthName,
-                                  FX_BOOL bAbbr) const {
-  wsMonthName = GetCalendarSymbol("month", nMonth, bAbbr);
-}
-void CXFA_XMLLocale::GetDayName(int32_t nWeek,
-                                CFX_WideString& wsDayName,
-                                FX_BOOL bAbbr) const {
-  wsDayName = GetCalendarSymbol("day", nWeek, bAbbr);
-}
-void CXFA_XMLLocale::GetMeridiemName(CFX_WideString& wsMeridiemName,
-                                     FX_BOOL bAM) const {
-  wsMeridiemName = GetCalendarSymbol("meridiem", bAM ? 0 : 1, FALSE);
-}
-void CXFA_XMLLocale::GetTimeZone(FX_TIMEZONE& tz) const {
-  IXFA_TimeZoneProvider* pProvider = IXFA_TimeZoneProvider::Get();
-  pProvider->GetTimeZone(tz);
-}
-void CXFA_XMLLocale::GetEraName(CFX_WideString& wsEraName, FX_BOOL bAD) const {
-  wsEraName = GetCalendarSymbol("era", bAD ? 1 : 0, FALSE);
-}
-CFX_WideString CXFA_XMLLocale::GetCalendarSymbol(const CFX_ByteStringC& symbol,
-                                                 int index,
-                                                 FX_BOOL bAbbr) const {
-  CFX_ByteString pstrSymbolNames = symbol + "Names";
-  CFX_WideString wsSymbolName = L"";
-  if (m_pLocaleData) {
-    CXML_Element* pChild = m_pLocaleData->GetElement("", "calendarSymbols");
-    if (pChild) {
-      CXML_Element* pSymbolNames = pChild->GetElement("", pstrSymbolNames);
-      if (pSymbolNames) {
-        if (pSymbolNames->GetAttrInteger("abbr") != bAbbr) {
-          pSymbolNames = pChild->GetElement("", pstrSymbolNames, 1);
-        }
-        if (pSymbolNames && pSymbolNames->GetAttrInteger("abbr") == bAbbr) {
-          CXML_Element* pSymbolName =
-              pSymbolNames->GetElement("", symbol, index);
-          if (pSymbolName) {
-            wsSymbolName = pSymbolName->GetContent(0);
-          }
-        }
-      }
-    }
-  }
-  return wsSymbolName;
-}
-void CXFA_XMLLocale::GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                                    CFX_WideString& wsPattern) const {
-  CXML_Element* pElement = m_pLocaleData->GetElement("", "datePatterns");
-  if (pElement == NULL) {
-    return;
-  }
-  CFX_WideString wsName;
-  switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
-      wsName = L"short";
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
-      wsName = L"med";
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
-      wsName = L"full";
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
-      wsName = L"long";
-      break;
-  }
-  GetPattern(pElement, "datePattern", wsName, wsPattern);
-}
-void CXFA_XMLLocale::GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                                    CFX_WideString& wsPattern) const {
-  CXML_Element* pElement = m_pLocaleData->GetElement("", "timePatterns");
-  if (pElement == NULL) {
-    return;
-  }
-  CFX_WideString wsName;
-  switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
-      wsName = L"short";
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
-      wsName = L"med";
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
-      wsName = L"full";
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
-      wsName = L"long";
-      break;
-  }
-  GetPattern(pElement, "timePattern", wsName, wsPattern);
-}
-void CXFA_XMLLocale::GetNumPattern(FX_LOCALENUMSUBCATEGORY eType,
-                                   CFX_WideString& wsPattern) const {
-  CXML_Element* pElement = m_pLocaleData->GetElement("", "numberPatterns");
-  if (pElement == NULL) {
-    return;
-  }
-  switch (eType) {
-    case FX_LOCALENUMPATTERN_Percent:
-      wsPattern = g_FX_Percent;
-      break;
-    case FX_LOCALENUMPATTERN_Currency:
-      wsPattern = g_FX_Currency;
-      break;
-    case FX_LOCALENUMPATTERN_Decimal:
-      wsPattern = g_FX_Decimal;
-      break;
-    case FX_LOCALENUMPATTERN_Integer:
-      wsPattern = g_FX_Integer;
-      break;
-  }
-}
-void CXFA_XMLLocale::GetPattern(CXML_Element* pElement,
-                                const CFX_ByteStringC& bsTag,
-                                const CFX_WideStringC& wsName,
-                                CFX_WideString& wsPattern) const {
-  int32_t iCount = pElement->CountElements("", bsTag);
-  for (int32_t i = 0; i < iCount; i++) {
-    CXML_Element* pChild = pElement->GetElement("", bsTag, i);
-    if (pChild->GetAttrValue("name") == wsName) {
-      wsPattern = pChild->GetContent(0);
-      return;
-    }
-  }
-}
-CXFA_NodeLocale::CXFA_NodeLocale(CXFA_Node* pLocale) {
-  m_pLocale = pLocale;
-}
-CXFA_NodeLocale::~CXFA_NodeLocale() {}
-void CXFA_NodeLocale::Release() {
-  delete this;
-}
-CFX_WideString CXFA_NodeLocale::GetName() {
-  return m_pLocale ? m_pLocale->GetCData(XFA_ATTRIBUTE_Name) : NULL;
-}
-void CXFA_NodeLocale::GetNumbericSymbol(FX_LOCALENUMSYMBOL eType,
-                                        CFX_WideString& wsNumSymbol) const {
-  switch (eType) {
-    case FX_LOCALENUMSYMBOL_Decimal:
-      wsNumSymbol = GetSymbol(XFA_ELEMENT_NumberSymbols, FX_WSTRC(L"decimal"));
-      break;
-    case FX_LOCALENUMSYMBOL_Grouping:
-      wsNumSymbol = GetSymbol(XFA_ELEMENT_NumberSymbols, FX_WSTRC(L"grouping"));
-      break;
-    case FX_LOCALENUMSYMBOL_Percent:
-      wsNumSymbol = GetSymbol(XFA_ELEMENT_NumberSymbols, FX_WSTRC(L"percent"));
-      break;
-    case FX_LOCALENUMSYMBOL_Minus:
-      wsNumSymbol = GetSymbol(XFA_ELEMENT_NumberSymbols, FX_WSTRC(L"minus"));
-      break;
-    case FX_LOCALENUMSYMBOL_Zero:
-      wsNumSymbol = GetSymbol(XFA_ELEMENT_NumberSymbols, FX_WSTRC(L"zero"));
-      break;
-    case FX_LOCALENUMSYMBOL_CurrencySymbol:
-      wsNumSymbol = GetSymbol(XFA_ELEMENT_CurrencySymbols, FX_WSTRC(L"symbol"));
-      break;
-    case FX_LOCALENUMSYMBOL_CurrencyName:
-      wsNumSymbol =
-          GetSymbol(XFA_ELEMENT_CurrencySymbols, FX_WSTRC(L"isoname"));
-      break;
-  }
-}
-void CXFA_NodeLocale::GetDateTimeSymbols(CFX_WideString& wsDtSymbol) const {
-  CXFA_Node* pSymbols =
-      m_pLocale ? m_pLocale->GetChild(0, XFA_ELEMENT_DateTimeSymbols) : NULL;
-  wsDtSymbol = pSymbols ? pSymbols->GetContent() : CFX_WideString();
-}
-void CXFA_NodeLocale::GetMonthName(int32_t nMonth,
-                                   CFX_WideString& wsMonthName,
-                                   FX_BOOL bAbbr) const {
-  wsMonthName = GetCalendarSymbol(XFA_ELEMENT_MonthNames, nMonth, bAbbr);
-}
-void CXFA_NodeLocale::GetDayName(int32_t nWeek,
-                                 CFX_WideString& wsDayName,
-                                 FX_BOOL bAbbr) const {
-  wsDayName = GetCalendarSymbol(XFA_ELEMENT_DayNames, nWeek, bAbbr);
-}
-void CXFA_NodeLocale::GetMeridiemName(CFX_WideString& wsMeridiemName,
-                                      FX_BOOL bAM) const {
-  wsMeridiemName =
-      GetCalendarSymbol(XFA_ELEMENT_MeridiemNames, bAM ? 0 : 1, FALSE);
-}
-void CXFA_NodeLocale::GetTimeZone(FX_TIMEZONE& tz) const {
-  IXFA_TimeZoneProvider* pProvider = IXFA_TimeZoneProvider::Get();
-  pProvider->GetTimeZone(tz);
-}
-void CXFA_NodeLocale::GetEraName(CFX_WideString& wsEraName, FX_BOOL bAD) const {
-  wsEraName = GetCalendarSymbol(XFA_ELEMENT_EraNames, bAD ? 1 : 0, FALSE);
-}
-void CXFA_NodeLocale::GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                                     CFX_WideString& wsPattern) const {
-  switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
-      wsPattern = GetSymbol(XFA_ELEMENT_DatePatterns, FX_WSTRC(L"short"));
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
-      wsPattern = GetSymbol(XFA_ELEMENT_DatePatterns, FX_WSTRC(L"med"));
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
-      wsPattern = GetSymbol(XFA_ELEMENT_DatePatterns, FX_WSTRC(L"full"));
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
-      wsPattern = GetSymbol(XFA_ELEMENT_DatePatterns, FX_WSTRC(L"long"));
-      break;
-  }
-}
-void CXFA_NodeLocale::GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                                     CFX_WideString& wsPattern) const {
-  switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
-      wsPattern = GetSymbol(XFA_ELEMENT_TimePatterns, FX_WSTRC(L"short"));
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
-      wsPattern = GetSymbol(XFA_ELEMENT_TimePatterns, FX_WSTRC(L"med"));
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
-      wsPattern = GetSymbol(XFA_ELEMENT_TimePatterns, FX_WSTRC(L"full"));
-      break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
-      wsPattern = GetSymbol(XFA_ELEMENT_TimePatterns, FX_WSTRC(L"long"));
-      break;
-  }
-}
-void CXFA_NodeLocale::GetNumPattern(FX_LOCALENUMSUBCATEGORY eType,
-                                    CFX_WideString& wsPattern) const {
-  switch (eType) {
-    case FX_LOCALENUMPATTERN_Percent:
-      wsPattern = g_FX_Percent;
-      break;
-    case FX_LOCALENUMPATTERN_Currency:
-      wsPattern = g_FX_Currency;
-      break;
-    case FX_LOCALENUMPATTERN_Decimal:
-      wsPattern = g_FX_Decimal;
-      break;
-    case FX_LOCALENUMPATTERN_Integer:
-      wsPattern = g_FX_Integer;
-      break;
-  }
-}
-CXFA_Node* CXFA_NodeLocale::GetNodeByName(CXFA_Node* pParent,
-                                          const CFX_WideStringC& wsName) const {
-  CXFA_Node* pChild =
-      pParent ? pParent->GetNodeItem(XFA_NODEITEM_FirstChild) : NULL;
-  while (pChild) {
-    CFX_WideString wsChild;
-    if (pChild->GetAttribute(XFA_ATTRIBUTE_Name, wsChild)) {
-      if (wsChild == wsName) {
-        return pChild;
-      }
-    }
-    pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  return NULL;
-}
-CFX_WideString CXFA_NodeLocale::GetSymbol(
-    XFA_ELEMENT eElement,
-    const CFX_WideStringC& symbol_type) const {
-  CXFA_Node* pSymbols = m_pLocale ? m_pLocale->GetChild(0, eElement) : NULL;
-  CXFA_Node* pSymbol = GetNodeByName(pSymbols, symbol_type);
-  return pSymbol ? pSymbol->GetContent() : CFX_WideString();
-}
-CFX_WideString CXFA_NodeLocale::GetCalendarSymbol(XFA_ELEMENT eElement,
-                                                  int index,
-                                                  FX_BOOL bAbbr) const {
-  CXFA_Node* pCalendar =
-      m_pLocale ? m_pLocale->GetChild(0, XFA_ELEMENT_CalendarSymbols) : NULL;
-  if (pCalendar) {
-    CXFA_Node* pNode = pCalendar->GetFirstChildByClass(eElement);
-    for (; pNode; pNode = pNode->GetNextSameClassSibling(eElement)) {
-      if (pNode->GetBoolean(XFA_ATTRIBUTE_Abbr) == bAbbr) {
-        CXFA_Node* pSymbol = pNode->GetChild(index, XFA_ELEMENT_UNKNOWN);
-        return pSymbol ? pSymbol->GetContent() : CFX_WideString();
-      }
-    }
-  }
-  return CFX_WideString();
-}
diff --git a/xfa/src/fxfa/parser/xfa_locale.h b/xfa/src/fxfa/parser/xfa_locale.h
deleted file mode 100644
index f4b128e67e..0000000000
--- a/xfa/src/fxfa/parser/xfa_locale.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_LOCALE_H_
-#define XFA_SRC_FXFA_PARSER_XFA_LOCALE_H_
-
-#include "xfa/src/fgas/localization/fgas_locale.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-class CXFA_XMLLocale : public IFX_Locale {
- public:
-  CXFA_XMLLocale(CXML_Element* pLocaleData);
-  virtual void Release();
-  virtual CFX_WideString GetName();
-  virtual void GetNumbericSymbol(FX_LOCALENUMSYMBOL eType,
-                                 CFX_WideString& wsNumSymbol) const;
-
-  virtual void GetDateTimeSymbols(CFX_WideString& wsDtSymbol) const;
-  virtual void GetMonthName(int32_t nMonth,
-                            CFX_WideString& wsMonthName,
-                            FX_BOOL bAbbr = TRUE) const;
-  virtual void GetDayName(int32_t nWeek,
-                          CFX_WideString& wsDayName,
-                          FX_BOOL bAbbr = TRUE) const;
-  virtual void GetMeridiemName(CFX_WideString& wsMeridiemName,
-                               FX_BOOL bAM = TRUE) const;
-  virtual void GetTimeZone(FX_TIMEZONE& tz) const;
-  virtual void GetEraName(CFX_WideString& wsEraName, FX_BOOL bAD = TRUE) const;
-
-  virtual void GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                              CFX_WideString& wsPattern) const;
-  virtual void GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                              CFX_WideString& wsPattern) const;
-  virtual void GetNumPattern(FX_LOCALENUMSUBCATEGORY eType,
-                             CFX_WideString& wsPattern) const;
-
- protected:
-  ~CXFA_XMLLocale();
-  void GetPattern(CXML_Element* pElement,
-                  const CFX_ByteStringC& bsTag,
-                  const CFX_WideStringC& wsName,
-                  CFX_WideString& wsPattern) const;
-  CFX_WideString GetCalendarSymbol(const CFX_ByteStringC& symbol,
-                                   int index,
-                                   FX_BOOL bAbbr) const;
-
- private:
-  CXML_Element* m_pLocaleData;
-};
-class CXFA_NodeLocale : public IFX_Locale {
- public:
-  CXFA_NodeLocale(CXFA_Node* pLocale);
-  virtual void Release();
-  virtual CFX_WideString GetName();
-  virtual void GetNumbericSymbol(FX_LOCALENUMSYMBOL eType,
-                                 CFX_WideString& wsNumSymbol) const;
-
-  virtual void GetDateTimeSymbols(CFX_WideString& wsDtSymbol) const;
-  virtual void GetMonthName(int32_t nMonth,
-                            CFX_WideString& wsMonthName,
-                            FX_BOOL bAbbr = TRUE) const;
-  virtual void GetDayName(int32_t nWeek,
-                          CFX_WideString& wsDayName,
-                          FX_BOOL bAbbr = TRUE) const;
-  virtual void GetMeridiemName(CFX_WideString& wsMeridiemName,
-                               FX_BOOL bAM = TRUE) const;
-  virtual void GetTimeZone(FX_TIMEZONE& tz) const;
-  virtual void GetEraName(CFX_WideString& wsEraName, FX_BOOL bAD = TRUE) const;
-
-  virtual void GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                              CFX_WideString& wsPattern) const;
-  virtual void GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY eType,
-                              CFX_WideString& wsPattern) const;
-  virtual void GetNumPattern(FX_LOCALENUMSUBCATEGORY eType,
-                             CFX_WideString& wsPattern) const;
-
- protected:
-  ~CXFA_NodeLocale();
-  CXFA_Node* GetNodeByName(CXFA_Node* pParent,
-                           const CFX_WideStringC& wsName) const;
-  CFX_WideString GetSymbol(XFA_ELEMENT eElement,
-                           const CFX_WideStringC& symbol_type) const;
-  CFX_WideString GetCalendarSymbol(XFA_ELEMENT eElement,
-                                   int index,
-                                   FX_BOOL bAbbr) const;
-
-  CXFA_Node* m_pLocale;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_LOCALE_H_
diff --git a/xfa/src/fxfa/parser/xfa_localemgr.cpp b/xfa/src/fxfa/parser/xfa_localemgr.cpp
deleted file mode 100644
index bb27c9c1e2..0000000000
--- a/xfa/src/fxfa/parser/xfa_localemgr.cpp
+++ /dev/null
@@ -1,1305 +0,0 @@
-// 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/src/fxfa/parser/xfa_localemgr.h"
-
-#include "core/include/fxcodec/fx_codec.h"
-#include "core/include/fxcrt/fx_xml.h"
-#include "core/include/fxge/fx_ge.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_locale.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-const uint8_t g_enUS_Locale[] = {
-    0x78, 0x9C, 0x95, 0x56, 0xD1, 0x6E, 0x9B, 0x30, 0x14, 0x7D, 0x9F, 0xB4,
-    0x7F, 0x40, 0xD6, 0x2A, 0xB5, 0x52, 0x56, 0x6F, 0x8F, 0xA9, 0x88, 0xA5,
-    0x6C, 0x24, 0x9B, 0x3A, 0xD1, 0x55, 0x22, 0x55, 0xB5, 0xBE, 0x4C, 0x0E,
-    0xDC, 0x05, 0x34, 0xB0, 0x23, 0x83, 0x37, 0x05, 0xED, 0xE3, 0x67, 0x07,
-    0xC3, 0xC0, 0xF6, 0x24, 0xC2, 0x4B, 0x7C, 0xCF, 0x3D, 0xE7, 0xE6, 0xDE,
-    0x63, 0x30, 0x84, 0x25, 0x4F, 0x69, 0x09, 0x01, 0xA3, 0x15, 0xAC, 0x10,
-    0xB0, 0xEF, 0x4F, 0x09, 0x0A, 0x32, 0xA8, 0xD3, 0x15, 0xDA, 0xB0, 0x43,
-    0x59, 0xD4, 0xF9, 0xF5, 0xBA, 0x02, 0x51, 0xA4, 0xF4, 0x06, 0x91, 0x50,
-    0x53, 0x59, 0x46, 0x45, 0x72, 0xAA, 0xF6, 0xBC, 0xAC, 0x8D, 0xEA, 0x20,
-    0xE0, 0xC0, 0x45, 0x41, 0x99, 0x62, 0x54, 0x9C, 0x35, 0xF9, 0x83, 0x82,
-    0x6B, 0xB3, 0x26, 0xF7, 0x94, 0x49, 0x2A, 0x4E, 0x21, 0xEE, 0xC2, 0xD7,
-    0xAF, 0x0C, 0xBE, 0x85, 0xBD, 0xF0, 0x26, 0x62, 0x2A, 0xD2, 0xDC, 0x41,
-    0xD7, 0x47, 0x51, 0x94, 0x1E, 0xAE, 0xAB, 0xBF, 0x97, 0x0C, 0x3C, 0x60,
-    0xE9, 0x32, 0xD7, 0xF2, 0x20, 0xEB, 0xC6, 0x81, 0x13, 0x38, 0x36, 0x50,
-    0xED, 0x41, 0x38, 0x99, 0xAF, 0x69, 0xC3, 0x7D, 0xF8, 0x03, 0xFF, 0xE5,
-    0x17, 0x44, 0x90, 0xDA, 0x09, 0x3C, 0xB2, 0xA8, 0xE7, 0x9D, 0xA3, 0x80,
-    0xEE, 0xF7, 0x62, 0x85, 0xDE, 0xA3, 0x91, 0x73, 0x3E, 0xD7, 0x7C, 0x86,
-    0xF9, 0xEC, 0x9A, 0x6B, 0x96, 0xCF, 0x2B, 0x9F, 0x55, 0x3E, 0x9F, 0x7C,
-    0x0E, 0xF9, 0xDC, 0xF1, 0x19, 0xF3, 0x7F, 0x4F, 0x32, 0x7A, 0x32, 0xB7,
-    0x90, 0x5A, 0x91, 0x44, 0xAA, 0x5B, 0x4E, 0x75, 0xAE, 0xD7, 0x5D, 0x92,
-    0xC4, 0xDC, 0x81, 0x76, 0x12, 0x6A, 0x1B, 0x7B, 0x86, 0x8C, 0xB9, 0xE8,
-    0x2E, 0x97, 0xC2, 0x01, 0xB7, 0xA2, 0xB0, 0xA1, 0x84, 0x36, 0x52, 0x8C,
-    0x41, 0x3C, 0xF4, 0x35, 0xEA, 0x71, 0xB4, 0x6B, 0xA6, 0x59, 0xBB, 0x53,
-    0xBB, 0x4D, 0xBB, 0x45, 0xBB, 0x39, 0xBB, 0x2F, 0xBB, 0x29, 0x7F, 0x3F,
-    0xFA, 0x21, 0xCD, 0x0A, 0xA8, 0xFA, 0x67, 0xCF, 0x84, 0x64, 0x1D, 0x2B,
-    0x77, 0xFB, 0x60, 0xC4, 0x23, 0x8F, 0x56, 0x02, 0x4F, 0x2B, 0x28, 0x04,
-    0x04, 0x35, 0xD5, 0xD4, 0x8A, 0x7C, 0xF8, 0x18, 0x62, 0xFD, 0xDB, 0x25,
-    0xC8, 0x3A, 0x1A, 0x42, 0x3C, 0x10, 0x75, 0x60, 0x9D, 0x11, 0x5D, 0xE3,
-    0x0D, 0x3C, 0xD2, 0xA6, 0x01, 0xC1, 0xCE, 0x7B, 0x3A, 0x44, 0xE6, 0x00,
-    0xF9, 0x21, 0xCB, 0x12, 0x91, 0x8D, 0xBA, 0x16, 0x41, 0xAC, 0xAE, 0x20,
-    0x5A, 0x04, 0xDF, 0xD4, 0xA5, 0x27, 0x1C, 0xB8, 0x56, 0x21, 0x23, 0x2D,
-    0x39, 0x3B, 0x20, 0x72, 0xA1, 0xA8, 0x82, 0xEC, 0xAC, 0xB9, 0x40, 0x52,
-    0xE7, 0x5C, 0x34, 0x4A, 0x84, 0x23, 0xEC, 0xE1, 0xE3, 0xC9, 0x84, 0x0A,
-    0x68, 0x8A, 0x6A, 0x34, 0xF1, 0x28, 0x9A, 0x4C, 0x9C, 0xDF, 0xC5, 0xF1,
-    0x5D, 0x92, 0x04, 0xEB, 0xE0, 0x25, 0xC4, 0x23, 0x92, 0x55, 0x61, 0x32,
-    0xEA, 0x65, 0x9A, 0xF3, 0xA4, 0x83, 0x64, 0x86, 0xC0, 0xCC, 0xA9, 0x25,
-    0x1E, 0x3E, 0x9E, 0xCC, 0x65, 0x8C, 0xDA, 0x29, 0xAC, 0xDF, 0xEC, 0x4F,
-    0xA7, 0x38, 0xFB, 0xF9, 0xB9, 0xAA, 0x93, 0x4D, 0xB4, 0xFD, 0xFD, 0x4C,
-    0xF3, 0x2F, 0xED, 0x4B, 0x67, 0xCE, 0x98, 0xA4, 0x74, 0x4C, 0xEA, 0x53,
-    0xF1, 0x9F, 0x43, 0x93, 0xD8, 0xB4, 0xA2, 0x30, 0xFD, 0xE2, 0x41, 0xA4,
-    0x5D, 0xB4, 0xED, 0xF2, 0xB6, 0x6D, 0xDB, 0x10, 0x4F, 0x78, 0x4E, 0x21,
-    0x23, 0x4C, 0xA5, 0x10, 0xC0, 0xD2, 0x13, 0x22, 0x6F, 0x3A, 0xE9, 0x72,
-    0xF9, 0xE7, 0x7A, 0x58, 0xDE, 0xCC, 0xAC, 0x72, 0x04, 0x91, 0x02, 0x6B,
-    0xCC, 0xDF, 0x5F, 0x79, 0x54, 0xD8, 0x9A, 0x62, 0x28, 0xD4, 0x0F, 0x3A,
-    0x09, 0x4D, 0xD9, 0x0C, 0xD2, 0xA2, 0xA2, 0x6A, 0xF3, 0x6F, 0x7B, 0x7D,
-    0x97, 0xB6, 0xD5, 0xC3, 0xBB, 0x95, 0xCB, 0x63, 0xA1, 0x37, 0x7E, 0x31,
-    0x8B, 0x3F, 0x74, 0x7D, 0x35, 0x8B, 0x5E, 0x15, 0x4C, 0xD6, 0x88, 0xBC,
-    0x9D, 0x45, 0x6E, 0x41, 0x70, 0x44, 0xDE, 0xB9, 0x5C, 0x3C, 0x1D, 0x5B,
-    0x21, 0xFD, 0x16, 0x0C, 0x4E, 0x4C, 0x81, 0xFE, 0x66, 0x3B, 0x07, 0x6A,
-    0x9B, 0xD4, 0xA9, 0x31, 0xC9, 0xBB, 0x25, 0x8C, 0xA2, 0xA8, 0xB9, 0x5E,
-    0x20, 0xF2, 0x94, 0x44, 0xB3, 0x45, 0x63, 0xCB, 0x5D, 0x09, 0xB6, 0x7B,
-    0xD5, 0x58, 0xF7, 0x55, 0xA4, 0x96, 0x7F, 0x01, 0x75, 0x37, 0x1B, 0x8B,
-};
-const uint8_t g_enGB_Locale[] = {
-    0x78, 0x9C, 0x95, 0x56, 0xD1, 0x6E, 0xD3, 0x30, 0x14, 0x7D, 0x47, 0xE2,
-    0x1F, 0xA2, 0x88, 0x49, 0x20, 0x6D, 0x33, 0x3C, 0x6E, 0xEA, 0x2C, 0x75,
-    0xEB, 0xD6, 0x32, 0xC8, 0xA8, 0x48, 0xC5, 0xC4, 0x5E, 0x90, 0x9B, 0x78,
-    0x8D, 0x59, 0x62, 0x57, 0x4E, 0xCC, 0x94, 0xFC, 0x02, 0x9F, 0xC0, 0x23,
-    0xCF, 0x08, 0xF1, 0x01, 0xBC, 0xF0, 0x2F, 0x48, 0xFB, 0x0C, 0x6E, 0x1A,
-    0x27, 0x4B, 0x1C, 0xAF, 0x64, 0x79, 0x89, 0xEF, 0xB9, 0xE7, 0xDC, 0xDE,
-    0x7B, 0x9C, 0xB8, 0x19, 0xC5, 0x22, 0x20, 0x31, 0x75, 0x38, 0x49, 0xE8,
-    0x91, 0x4B, 0xF9, 0xA7, 0xE9, 0xB1, 0xEB, 0x84, 0x34, 0x0D, 0x8E, 0xDC,
-    0xBB, 0xAF, 0xBF, 0xEE, 0x7E, 0xFE, 0x78, 0x0E, 0xB7, 0xBF, 0xDF, 0x7E,
-    0xBF, 0x70, 0xF1, 0xA8, 0x24, 0xF2, 0x90, 0x48, 0x3F, 0x4F, 0x96, 0x22,
-    0x4E, 0xB5, 0x66, 0x25, 0xE9, 0x4A, 0x48, 0x46, 0x38, 0x30, 0x12, 0xC1,
-    0xB3, 0xE8, 0x02, 0xE0, 0x54, 0xAF, 0xF1, 0x39, 0xE1, 0x8A, 0xC8, 0x7C,
-    0x84, 0xAA, 0xF0, 0xE9, 0x13, 0x8D, 0x9F, 0xD1, 0xA5, 0xB4, 0x26, 0x3C,
-    0x22, 0x83, 0xA8, 0x87, 0x8E, 0xD7, 0x92, 0xC5, 0x16, 0x6E, 0x5F, 0x7F,
-    0xAE, 0x38, 0xB5, 0x80, 0x71, 0x9F, 0x39, 0x56, 0x2B, 0x95, 0x66, 0x3D,
-    0xD8, 0xA7, 0xEB, 0x8C, 0x26, 0x4B, 0x2A, 0x7B, 0x99, 0x77, 0x41, 0x26,
-    0x6C, 0xF8, 0x85, 0xF8, 0x62, 0x17, 0x4C, 0x68, 0x60, 0x26, 0x50, 0xCB,
-    0xA2, 0x9A, 0xB7, 0x89, 0x1C, 0xB2, 0x5C, 0xCA, 0x23, 0xF7, 0x95, 0xDB,
-    0x72, 0xCE, 0xE6, 0x9A, 0xCD, 0x30, 0x9B, 0x5D, 0x43, 0xCD, 0xB2, 0x79,
-    0x65, 0xB3, 0xCA, 0xE6, 0x93, 0xCD, 0x21, 0x9B, 0x3B, 0x36, 0x63, 0x1E,
-    0xF6, 0x24, 0x24, 0xB9, 0x7E, 0x84, 0x60, 0x85, 0x7D, 0x05, 0x8F, 0x1C,
-    0x74, 0x5E, 0xAE, 0xAB, 0x24, 0xF6, 0x44, 0x0F, 0x5A, 0x28, 0x9A, 0x9A,
-    0xD8, 0x25, 0x0D, 0x79, 0x1F, 0x5D, 0x44, 0x4A, 0xF6, 0xC0, 0x33, 0xC9,
-    0x4C, 0xC8, 0x27, 0x99, 0x92, 0x6D, 0x10, 0x35, 0x7D, 0xB5, 0x7A, 0x6C,
-    0xED, 0x9A, 0x6E, 0xD6, 0xEC, 0xD4, 0x6C, 0xD3, 0x6C, 0xD1, 0x6C, 0xCE,
-    0xEC, 0xCB, 0x6C, 0xCA, 0xDE, 0x4F, 0x42, 0x61, 0x02, 0x46, 0x93, 0xFA,
-    0xDD, 0xD3, 0x21, 0x1E, 0x7B, 0xE0, 0x6E, 0x1D, 0xB4, 0x78, 0x78, 0x6E,
-    0x24, 0x50, 0xB7, 0x02, 0x20, 0x54, 0x12, 0x5D, 0x0D, 0x56, 0xF8, 0xF8,
-    0x64, 0x84, 0xCA, 0x7B, 0x95, 0xC0, 0xE3, 0x49, 0x13, 0xA2, 0x86, 0x58,
-    0x06, 0xC6, 0x19, 0x51, 0x35, 0x9E, 0xD1, 0x39, 0xC9, 0x32, 0x2A, 0xF9,
-    0x66, 0x4F, 0x9B, 0x48, 0x1F, 0x20, 0xD7, 0x2A, 0x8E, 0x5D, 0x7C, 0x0A,
-    0xD7, 0xAE, 0x33, 0x71, 0x3C, 0xB8, 0x9C, 0x8F, 0x70, 0x95, 0x03, 0x36,
-    0x54, 0xA3, 0x8E, 0x56, 0xC6, 0x82, 0xAF, 0x5C, 0xFC, 0x38, 0x4D, 0x42,
-    0x43, 0x2D, 0x19, 0xAA, 0x48, 0x23, 0x21, 0x33, 0xD0, 0x4C, 0x90, 0xE7,
-    0x21, 0xAB, 0x06, 0x75, 0x46, 0x04, 0x20, 0x63, 0x49, 0x6B, 0xE4, 0x56,
-    0xD4, 0x19, 0x79, 0x36, 0x3B, 0xF4, 0xBC, 0x43, 0xDF, 0x77, 0xAE, 0x46,
-    0xA8, 0xC5, 0x31, 0x0A, 0x74, 0x66, 0x7D, 0x94, 0x64, 0x33, 0x6A, 0xAD,
-    0x18, 0xC0, 0xD7, 0x83, 0x6E, 0x14, 0x3D, 0x3A, 0xEA, 0xCC, 0xA4, 0x8D,
-    0x5A, 0x00, 0x56, 0xEF, 0xF4, 0x34, 0xF7, 0xC2, 0x9B, 0x59, 0x92, 0xFA,
-    0xA7, 0x93, 0xB3, 0xDB, 0x4B, 0x12, 0xBD, 0x29, 0xAE, 0x2A, 0x63, 0xDA,
-    0x24, 0xD0, 0x71, 0x55, 0x1E, 0x89, 0xF7, 0xEE, 0x74, 0x62, 0xDD, 0x09,
-    0x60, 0xF0, 0x38, 0x06, 0x2E, 0x2E, 0x76, 0x8B, 0xE2, 0x60, 0xBF, 0x28,
-    0x8A, 0x11, 0xEA, 0xF0, 0x7A, 0x85, 0xB4, 0x30, 0x50, 0x52, 0x52, 0x1E,
-    0xE4, 0x2E, 0x7E, 0x56, 0x49, 0x0F, 0x0E, 0x06, 0x2A, 0xD7, 0x54, 0x06,
-    0x94, 0x67, 0xFA, 0x27, 0x77, 0x2C, 0x2A, 0x64, 0x74, 0xDE, 0x14, 0xAA,
-    0x87, 0xEB, 0x84, 0xBA, 0x6C, 0x48, 0x03, 0x96, 0x10, 0xD8, 0xEC, 0xFD,
-    0x5A, 0x5F, 0xA5, 0x4D, 0x75, 0xF3, 0x67, 0x2A, 0xD4, 0x9A, 0x95, 0x3B,
-    0xBD, 0x3B, 0x88, 0xDF, 0x74, 0xBD, 0x33, 0x88, 0x9E, 0x30, 0xAE, 0x52,
-    0x17, 0xEF, 0x0D, 0x22, 0x17, 0x54, 0x0A, 0x17, 0xBF, 0xEC, 0x73, 0x51,
-    0x77, 0x6C, 0x40, 0x6A, 0xDB, 0x1B, 0x27, 0xBA, 0x40, 0xFD, 0x7C, 0x6D,
-    0x02, 0x17, 0xFF, 0xF9, 0x0E, 0xE7, 0x44, 0x87, 0xD0, 0xAF, 0xA1, 0x25,
-    0x2C, 0x15, 0xE5, 0xC2, 0xC5, 0xD3, 0xE3, 0xF9, 0x60, 0x51, 0xDB, 0xF3,
-    0xBE, 0x04, 0x99, 0xCD, 0x96, 0xEF, 0x42, 0xBE, 0xA6, 0xD7, 0x24, 0x28,
-    0x0F, 0xBB, 0x7A, 0xA9, 0x6B, 0x79, 0x39, 0x7C, 0xDA, 0x84, 0xCE, 0x1C,
-    0xAC, 0x40, 0x6D, 0x66, 0x9D, 0x66, 0x9C, 0x09, 0xFE, 0x60, 0xFA, 0x44,
-    0x28, 0xC9, 0xA8, 0x74, 0xFC, 0x2C, 0xB4, 0xE6, 0xC7, 0x21, 0x7C, 0x50,
-    0x38, 0x73, 0xF6, 0x1F, 0xC2, 0x0C, 0x3E, 0x96, 0xE8, 0xED, 0x16, 0xC2,
-    0x58, 0x92, 0x25, 0xBC, 0x2E, 0x0F, 0x13, 0x16, 0x11, 0x61, 0xD6, 0xF4,
-    0x1B, 0x51, 0xA8, 0x1B, 0xE2, 0x4C, 0x45, 0x16, 0xB1, 0xA0, 0x9C, 0x63,
-    0xEF, 0xC3, 0x6B, 0xC7, 0xDB, 0x46, 0x85, 0x91, 0x83, 0x48, 0xD4, 0xD4,
-    0xF7, 0x5B, 0x7E, 0x14, 0x98, 0xAB, 0x72, 0x32, 0xE7, 0xED, 0x16, 0x92,
-    0x2F, 0x06, 0x90, 0xBC, 0x5C, 0xF1, 0xD5, 0x67, 0xB1, 0xE1, 0xE9, 0xE6,
-    0xD0, 0xFD, 0x9E, 0x95, 0x51, 0xF5, 0x19, 0x0B, 0xCB, 0x7F, 0x8E, 0x69,
-    0xAC, 0xD0};
-const uint8_t g_zhCN_Locale[] = {
-    0x78, 0x9C, 0xED, 0x56, 0x41, 0x4F, 0xD4, 0x40, 0x14, 0xBE, 0x9B, 0xF8,
-    0x1F, 0x9A, 0x46, 0x52, 0x4D, 0x58, 0x46, 0x8F, 0x90, 0xD2, 0x64, 0x03,
-    0x08, 0x06, 0xBB, 0x21, 0x96, 0x68, 0xE0, 0x62, 0xBA, 0xED, 0xB0, 0x2D,
-    0x6C, 0x3B, 0x64, 0xB6, 0x0D, 0x6E, 0x4F, 0x18, 0x82, 0x82, 0xC2, 0x45,
-    0x89, 0x9A, 0x80, 0xE1, 0x64, 0x3C, 0x28, 0x9E, 0x8C, 0x01, 0x22, 0xF1,
-    0xCF, 0xB0, 0xCB, 0x91, 0xBF, 0xE0, 0x9B, 0xED, 0xB4, 0xB4, 0xDD, 0xD9,
-    0xB5, 0x3F, 0xC0, 0x3D, 0xCD, 0xFB, 0xDE, 0xF7, 0x7D, 0xF3, 0xDE, 0xEB,
-    0x74, 0xB6, 0x6A, 0x93, 0x58, 0x66, 0x13, 0x4B, 0xBE, 0xE9, 0xE1, 0x49,
-    0x39, 0x72, 0x9E, 0x4F, 0xD5, 0x64, 0xC9, 0xC6, 0x2D, 0x6B, 0x52, 0xBE,
-    0x3C, 0x3D, 0xE9, 0x7E, 0x78, 0x7D, 0xF7, 0xEA, 0xC7, 0xE6, 0xE5, 0xC5,
-    0xFB, 0xEB, 0xDF, 0x7B, 0x10, 0x77, 0x0E, 0x2F, 0xEE, 0xC9, 0x9A, 0xCA,
-    0x14, 0xBE, 0x6D, 0x52, 0xA3, 0xED, 0xD5, 0x49, 0xB3, 0xC5, 0xC5, 0x0D,
-    0x8A, 0x1B, 0x84, 0xBA, 0xA6, 0x0F, 0x0C, 0x8F, 0xF8, 0x81, 0x53, 0x03,
-    0xB8, 0xC5, 0xD7, 0xDA, 0xE5, 0xE9, 0x66, 0xF7, 0x68, 0x47, 0x45, 0x71,
-    0x74, 0xFB, 0x56, 0x02, 0x9F, 0xEF, 0x09, 0xE1, 0xD3, 0x5D, 0x11, 0xDC,
-    0x39, 0x3C, 0x14, 0x9B, 0x1C, 0x08, 0xD9, 0xDB, 0x27, 0x62, 0xEF, 0x2D,
-    0x31, 0xFB, 0x9B, 0x90, 0x7D, 0xF6, 0x59, 0xC8, 0xDE, 0x7F, 0x39, 0x00,
-    0x1E, 0xD0, 0x28, 0xCB, 0x14, 0x7B, 0x45, 0x99, 0x31, 0x25, 0xC4, 0x5E,
-    0x24, 0x99, 0xF5, 0x3A, 0x9D, 0x94, 0x1F, 0xC8, 0xFF, 0xA7, 0x57, 0x7A,
-    0x7A, 0xB6, 0xD9, 0xE6, 0x07, 0x0E, 0x56, 0x5A, 0xF7, 0xD3, 0x71, 0xF7,
-    0xE8, 0xB8, 0xFB, 0xF1, 0x8B, 0x8A, 0x58, 0x18, 0xE7, 0x39, 0x0A, 0x7B,
-    0x88, 0xD0, 0xF3, 0x3D, 0x21, 0x77, 0x57, 0x80, 0xC2, 0x24, 0x85, 0x0E,
-    0x07, 0x22, 0xEE, 0xF6, 0x49, 0x8A, 0xA2, 0xB4, 0xC8, 0x4C, 0xC1, 0x99,
-    0x87, 0xDD, 0x53, 0x15, 0x6A, 0x2E, 0x56, 0x5B, 0xAC, 0xB3, 0x58, 0x61,
-    0xB1, 0xB6, 0x62, 0x55, 0x03, 0xEB, 0xF1, 0x30, 0x75, 0x6D, 0x17, 0x7B,
-    0xC9, 0x6B, 0xCB, 0x43, 0xD8, 0xE0, 0x4D, 0x67, 0x9F, 0x0D, 0x3E, 0x01,
-    0x32, 0x5C, 0x48, 0xBE, 0xED, 0x4B, 0xA2, 0xBC, 0x13, 0x20, 0x98, 0x9A,
-    0xDC, 0x15, 0x56, 0x50, 0xC1, 0xF7, 0xCE, 0xF6, 0x56, 0x67, 0x77, 0x5F,
-    0x45, 0x2C, 0x8C, 0xF3, 0x1C, 0x4D, 0x21, 0x94, 0x6A, 0x58, 0x50, 0xB8,
-    0x71, 0xE2, 0x5E, 0x02, 0xBC, 0x60, 0x06, 0x01, 0xA6, 0x7E, 0xEF, 0x99,
-    0xA7, 0x11, 0xBF, 0x8E, 0x56, 0xC2, 0x66, 0x53, 0xD6, 0x96, 0xE0, 0xA7,
-    0x74, 0xCE, 0x7E, 0x2A, 0xBA, 0x02, 0xA7, 0x47, 0x99, 0x56, 0x60, 0xBC,
-    0xCA, 0x0C, 0xFC, 0x58, 0xEF, 0xA9, 0xA4, 0xE0, 0xC7, 0x1D, 0x9A, 0xC4,
-    0x6F, 0x0C, 0x70, 0x28, 0xA1, 0xF6, 0xB0, 0x1D, 0x8B, 0x2B, 0x7A, 0x65,
-    0xBA, 0x04, 0xBF, 0xE5, 0x10, 0x1A, 0x30, 0x85, 0x90, 0x8F, 0x72, 0xED,
-    0x02, 0x10, 0xB8, 0x5E, 0xA6, 0xFD, 0x4C, 0x94, 0x6B, 0xBF, 0xEA, 0x38,
-    0x50, 0xEF, 0x2F, 0x45, 0xD7, 0x95, 0xCE, 0xCE, 0x2B, 0xC5, 0x30, 0x94,
-    0xAB, 0xAF, 0xEF, 0x14, 0x69, 0x59, 0x45, 0x19, 0x45, 0xC1, 0x2E, 0xD7,
-    0xBD, 0xD8, 0xA0, 0x84, 0xBC, 0xD7, 0x3E, 0xA8, 0x27, 0x74, 0x7D, 0xC2,
-    0x30, 0x4A, 0x08, 0x78, 0xFF, 0x55, 0xA6, 0xE8, 0xA3, 0xA3, 0x5C, 0xBB,
-    0x7C, 0x7E, 0x8B, 0x80, 0x25, 0x07, 0x62, 0xD6, 0xF4, 0x57, 0xD7, 0xE6,
-    0xBC, 0x96, 0x31, 0x33, 0xFD, 0x70, 0xE3, 0xD9, 0x0B, 0x67, 0x3E, 0x5A,
-    0x8E, 0x67, 0x96, 0x25, 0x81, 0xCE, 0x0F, 0xBD, 0x3A, 0xA6, 0x37, 0x83,
-    0xCB, 0xC5, 0xBC, 0x12, 0xC0, 0xE0, 0x00, 0x5B, 0xB2, 0x16, 0x8D, 0x46,
-    0xD1, 0xF8, 0x58, 0x14, 0x45, 0x2A, 0xCA, 0xF1, 0xFA, 0x8C, 0xB8, 0xD0,
-    0x0A, 0x29, 0xC5, 0xBE, 0xD5, 0x96, 0xB5, 0x3B, 0xB1, 0x74, 0x7C, 0xBC,
-    0xA4, 0x72, 0x1D, 0x53, 0x0B, 0xFB, 0x01, 0xDF, 0x72, 0x44, 0xA0, 0x42,
-    0x85, 0xCA, 0x53, 0xA3, 0xA4, 0xB9, 0x5C, 0xC8, 0x6D, 0x6D, 0x6C, 0xB9,
-    0x9E, 0x09, 0xE7, 0x60, 0x2C, 0xD1, 0xC7, 0xE9, 0xA2, 0x3A, 0xFD, 0x07,
-    0x27, 0xE1, 0xBA, 0xCB, 0x1E, 0xFB, 0x68, 0x29, 0x7E, 0x5A, 0xF5, 0x48,
-    0x29, 0xBA, 0xE7, 0xFA, 0x61, 0x4B, 0xD6, 0x2A, 0xA5, 0xC8, 0x11, 0xA6,
-    0x44, 0xD6, 0xEE, 0xF7, 0x73, 0x51, 0xBE, 0x6D, 0x40, 0x92, 0xB1, 0xA7,
-    0x93, 0xC8, 0x03, 0xC9, 0xF9, 0xEA, 0x05, 0xB2, 0x76, 0xFD, 0x07, 0xEE,
-    0xD7, 0x3C, 0xA3, 0xDF, 0x84, 0x6B, 0xDC, 0x16, 0x61, 0x0B, 0x59, 0x9B,
-    0xAA, 0x2D, 0x95, 0x16, 0x65, 0x87, 0xDE, 0x2F, 0x41, 0xC5, 0x6A, 0xD9,
-    0xCB, 0xD0, 0x5E, 0xC7, 0x2B, 0xA6, 0xC5, 0xEE, 0xC7, 0x64, 0xC9, 0xBD,
-    0xAA, 0x36, 0xA9, 0x63, 0xC9, 0x80, 0x57, 0x51, 0x32, 0x02, 0x5B, 0x7A,
-    0x2C, 0xA3, 0x2C, 0x9F, 0x93, 0xF4, 0x36, 0x7C, 0x75, 0xD9, 0xD2, 0x02,
-    0x0C, 0x4C, 0x98, 0x76, 0x7D, 0x97, 0xF8, 0x03, 0xD3, 0x53, 0x24, 0xA4,
-    0x2E, 0xA6, 0xCC, 0x5F, 0x98, 0x8F, 0x4B, 0x58, 0x70, 0xFF, 0x41, 0x98,
-    0xC3, 0x75, 0x8A, 0x37, 0x86, 0x10, 0xAA, 0xD4, 0xAC, 0xC3, 0x4B, 0x35,
-    0x98, 0xB0, 0xE8, 0x98, 0xAE, 0x30, 0x3D, 0x4F, 0xA2, 0x70, 0xCD, 0x94,
-    0x66, 0x49, 0xE0, 0xB8, 0x16, 0xEB, 0xA3, 0xF2, 0xF4, 0x91, 0xA4, 0x0F,
-    0xA3, 0x42, 0xCB, 0x96, 0x43, 0x12, 0xEA, 0x93, 0x21, 0x9B, 0x02, 0x73,
-    0xD8, 0x68, 0x39, 0xA9, 0x1D, 0xFA, 0x8D, 0x55, 0xD2, 0xE3, 0xF1, 0x7D,
-    0xD1, 0xCD, 0x33, 0x63, 0x51, 0xFC, 0x15, 0x0D, 0xCB, 0xBF, 0xC0, 0xE4,
-    0x3D, 0x40};
-const uint8_t g_zhTW_Locale[] = {
-    0x78, 0x9C, 0xED, 0x57, 0xCD, 0x4F, 0xD4, 0x40, 0x14, 0x3F, 0x63, 0xE2,
-    0xFF, 0x30, 0x69, 0x20, 0xD5, 0x04, 0xA8, 0x1E, 0x21, 0xA5, 0xC9, 0xC6,
-    0x45, 0x30, 0x58, 0x42, 0xEC, 0x46, 0x22, 0x17, 0x33, 0xDB, 0x0E, 0xDB,
-    0xC2, 0xB6, 0x43, 0x66, 0xDB, 0xC0, 0xF6, 0x24, 0x12, 0x14, 0x14, 0x62,
-    0xA2, 0xC4, 0x8F, 0x80, 0xE1, 0x64, 0x3C, 0x28, 0x89, 0x07, 0x0F, 0x2C,
-    0x51, 0xFF, 0x1A, 0x76, 0x39, 0xFA, 0x2F, 0x38, 0xD3, 0x2F, 0xFA, 0xB1,
-    0xB3, 0xD4, 0xC4, 0xA3, 0x7B, 0x9A, 0xF7, 0xDE, 0xEF, 0xF7, 0xE6, 0xBD,
-    0xDF, 0xBC, 0x7D, 0xD9, 0x95, 0x9B, 0x58, 0x87, 0x4D, 0x04, 0x1C, 0x68,
-    0xA3, 0x29, 0xC1, 0x37, 0x1F, 0xD7, 0x16, 0x05, 0x60, 0xA0, 0x96, 0x3E,
-    0x25, 0x9C, 0x9F, 0x9E, 0xF4, 0xDE, 0x3E, 0xBF, 0x71, 0xD1, 0xD9, 0x3C,
-    0xFF, 0xF9, 0xE6, 0xF7, 0x8F, 0xBD, 0xEE, 0xAB, 0x6F, 0xBD, 0xCE, 0xAF,
-    0x9B, 0x82, 0x72, 0xFD, 0x1A, 0x00, 0x32, 0x63, 0x39, 0x06, 0x24, 0x5A,
-    0xDB, 0xAE, 0xE3, 0x66, 0x2B, 0x4A, 0xD0, 0x20, 0xA8, 0x81, 0x89, 0x05,
-    0x1D, 0x86, 0x1A, 0x02, 0xB2, 0x8D, 0x1D, 0xD7, 0x9C, 0xA7, 0xA1, 0x16,
-    0xB3, 0x87, 0x42, 0x5B, 0x39, 0x3F, 0x7D, 0xD2, 0x3B, 0xDA, 0x91, 0xA5,
-    0xD0, 0x4A, 0x07, 0xCE, 0xF6, 0x38, 0x81, 0xD3, 0xDD, 0xFE, 0x81, 0xEE,
-    0xE1, 0x21, 0x2F, 0xD5, 0x01, 0x87, 0xB1, 0x7D, 0xC2, 0xBB, 0x63, 0x8B,
-    0xC7, 0xF8, 0xC2, 0x61, 0x74, 0x3E, 0x72, 0x18, 0xFB, 0x9B, 0xDC, 0x00,
-    0xB7, 0x79, 0x16, 0xCB, 0xF7, 0x0F, 0xA2, 0x73, 0x22, 0x61, 0x5A, 0x52,
-    0x00, 0xEB, 0x75, 0x32, 0x25, 0xDC, 0x16, 0xFE, 0x6B, 0xFB, 0x8F, 0xB4,
-    0x35, 0x60, 0x3B, 0x35, 0xAC, 0xD4, 0x52, 0x7A, 0xEF, 0x8F, 0x7B, 0x47,
-    0xC7, 0xBD, 0x77, 0x9F, 0x64, 0x89, 0x99, 0x39, 0x3F, 0xBD, 0xAF, 0xBF,
-    0xFF, 0x6C, 0x8F, 0x83, 0xDF, 0xED, 0xEB, 0xA7, 0x4A, 0x73, 0xF2, 0x1C,
-    0xF4, 0xC7, 0x6F, 0x9F, 0x24, 0x7E, 0x10, 0x9C, 0xFA, 0x34, 0x91, 0x1B,
-    0x8F, 0x80, 0x5D, 0xE8, 0xA3, 0xD8, 0x41, 0xB1, 0xF6, 0x62, 0xD5, 0xC5,
-    0x7A, 0x8B, 0x95, 0x0E, 0xAC, 0xD1, 0x46, 0xC4, 0x32, 0x2C, 0x64, 0xA7,
-    0x57, 0x43, 0xE4, 0xA2, 0xD7, 0xBD, 0xE8, 0xEE, 0xB3, 0x87, 0x8A, 0x1D,
-    0xF9, 0xF0, 0xCB, 0x42, 0x18, 0x5C, 0x9A, 0xA9, 0x4B, 0x10, 0x81, 0xA9,
-    0xFC, 0xD4, 0xA2, 0x35, 0x7D, 0xED, 0x6E, 0x6F, 0x75, 0x77, 0xF7, 0x65,
-    0x89, 0x99, 0x39, 0x7F, 0xE2, 0x04, 0xC1, 0x29, 0xE6, 0xD2, 0x65, 0x27,
-    0xE5, 0xB6, 0x5D, 0xE8, 0x35, 0xA0, 0x8B, 0x16, 0xA0, 0xEB, 0x22, 0xE2,
-    0x24, 0xD2, 0x27, 0x9E, 0x68, 0x21, 0x2E, 0x7B, 0xCD, 0xA6, 0xA0, 0x3C,
-    0xA2, 0x1F, 0xB1, 0xDB, 0xF9, 0x2E, 0xAA, 0x22, 0x9D, 0x41, 0xB1, 0x2A,
-    0xD2, 0x87, 0x10, 0xA7, 0xE9, 0x87, 0xE9, 0x92, 0x50, 0x78, 0x39, 0x9A,
-    0xD8, 0x69, 0x70, 0x72, 0x94, 0xE2, 0xDB, 0xC8, 0x08, 0xE9, 0x92, 0x2A,
-    0x55, 0x4B, 0x31, 0x5A, 0x26, 0x26, 0x2E, 0x9F, 0x03, 0x40, 0xC6, 0x13,
-    0xC9, 0xE1, 0x5A, 0x76, 0x4E, 0x8E, 0x94, 0x27, 0x23, 0x47, 0xC5, 0x34,
-    0xC5, 0xDE, 0x87, 0xA7, 0xA2, 0xAA, 0x8A, 0xDD, 0x9D, 0x67, 0xA2, 0xA6,
-    0x89, 0x17, 0x9F, 0x5F, 0x8B, 0x60, 0x49, 0x96, 0x52, 0x0C, 0x5E, 0x8A,
-    0x50, 0x8D, 0xFE, 0x29, 0x4A, 0x25, 0x08, 0xE4, 0xA8, 0x00, 0x73, 0x52,
-    0x55, 0x27, 0x35, 0xAD, 0x14, 0x25, 0xD2, 0x23, 0x24, 0xE5, 0x19, 0x4C,
-    0x8D, 0x5C, 0xEF, 0xD1, 0x70, 0xD4, 0xA8, 0x37, 0x9E, 0x98, 0x19, 0xE8,
-    0xAC, 0xAC, 0xCE, 0xDA, 0x2D, 0x6D, 0xBA, 0x7A, 0x77, 0x7D, 0x71, 0xC3,
-    0x9C, 0xF3, 0x97, 0x42, 0x11, 0xD3, 0xA0, 0x80, 0xE9, 0x78, 0x76, 0x1D,
-    0x91, 0xAC, 0x92, 0x19, 0x5F, 0x54, 0x14, 0xF5, 0xD1, 0x99, 0xD7, 0x05,
-    0xC5, 0x1F, 0xF5, 0xFD, 0x89, 0x71, 0xDF, 0xF7, 0x65, 0x29, 0x83, 0xE3,
-    0x53, 0x75, 0x8F, 0x10, 0xE4, 0xE8, 0x6D, 0x41, 0x19, 0x0E, 0xC9, 0x13,
-    0x13, 0xA5, 0xB9, 0x6B, 0x88, 0xE8, 0xC8, 0x71, 0xA3, 0x6B, 0x47, 0x8A,
-    0x3C, 0xA6, 0x47, 0xA1, 0x87, 0xA4, 0xAF, 0xCB, 0x56, 0x87, 0xB2, 0xAE,
-    0x28, 0xBD, 0x81, 0x74, 0xCB, 0x86, 0x74, 0x48, 0xC6, 0xE3, 0x2C, 0x61,
-    0x98, 0x4B, 0x68, 0x10, 0xEC, 0xAD, 0x59, 0x6C, 0x26, 0x46, 0x4B, 0x32,
-    0x92, 0x0E, 0x46, 0x4A, 0x12, 0x6C, 0xCB, 0xF1, 0x5A, 0x82, 0x32, 0x56,
-    0x12, 0xEE, 0x23, 0x82, 0x05, 0xE5, 0x56, 0x01, 0x7D, 0x29, 0x4C, 0xE6,
-    0xBD, 0xE3, 0xC7, 0xC8, 0x28, 0x93, 0x75, 0xC6, 0x63, 0x18, 0x18, 0x82,
-    0x32, 0x5F, 0x1B, 0xA6, 0x2B, 0x29, 0x83, 0x18, 0xC0, 0xB2, 0x5A, 0x98,
-    0x1D, 0x04, 0xA5, 0xB6, 0x58, 0xFD, 0x0B, 0x5A, 0xFA, 0x21, 0x0A, 0xA4,
-    0x60, 0x27, 0x16, 0xEA, 0x66, 0x4B, 0xA0, 0xBD, 0x86, 0x96, 0xA1, 0x1E,
-    0xAF, 0xE0, 0xD8, 0x8C, 0x72, 0x56, 0x0C, 0x5C, 0x47, 0x40, 0xA5, 0xAF,
-    0x05, 0x34, 0xD7, 0x00, 0xF7, 0x05, 0xA9, 0x2F, 0x4C, 0x6D, 0xD3, 0x9F,
-    0x90, 0x06, 0x58, 0xA0, 0x32, 0x72, 0x00, 0x96, 0x63, 0x61, 0x67, 0x00,
-    0xE0, 0x0E, 0xF6, 0x88, 0x85, 0x08, 0xBB, 0x85, 0x83, 0x08, 0x4B, 0x59,
-    0xB0, 0xAE, 0x84, 0xCC, 0xA2, 0x3A, 0x41, 0xEB, 0x03, 0x21, 0x15, 0x02,
-    0xEB, 0xF4, 0x8B, 0x38, 0x08, 0x52, 0x33, 0xA1, 0xC5, 0x01, 0xCC, 0x61,
-    0xDF, 0x5B, 0x85, 0x60, 0x06, 0xBB, 0xA6, 0xA5, 0xB3, 0x9E, 0xC6, 0x1E,
-    0xDE, 0x03, 0xEA, 0x60, 0x30, 0x15, 0x40, 0x37, 0x71, 0x0C, 0x7E, 0x30,
-    0xF0, 0x6A, 0x0D, 0x5F, 0x21, 0x77, 0xF4, 0x2A, 0x6D, 0xCF, 0x69, 0xAC,
-    0xE0, 0x00, 0x19, 0xDE, 0x1E, 0x2C, 0xB6, 0xD4, 0x7B, 0xCA, 0x52, 0xF8,
-    0x67, 0x41, 0xF9, 0x03, 0x11, 0xC2, 0x4A, 0xC9};
-const uint8_t g_zhHK_Locale[] = {
-    0x78, 0x9C, 0xA5, 0x57, 0x4D, 0x4F, 0x13, 0x41, 0x18, 0x3E, 0x63, 0xE2,
-    0x7F, 0x98, 0x6C, 0x20, 0x0B, 0x09, 0x50, 0x8A, 0x9F, 0x25, 0xCB, 0x26,
-    0x44, 0x90, 0x9A, 0x5A, 0x43, 0x2C, 0xD1, 0xC8, 0xC5, 0x6C, 0x77, 0x87,
-    0xEE, 0x42, 0x77, 0x87, 0x4C, 0xB7, 0xC1, 0x6E, 0x3C, 0x88, 0x04, 0xA5,
-    0x5A, 0x2E, 0x4A, 0x54, 0x02, 0x86, 0x78, 0x50, 0x0F, 0x48, 0xBC, 0x78,
-    0x68, 0x89, 0xC6, 0x3F, 0x43, 0x8B, 0x9E, 0xFC, 0x0B, 0xCE, 0xEC, 0x17,
-    0xFB, 0x35, 0x6D, 0x8D, 0x3D, 0xCD, 0xFB, 0xBC, 0xCF, 0xF3, 0xCE, 0xFB,
-    0x3E, 0x33, 0x3B, 0x01, 0xA1, 0x8C, 0x64, 0xA9, 0x0C, 0x81, 0x21, 0xE9,
-    0x70, 0x9A, 0xB3, 0xD4, 0x87, 0xD9, 0x1C, 0x07, 0x14, 0x58, 0x91, 0xA7,
-    0xB9, 0xD3, 0xE6, 0x71, 0xE7, 0xCD, 0xF3, 0xE1, 0xB3, 0xD6, 0xC6, 0xE9,
-    0x8F, 0xD7, 0x7F, 0xBE, 0x37, 0x7E, 0x7F, 0xDA, 0xEB, 0x34, 0xBF, 0x9E,
-    0xD5, 0x5B, 0xED, 0xED, 0xA3, 0x5F, 0x1F, 0x1A, 0x9D, 0xDD, 0x9F, 0xED,
-    0xC6, 0xC9, 0x08, 0x27, 0x5E, 0xBC, 0x00, 0x80, 0x40, 0x8B, 0x18, 0x8A,
-    0x84, 0x0B, 0x35, 0xBD, 0x88, 0xCA, 0x15, 0xB7, 0x5E, 0x09, 0xC3, 0x12,
-    0xC2, 0x9A, 0x64, 0x50, 0xD6, 0x00, 0x10, 0x74, 0x64, 0x98, 0xEA, 0x1D,
-    0x92, 0xAA, 0xD0, 0x78, 0xC0, 0x89, 0xC5, 0xD3, 0xE6, 0x93, 0xCE, 0xC1,
-    0xB6, 0x90, 0x72, 0xA2, 0x60, 0xE2, 0xA4, 0xC1, 0x48, 0x34, 0xEB, 0xC9,
-    0x89, 0xF6, 0xFE, 0x3E, 0xAB, 0xD4, 0x2E, 0x43, 0xB1, 0x75, 0xCC, 0xDA,
-    0x63, 0x93, 0xA5, 0x38, 0x62, 0x28, 0x5A, 0xEF, 0x19, 0x8A, 0x9D, 0x0D,
-    0x66, 0x82, 0x39, 0x3C, 0xCD, 0x45, 0xE7, 0x07, 0xEE, 0xDA, 0xB7, 0x30,
-    0x68, 0x29, 0x90, 0x8A, 0x45, 0x3C, 0xCD, 0xA5, 0xB9, 0x60, 0x95, 0x74,
-    0x72, 0xF1, 0xC9, 0x64, 0xF8, 0x52, 0x32, 0x7C, 0x39, 0x19, 0xBE, 0x92,
-    0x0C, 0x5F, 0x4D, 0x86, 0xAF, 0x25, 0xC3, 0xD7, 0x93, 0xE1, 0x4C, 0x32,
-    0x9C, 0x9E, 0x60, 0xE0, 0x8C, 0x39, 0xD3, 0x93, 0x3D, 0x0D, 0x54, 0xA4,
-    0x5A, 0xE0, 0x46, 0x92, 0x48, 0xEC, 0xBC, 0x3B, 0xEC, 0x1C, 0x1C, 0x76,
-    0xDE, 0x7E, 0x14, 0x52, 0x34, 0x8C, 0xE0, 0xE4, 0xC0, 0x92, 0xF1, 0x93,
-    0x06, 0x83, 0x5F, 0x4F, 0xC4, 0xC9, 0x55, 0x65, 0xD4, 0xD9, 0x4D, 0xE6,
-    0x6F, 0x1D, 0xFB, 0x38, 0xB0, 0x57, 0x09, 0x43, 0x44, 0xEE, 0x80, 0xAD,
-    0x8E, 0xCD, 0x11, 0x9F, 0x20, 0xDE, 0x7B, 0xBC, 0xEB, 0x78, 0xBF, 0xF1,
-    0x4E, 0xBB, 0xF6, 0xA8, 0x43, 0xAC, 0x29, 0x1A, 0xD4, 0x83, 0xDF, 0xBF,
-    0x0B, 0x91, 0xED, 0x5E, 0xB4, 0x77, 0xE8, 0x41, 0x79, 0x40, 0x34, 0xFD,
-    0x32, 0x96, 0x06, 0xE7, 0x61, 0x60, 0x13, 0x88, 0xA5, 0x40, 0x7D, 0x12,
-    0x91, 0x9E, 0xBE, 0xB4, 0xB7, 0x36, 0xDB, 0xF5, 0x1D, 0x21, 0x45, 0xC3,
-    0x08, 0xEE, 0x83, 0xC0, 0x5E, 0x79, 0x5A, 0xF2, 0xA2, 0xA5, 0x22, 0x4F,
-    0x9A, 0x83, 0x2A, 0x92, 0x09, 0x17, 0x24, 0xD3, 0x84, 0xD8, 0xF0, 0xAD,
-    0xF7, 0x11, 0xF7, 0xD5, 0x5B, 0xAE, 0x96, 0xCB, 0x9C, 0xF8, 0x80, 0xFC,
-    0xF8, 0x76, 0xEB, 0x1B, 0x9F, 0xE7, 0xC9, 0x1D, 0xE4, 0x67, 0x79, 0x72,
-    0x10, 0x3C, 0x98, 0x23, 0x3F, 0x6A, 0x8C, 0xAF, 0x61, 0x15, 0x29, 0x23,
-    0xA3, 0xC4, 0x28, 0xD2, 0x97, 0x5E, 0x87, 0xCA, 0xFF, 0xC8, 0x2B, 0x2A,
-    0xC2, 0x26, 0x2D, 0xD0, 0x53, 0x0E, 0x40, 0x08, 0x71, 0x7D, 0x32, 0x35,
-    0x3D, 0xE2, 0x53, 0x00, 0x09, 0xF9, 0x34, 0xA3, 0xAA, 0x7C, 0x67, 0xEF,
-    0x29, 0x9F, 0xCF, 0xF3, 0xED, 0xED, 0x67, 0x7C, 0xA1, 0xC0, 0x9F, 0x7D,
-    0x7E, 0xC5, 0x83, 0x25, 0x21, 0x15, 0x50, 0xB0, 0x4A, 0x38, 0x2E, 0x25,
-    0x97, 0xE8, 0xAB, 0x80, 0x6D, 0x13, 0xD1, 0x4F, 0xE5, 0xF3, 0x53, 0x85,
-    0x42, 0x5F, 0x12, 0xD7, 0x9A, 0x19, 0xAA, 0x89, 0x0A, 0xA8, 0x19, 0x91,
-    0xD1, 0xDD, 0x4B, 0xB3, 0x48, 0x50, 0xEF, 0x26, 0xCD, 0x4B, 0xC6, 0xCA,
-    0x6A, 0x56, 0xAF, 0x14, 0xE6, 0x66, 0x6F, 0xAE, 0xDF, 0x7F, 0xA4, 0xE6,
-    0xAC, 0x25, 0xC7, 0xC3, 0x20, 0xC9, 0x56, 0x1A, 0x55, 0xBD, 0x08, 0x71,
-    0xD8, 0xC8, 0x10, 0xE6, 0xF6, 0x44, 0x30, 0xF2, 0x2D, 0xC8, 0x9C, 0x68,
-    0x8D, 0x5A, 0x56, 0x66, 0xDC, 0xB2, 0x2C, 0x21, 0x15, 0xE2, 0xB1, 0xA5,
-    0x72, 0x15, 0x63, 0x68, 0xC8, 0x35, 0x4E, 0x1C, 0x74, 0xC4, 0x99, 0xCC,
-    0xE3, 0x61, 0x7F, 0x39, 0xD2, 0x77, 0x9D, 0x35, 0x88, 0x65, 0x68, 0x98,
-    0x6E, 0x0B, 0x43, 0x71, 0x1D, 0xF5, 0x26, 0x36, 0x8F, 0x3F, 0xE3, 0xF9,
-    0xD8, 0x03, 0x61, 0xC8, 0x2D, 0xAF, 0x40, 0x59, 0xD3, 0x25, 0x72, 0x5F,
-    0xC6, 0xBD, 0x2A, 0x4E, 0x9A, 0x29, 0x28, 0x61, 0x54, 0x5D, 0xD3, 0xE8,
-    0xF5, 0x18, 0xED, 0x53, 0xE1, 0x4F, 0x30, 0xD4, 0xA7, 0x40, 0xD7, 0x8C,
-    0x6A, 0x85, 0x13, 0xC7, 0xFA, 0xA4, 0x5B, 0x10, 0x23, 0x4E, 0x9C, 0x88,
-    0xB1, 0xCF, 0x8D, 0x09, 0x9D, 0xBD, 0x77, 0x30, 0x21, 0x67, 0xC2, 0xA0,
-    0x77, 0x23, 0xED, 0x80, 0x13, 0xB3, 0xB9, 0x41, 0xF2, 0x6C, 0x85, 0x18,
-    0x5D, 0x54, 0x5A, 0x05, 0xD1, 0x05, 0x95, 0xCD, 0xFE, 0x83, 0x2C, 0x78,
-    0x10, 0x31, 0x91, 0xFD, 0x6E, 0xC6, 0xFA, 0xA6, 0xEF, 0x41, 0x6D, 0x0D,
-    0x2E, 0x4B, 0xB2, 0xF7, 0x4C, 0x7B, 0xA1, 0x5B, 0x73, 0x46, 0x41, 0x45,
-    0x08, 0xF2, 0xE4, 0xB4, 0x40, 0xC1, 0x54, 0xC0, 0x6D, 0x2E, 0x95, 0x48,
-    0xCB, 0xD7, 0xC8, 0xDF, 0x92, 0x0A, 0x58, 0x20, 0x36, 0x32, 0x08, 0x9A,
-    0xA1, 0x21, 0xA3, 0x0B, 0xE1, 0x06, 0xAA, 0x62, 0x0D, 0x62, 0xBA, 0x0B,
-    0x83, 0xE1, 0xB4, 0xB2, 0xA0, 0xF5, 0xA4, 0x64, 0x61, 0x11, 0xC3, 0xF5,
-    0xAE, 0x94, 0x19, 0x2C, 0x15, 0xC9, 0x47, 0xD9, 0x8D, 0xB2, 0xA8, 0x4A,
-    0x1A, 0x83, 0x90, 0x43, 0x56, 0x75, 0x55, 0x02, 0xF3, 0xC8, 0x54, 0x35,
-    0x99, 0xCE, 0x34, 0x76, 0xEF, 0x16, 0xC8, 0x77, 0x27, 0x13, 0x03, 0x64,
-    0x15, 0x79, 0xE4, 0xBB, 0x5D, 0xB7, 0x2E, 0xA0, 0x1E, 0x76, 0xBB, 0xA7,
-    0x52, 0xAB, 0x1A, 0xA5, 0x15, 0x64, 0x33, 0x9D, 0xDD, 0xED, 0x47, 0x2E,
-    0x70, 0x9E, 0x42, 0xCA, 0xF9, 0x27, 0x42, 0xFC, 0x0B, 0xD9, 0x0E, 0x4B,
-    0xED};
-const uint8_t g_jaJP_Locale[] = {
-    0x78, 0x9C, 0xED, 0x56, 0xCB, 0x6E, 0xD3, 0x40, 0x14, 0x5D, 0x17, 0x89,
-    0x7F, 0x18, 0x59, 0x20, 0x83, 0xD4, 0xD6, 0x0D, 0xEF, 0x56, 0xAE, 0xA5,
-    0x8A, 0x96, 0x86, 0x16, 0xA3, 0x08, 0x57, 0xA0, 0x76, 0x83, 0x26, 0xF6,
-    0x34, 0x99, 0x36, 0x9E, 0xA9, 0x26, 0xB6, 0x4A, 0xBC, 0xE2, 0x21, 0x20,
-    0x48, 0x74, 0x01, 0x1B, 0x04, 0x44, 0x62, 0x55, 0x40, 0x02, 0x04, 0x8B,
-    0x6E, 0xD8, 0xD0, 0xAF, 0x49, 0x5A, 0x56, 0xFC, 0x02, 0x33, 0x7E, 0xC5,
-    0x8E, 0xED, 0xE0, 0xEE, 0xF1, 0x22, 0x99, 0x7B, 0x7C, 0xCE, 0xF5, 0xBD,
-    0xE7, 0x8E, 0x47, 0x56, 0x5B, 0xD4, 0x84, 0x2D, 0x04, 0x08, 0xB4, 0xD1,
-    0xBC, 0xB4, 0x05, 0xEF, 0xAF, 0xD4, 0x24, 0x60, 0xA1, 0xB6, 0x39, 0x2F,
-    0x0D, 0xDE, 0xEC, 0x1F, 0x7F, 0xFF, 0x76, 0x8E, 0xFF, 0x0D, 0x7A, 0x5F,
-    0xCF, 0x4B, 0xDA, 0xE9, 0x53, 0x00, 0xA8, 0x82, 0x4C, 0x2C, 0xC8, 0x8C,
-    0x8E, 0x5D, 0xA7, 0xAD, 0x76, 0xA8, 0x6B, 0x30, 0xD4, 0xA0, 0x0C, 0x43,
-    0x22, 0x58, 0x13, 0x40, 0xB5, 0x29, 0x71, 0x9A, 0xB7, 0xF9, 0xAD, 0xB6,
-    0x88, 0x27, 0x82, 0x58, 0xAB, 0x0C, 0x7A, 0x5D, 0x55, 0x09, 0xD6, 0x09,
-    0xF8, 0x42, 0x3E, 0x7C, 0x31, 0x1F, 0xBE, 0x94, 0x0F, 0x5F, 0xCE, 0x87,
-    0xAF, 0xE4, 0xC3, 0x57, 0xF3, 0xE1, 0x6B, 0xF9, 0xF0, 0x6C, 0x3E, 0x5C,
-    0x99, 0x29, 0xC0, 0x0B, 0xFA, 0xAC, 0x8C, 0x34, 0x0A, 0xC2, 0x75, 0xEC,
-    0x53, 0xD2, 0x37, 0x00, 0xEB, 0x75, 0x36, 0x2F, 0x55, 0xA4, 0xFF, 0x06,
-    0x9E, 0xC4, 0x40, 0x0B, 0x76, 0x12, 0xDB, 0x8E, 0x47, 0x9A, 0xD8, 0xBE,
-    0xEF, 0x7B, 0xFC, 0x57, 0x55, 0x44, 0x38, 0xC4, 0x7B, 0xDD, 0x5C, 0xFC,
-    0xE8, 0xD1, 0x97, 0x7C, 0xFE, 0x8F, 0x83, 0x82, 0x3C, 0x9F, 0x73, 0xF1,
-    0xDF, 0xCF, 0x5F, 0xE5, 0xE2, 0xFD, 0xDE, 0x87, 0x11, 0x1C, 0xF8, 0xAB,
-    0x9C, 0x26, 0x46, 0xF6, 0x40, 0xD8, 0x4D, 0xB6, 0x8F, 0x6C, 0x07, 0xD9,
-    0xDA, 0xB3, 0x55, 0x67, 0xEB, 0xCD, 0x56, 0x5A, 0x5C, 0xA3, 0x8D, 0x18,
-    0xB6, 0x30, 0xB2, 0x93, 0x2F, 0x79, 0x08, 0x69, 0xFD, 0xBD, 0x6E, 0xFF,
-    0xC5, 0x1E, 0x1F, 0x4E, 0x04, 0x64, 0x6F, 0xFF, 0x7A, 0x99, 0xBE, 0x0D,
-    0x86, 0x61, 0xE2, 0x21, 0x88, 0xC1, 0x44, 0x7E, 0x1E, 0x69, 0x47, 0x07,
-    0x0F, 0xFB, 0x4F, 0x9F, 0xF8, 0xD9, 0x45, 0x18, 0xE3, 0xC7, 0xFB, 0x87,
-    0x83, 0x77, 0x1F, 0x63, 0x10, 0xF8, 0xAB, 0x48, 0xCB, 0x8F, 0x2D, 0x65,
-    0xE4, 0xDC, 0x0A, 0x50, 0x0B, 0x3A, 0xA8, 0x06, 0x1D, 0x07, 0x31, 0x12,
-    0x5B, 0x1F, 0x23, 0xE1, 0xD1, 0xB6, 0xE9, 0xB6, 0x5A, 0x92, 0xB6, 0xCE,
-    0x2F, 0xB9, 0xFF, 0xF3, 0x40, 0xD6, 0x65, 0x6E, 0xB8, 0xBC, 0x28, 0xF3,
-    0x41, 0xC8, 0x4B, 0xFC, 0x12, 0xBE, 0xC4, 0x92, 0xA2, 0x1C, 0x2D, 0x4A,
-    0x1A, 0x05, 0x39, 0x4A, 0xE9, 0x6D, 0x64, 0x05, 0x72, 0x45, 0xD7, 0x95,
-    0xC5, 0xC5, 0x52, 0x9A, 0x76, 0x93, 0x32, 0x47, 0xA8, 0xF2, 0x35, 0x00,
-    0xA4, 0x90, 0xD0, 0x10, 0x07, 0xDB, 0x23, 0x86, 0x24, 0x90, 0x94, 0x21,
-    0x55, 0x79, 0xF0, 0xF6, 0xB1, 0xAC, 0xEB, 0x72, 0xBF, 0xFB, 0x4C, 0x36,
-    0x0C, 0xF9, 0xE8, 0xD3, 0x6B, 0x79, 0x43, 0x55, 0x12, 0xF4, 0x22, 0x7D,
-    0x60, 0x46, 0x75, 0x4E, 0xD7, 0xE7, 0x0C, 0x63, 0xAE, 0x9C, 0xC6, 0x37,
-    0x20, 0x94, 0x94, 0x12, 0x84, 0xDD, 0x0B, 0xC9, 0x28, 0x5F, 0x74, 0x3E,
-    0xD2, 0x67, 0xB8, 0x15, 0xD6, 0x38, 0x1A, 0xED, 0x8F, 0x65, 0x48, 0xB6,
-    0xB6, 0xAB, 0x76, 0xDB, 0x58, 0x5A, 0xBC, 0xB1, 0x7B, 0xEF, 0x41, 0x73,
-    0xD5, 0xDB, 0x08, 0x0C, 0x4B, 0x92, 0x7C, 0x25, 0x71, 0xED, 0x3A, 0x62,
-    0x69, 0xD7, 0x52, 0x58, 0x58, 0x12, 0xC7, 0xF8, 0x0E, 0x37, 0x25, 0xCD,
-    0x9B, 0xF4, 0xBC, 0xD9, 0x69, 0xCF, 0xF3, 0x54, 0x25, 0xC5, 0x2B, 0x96,
-    0x9A, 0x2E, 0x63, 0x88, 0x98, 0x1D, 0x49, 0x3B, 0xE3, 0x8B, 0x4B, 0x0B,
-    0x77, 0x10, 0x33, 0x11, 0x71, 0xC2, 0x67, 0x9E, 0xCD, 0xEA, 0x84, 0x19,
-    0x99, 0x06, 0xE2, 0xA6, 0x86, 0x7D, 0x4E, 0xA4, 0xA1, 0x30, 0xBD, 0x85,
-    0x4C, 0x6C, 0x43, 0xBE, 0x1B, 0xA6, 0xA3, 0x2C, 0xC1, 0xED, 0x42, 0x41,
-    0x83, 0x51, 0x77, 0x07, 0x8B, 0xF9, 0x4F, 0x96, 0x54, 0xC4, 0x1D, 0x9C,
-    0x2D, 0x29, 0xB0, 0x31, 0x71, 0xDB, 0x92, 0x36, 0x55, 0x92, 0xEE, 0x21,
-    0x46, 0x25, 0x6D, 0x26, 0xC3, 0x1E, 0x1A, 0x93, 0x1A, 0x76, 0x34, 0x89,
-    0x94, 0x33, 0x69, 0x30, 0xDA, 0x81, 0x7E, 0x20, 0x69, 0x7F, 0x0E, 0xF9,
-    0x89, 0x9D, 0x66, 0x8C, 0x51, 0xE1, 0x36, 0x15, 0x0B, 0x49, 0x5B, 0xA9,
-    0xAD, 0x9F, 0x40, 0x96, 0x1C, 0x44, 0x46, 0xE4, 0x1F, 0x7F, 0x99, 0xBA,
-    0xC5, 0xDB, 0xDE, 0xD9, 0x41, 0x9B, 0xD0, 0x8C, 0x4E, 0xDB, 0x28, 0x0C,
-    0x73, 0xAE, 0x52, 0xCF, 0xDD, 0x86, 0x60, 0x99, 0x3A, 0x4D, 0x6C, 0x82,
-    0x1A, 0xA3, 0x53, 0x77, 0x6F, 0x02, 0x5D, 0x52, 0xC6, 0x91, 0x75, 0x4C,
-    0xCC, 0x26, 0x8D, 0xC8, 0x77, 0x0A, 0xC8, 0x7A, 0x87, 0x7F, 0x2A, 0x5A,
-    0x82, 0x55, 0x44, 0xC0, 0x04, 0x53, 0x32, 0x86, 0x70, 0x9D, 0xBA, 0x0C,
-    0x23, 0x06, 0x0C, 0xC7, 0x2A, 0x60, 0x2C, 0x58, 0xB4, 0x8E, 0x40, 0x0D,
-    0xFF, 0x93, 0x52, 0x45, 0x75, 0x86, 0x76, 0xC7, 0x52, 0x16, 0x18, 0xAC,
-    0xF3, 0x17, 0x77, 0x1C, 0x65, 0xAD, 0x09, 0xF1, 0x58, 0x02, 0x6F, 0xA9,
-    0x21, 0x6A, 0x01, 0xB7, 0xC6, 0xD2, 0x0C, 0x5A, 0x8A, 0xA6, 0x77, 0x5C,
-    0xD2, 0xD8, 0xA2, 0x3E, 0x33, 0x18, 0x89, 0x7F, 0xAA, 0x25, 0xE6, 0xA9,
-    0x2A, 0xC1, 0x87, 0xBD, 0xF6, 0x17, 0x6C, 0x42, 0x08, 0x21};
-const uint8_t g_koKR_Locale[] = {
-    0x78, 0x9C, 0xED, 0x56, 0x4D, 0x6B, 0xD4, 0x40, 0x18, 0x3E, 0x57, 0xF0,
-    0x3F, 0x0C, 0xC1, 0x12, 0x85, 0x76, 0xB7, 0xEB, 0x77, 0x4B, 0x1A, 0x28,
-    0x6E, 0x6D, 0x65, 0x8D, 0x94, 0xA6, 0x58, 0xEC, 0x45, 0x66, 0x93, 0xE9,
-    0x26, 0xED, 0x26, 0x53, 0x26, 0x09, 0x75, 0x73, 0xAE, 0x52, 0xF0, 0xE2,
-    0xA1, 0x87, 0xEA, 0x6E, 0xB1, 0x07, 0x11, 0x2A, 0x88, 0x22, 0x22, 0x1E,
-    0x14, 0x7F, 0x8D, 0x62, 0x6D, 0x8A, 0x7F, 0xC1, 0xC9, 0xE7, 0xE6, 0x63,
-    0xB2, 0x4D, 0xEF, 0xEE, 0x61, 0x99, 0xF7, 0x99, 0xE7, 0x79, 0xF3, 0xBE,
-    0xCF, 0x4C, 0x5E, 0x22, 0x74, 0xB1, 0x02, 0xBB, 0x08, 0x98, 0xD0, 0x40,
-    0xB3, 0xDC, 0x26, 0x7E, 0xDC, 0x5A, 0xE6, 0x80, 0x8A, 0x2C, 0x65, 0x96,
-    0xFB, 0x35, 0x38, 0x38, 0xFE, 0x34, 0xF8, 0xFD, 0xE1, 0xFD, 0xE5, 0xE3,
-    0xD7, 0x47, 0x3F, 0xFB, 0xDF, 0xAF, 0x70, 0xE2, 0xC5, 0x0B, 0x00, 0x08,
-    0x3E, 0xDF, 0x54, 0x21, 0x91, 0x7B, 0x46, 0x1B, 0x77, 0xAD, 0x48, 0xDA,
-    0x21, 0xA8, 0x83, 0x89, 0x0E, 0x4D, 0x9F, 0x35, 0x06, 0x04, 0x03, 0x9B,
-    0xB6, 0xF6, 0x80, 0x6E, 0x59, 0x7E, 0x3C, 0x16, 0xC6, 0x62, 0xC3, 0xEB,
-    0xEF, 0x09, 0xF5, 0x70, 0x9D, 0x82, 0xAF, 0xB2, 0xE1, 0x6B, 0x6C, 0xF8,
-    0x3A, 0x1B, 0xBE, 0xC1, 0x86, 0x6F, 0xB2, 0xE1, 0x5B, 0x6C, 0xF8, 0x36,
-    0x1B, 0x9E, 0x66, 0xC3, 0x8D, 0xA9, 0x12, 0xBC, 0xA4, 0xCF, 0x46, 0xAE,
-    0x51, 0x10, 0xAD, 0x13, 0x9F, 0xD2, 0xBE, 0x01, 0xD8, 0x6E, 0x93, 0x59,
-    0xAE, 0xC1, 0xFD, 0x37, 0xF0, 0x3C, 0x06, 0xAA, 0xB0, 0x97, 0xBA, 0x76,
-    0x34, 0x12, 0xBD, 0x83, 0x6F, 0xDE, 0xAB, 0x3D, 0xFA, 0x2F, 0xD4, 0xFD,
-    0x70, 0x88, 0xF7, 0xF7, 0x98, 0xF8, 0xE9, 0x4B, 0x36, 0xEE, 0xED, 0xEE,
-    0x33, 0xF1, 0x93, 0x77, 0x47, 0x4C, 0xFC, 0xCF, 0xD7, 0x5D, 0x76, 0xFE,
-    0x67, 0x87, 0x39, 0x1C, 0x04, 0x2B, 0x46, 0x13, 0xB9, 0x3B, 0x10, 0x75,
-    0x53, 0xEC, 0xA3, 0xD8, 0x41, 0xB1, 0xF6, 0x62, 0xD5, 0xC5, 0x7A, 0x8B,
-    0x95, 0x96, 0xD7, 0x68, 0x20, 0xA2, 0xAB, 0x3A, 0x32, 0xD2, 0x2F, 0x79,
-    0x04, 0x89, 0xDE, 0xFE, 0x1B, 0xEF, 0x70, 0x87, 0x1E, 0x4E, 0x0C, 0x14,
-    0xB6, 0x4F, 0xFB, 0xB9, 0x6D, 0x30, 0x0C, 0x53, 0x0F, 0x41, 0x04, 0xA6,
-    0xF2, 0xD3, 0x88, 0x56, 0xF9, 0xD1, 0xEB, 0xBF, 0x08, 0xB2, 0xFB, 0x61,
-    0x82, 0x7B, 0x3B, 0x03, 0xBA, 0x95, 0x80, 0x20, 0x58, 0xC5, 0x5A, 0x3A,
-    0xB6, 0xEA, 0xB9, 0xB9, 0x15, 0xA2, 0x2A, 0xB4, 0xD1, 0x12, 0xB4, 0x6D,
-    0x44, 0xCC, 0xC4, 0xFA, 0x04, 0x89, 0x46, 0xDB, 0xBA, 0xD3, 0xED, 0x72,
-    0xE2, 0x23, 0xFA, 0xE3, 0x4F, 0x9E, 0xEE, 0xF0, 0x40, 0xE2, 0xA9, 0xE3,
-    0x3C, 0x68, 0xF2, 0xF4, 0x28, 0x78, 0x30, 0x4F, 0x7F, 0xBE, 0x35, 0x89,
-    0xAA, 0x2C, 0x4D, 0x17, 0x9B, 0x9D, 0xD2, 0x34, 0x95, 0x32, 0x18, 0x48,
-    0x0D, 0x13, 0xD4, 0x80, 0x24, 0xD5, 0x40, 0xB3, 0x59, 0x49, 0x65, 0x69,
-    0x98, 0xD8, 0xBE, 0xAE, 0x4C, 0x05, 0x40, 0x06, 0x89, 0x9C, 0xB1, 0x75,
-    0x23, 0xE7, 0x4C, 0x0A, 0xC9, 0x38, 0x33, 0x07, 0x34, 0x8D, 0xF7, 0x9E,
-    0x0F, 0x68, 0x4B, 0x12, 0x7F, 0xF2, 0x85, 0xB6, 0x26, 0xCB, 0xBC, 0xF7,
-    0x79, 0x97, 0x07, 0x6B, 0x42, 0x3D, 0x25, 0x2A, 0xCB, 0x12, 0x1A, 0x53,
-    0x9A, 0xA5, 0x52, 0x8E, 0xC0, 0x1A, 0x9A, 0x62, 0x46, 0x92, 0x66, 0x64,
-    0xB9, 0x92, 0x24, 0xF2, 0x25, 0x14, 0xE5, 0x15, 0xBE, 0x27, 0x39, 0x07,
-    0xA2, 0xDB, 0xB2, 0x42, 0xD1, 0xF8, 0x0A, 0x2D, 0x40, 0x73, 0x63, 0x73,
-    0xD1, 0xB0, 0xE4, 0xF9, 0xE6, 0xDD, 0xED, 0xD5, 0x27, 0x5A, 0xCB, 0x5D,
-    0x0B, 0xAD, 0x4C, 0x93, 0x02, 0xA5, 0xE9, 0x18, 0x6D, 0x44, 0xB2, 0x7E,
-    0x66, 0xB0, 0xA8, 0x28, 0x8A, 0xD1, 0x97, 0x40, 0xE1, 0x44, 0x77, 0xC2,
-    0x75, 0xA7, 0x6B, 0xAE, 0xEB, 0x0A, 0xF5, 0x0C, 0xAF, 0x5C, 0xAA, 0x38,
-    0x84, 0x20, 0x53, 0xE9, 0x71, 0xE2, 0xA5, 0x40, 0x5C, 0x59, 0xB8, 0x85,
-    0x88, 0x82, 0x4C, 0x3B, 0x7A, 0xE6, 0x78, 0x51, 0xE7, 0x9B, 0x51, 0x68,
-    0x20, 0x69, 0x6A, 0xD8, 0xE7, 0x58, 0x16, 0x8A, 0xD2, 0xAB, 0x48, 0xD1,
-    0x0D, 0x48, 0xEF, 0x49, 0x2D, 0xCE, 0x12, 0x6E, 0x97, 0x0A, 0x3A, 0x04,
-    0x3B, 0x5B, 0xBA, 0x7F, 0x27, 0x26, 0x2A, 0x2A, 0x92, 0x0E, 0xC6, 0x2B,
-    0x0A, 0x0C, 0xDD, 0x74, 0x2C, 0x4E, 0x9C, 0xAC, 0x48, 0x77, 0x11, 0xC1,
-    0x9C, 0x38, 0x55, 0x60, 0x0F, 0x8D, 0xC9, 0x1C, 0x76, 0x7C, 0x12, 0x19,
-    0x67, 0xB2, 0x60, 0x7C, 0x07, 0x83, 0x80, 0x13, 0xFF, 0xFE, 0x78, 0x4B,
-    0x07, 0x54, 0x86, 0x31, 0x42, 0xA5, 0x5B, 0xD8, 0x5F, 0x70, 0x62, 0x6B,
-    0x79, 0xF5, 0x1C, 0xB2, 0xF4, 0x41, 0x14, 0x44, 0xC1, 0x84, 0x2C, 0xD4,
-    0xED, 0xCF, 0x81, 0xDE, 0x16, 0x5A, 0x87, 0x4A, 0x3C, 0x90, 0xE3, 0x30,
-    0xCA, 0x39, 0xA7, 0xE2, 0x36, 0x02, 0x52, 0xCF, 0x31, 0x3B, 0x1B, 0x18,
-    0xC8, 0xB6, 0x0A, 0x24, 0xAE, 0xCE, 0x64, 0x4A, 0x3D, 0xFA, 0x75, 0xA8,
-    0x82, 0x25, 0xEA, 0x64, 0x09, 0x41, 0x37, 0x75, 0x6C, 0x8E, 0x20, 0xDC,
-    0xC1, 0x0E, 0xD1, 0x11, 0xF1, 0x9F, 0x52, 0xC2, 0x08, 0xAB, 0x59, 0xD2,
-    0xCF, 0xA4, 0x2C, 0xA2, 0x36, 0x41, 0xDB, 0x23, 0x29, 0x73, 0x04, 0xB6,
-    0xE9, 0x8B, 0x38, 0x8A, 0xB2, 0xA2, 0x41, 0xBD, 0x84, 0xD0, 0xC2, 0xAE,
-    0xB3, 0x09, 0xC1, 0x02, 0xB6, 0x35, 0x5D, 0xF1, 0x7B, 0x9A, 0x7C, 0x78,
-    0xAF, 0xD4, 0x9A, 0x88, 0x4C, 0x0D, 0x50, 0x34, 0x1C, 0x93, 0x97, 0x47,
-    0x3E, 0x9A, 0x72, 0x3B, 0x81, 0xDD, 0xF7, 0x47, 0xD2, 0x64, 0x9C, 0xA1,
-    0x05, 0x53, 0x2D, 0x75, 0x9E, 0x42, 0x3D, 0xFC, 0xFC, 0x17, 0xFF, 0x01,
-    0xDC, 0xF1, 0x18, 0xD3};
-const uint8_t g_esES_Locale[] = {
-    0x78, 0x9C, 0x9D, 0x56, 0xCF, 0x6B, 0xD4, 0x40, 0x14, 0xBE, 0x0B, 0xFE,
-    0x0F, 0x21, 0x58, 0x56, 0xA1, 0xDD, 0xD1, 0x63, 0xCB, 0x36, 0x50, 0xDA,
-    0xDA, 0x95, 0x1A, 0x59, 0x9A, 0xAA, 0xD8, 0x8B, 0x4C, 0x92, 0xE9, 0xEE,
-    0xB4, 0xC9, 0xCC, 0x32, 0x49, 0x2C, 0x9B, 0xA3, 0xE0, 0x41, 0x10, 0x0B,
-    0xDE, 0x8A, 0x27, 0x0F, 0x1E, 0x04, 0x8B, 0x77, 0x51, 0x3C, 0xF4, 0x3F,
-    0x11, 0x6A, 0xEB, 0xC9, 0x7F, 0xC1, 0x37, 0x9B, 0x49, 0x36, 0x3F, 0x66,
-    0xD7, 0x60, 0x4E, 0xF3, 0xBE, 0xF7, 0x7D, 0x2F, 0xEF, 0x7D, 0x93, 0x4C,
-    0xD2, 0x0B, 0xB8, 0x87, 0x03, 0x62, 0x30, 0x1C, 0x92, 0x75, 0x93, 0x44,
-    0xCF, 0xB7, 0x1D, 0xD3, 0xF0, 0x49, 0xE4, 0xAD, 0x9B, 0xD7, 0x1F, 0x7F,
-    0x5C, 0x9D, 0x9E, 0x5F, 0xBD, 0x3E, 0xBB, 0xFE, 0x72, 0x7E, 0xBB, 0x08,
-    0xFE, 0x7C, 0x7B, 0x73, 0xF9, 0xFE, 0xFB, 0xEF, 0xB3, 0x57, 0xBF, 0xDE,
-    0xBE, 0xBB, 0xFC, 0x7A, 0x7A, 0xC7, 0xB4, 0x7A, 0xB2, 0x00, 0xF3, 0xB1,
-    0x70, 0x26, 0xA1, 0xCB, 0x83, 0x48, 0xD5, 0x1A, 0x0A, 0x32, 0xE4, 0x82,
-    0x62, 0x06, 0x8C, 0x90, 0xB3, 0x78, 0xF4, 0x08, 0xE0, 0x48, 0xAD, 0x2D,
-    0xC2, 0x88, 0xE0, 0x3D, 0x94, 0x05, 0x37, 0x6F, 0x28, 0xF4, 0x90, 0xB8,
-    0x42, 0x87, 0x87, 0x58, 0xA4, 0x4D, 0x14, 0xBB, 0x82, 0x06, 0x1A, 0xEE,
-    0xA4, 0x49, 0x3D, 0x4A, 0x18, 0xD5, 0xA1, 0x81, 0x06, 0xC5, 0x43, 0x1E,
-    0xC5, 0x4D, 0x38, 0x22, 0xE3, 0x98, 0x92, 0x10, 0x1A, 0x6C, 0xA4, 0xB8,
-    0x17, 0x27, 0x3A, 0x9C, 0xF1, 0x17, 0x73, 0x14, 0x3E, 0xF5, 0x1A, 0x19,
-    0x54, 0x72, 0x29, 0x27, 0x4E, 0x23, 0x03, 0xBB, 0xAE, 0x58, 0x37, 0xEF,
-    0x99, 0x25, 0xF3, 0x74, 0xD6, 0xE9, 0x6C, 0xD3, 0x99, 0xA6, 0xB3, 0x4C,
-    0xE7, 0x98, 0xCE, 0x2F, 0x9D, 0x5B, 0x3A, 0xAB, 0x74, 0x1E, 0xE9, 0xFC,
-    0xD1, 0x39, 0x33, 0xDF, 0x13, 0x1F, 0x4F, 0xD4, 0x53, 0x04, 0x2B, 0xCB,
-    0xE7, 0x21, 0x65, 0xF2, 0xF6, 0x32, 0xC8, 0xB2, 0x56, 0x90, 0x30, 0x12,
-    0x55, 0x10, 0x30, 0x21, 0xAE, 0x43, 0xF4, 0xE2, 0x93, 0xF0, 0x78, 0x50,
-    0x83, 0x8F, 0x12, 0xF2, 0xA2, 0x06, 0xC1, 0xFE, 0x89, 0x7A, 0xC1, 0xE8,
-    0xE2, 0x83, 0x8B, 0xFD, 0xD9, 0x6D, 0x51, 0xD1, 0x55, 0xA9, 0xC3, 0xD2,
-    0x9E, 0xA9, 0x56, 0xEB, 0x6D, 0xD6, 0x9B, 0x6C, 0x74, 0x58, 0xEF, 0xAD,
-    0xDE, 0x58, 0xA3, 0x29, 0x7D, 0x47, 0x21, 0x11, 0xD4, 0x87, 0x87, 0x2D,
-    0x7F, 0xFD, 0x54, 0x68, 0x6D, 0xD8, 0xE0, 0x6E, 0x1E, 0x94, 0x78, 0xD6,
-    0xA0, 0x96, 0x40, 0xD5, 0x0A, 0x80, 0x10, 0x81, 0x55, 0x35, 0x58, 0x59,
-    0xB8, 0xBB, 0xD9, 0xED, 0x21, 0xB9, 0xCA, 0x52, 0x96, 0x5F, 0x06, 0x50,
-    0x41, 0x96, 0x41, 0xED, 0xA8, 0xC8, 0xBA, 0x8F, 0xC9, 0x00, 0xC7, 0x31,
-    0x18, 0x3D, 0xDD, 0xD7, 0x22, 0x52, 0xE7, 0xC8, 0x61, 0x12, 0x04, 0xA6,
-    0xB5, 0x0D, 0x97, 0xB1, 0xD5, 0x81, 0xA3, 0xC9, 0xE8, 0xD8, 0x70, 0x65,
-    0xAB, 0x67, 0x70, 0xC9, 0x69, 0x0B, 0x4D, 0xAD, 0xA0, 0x2A, 0x11, 0x70,
-    0x36, 0x34, 0xAD, 0xFF, 0x55, 0x87, 0xC4, 0x07, 0xF1, 0x16, 0xB2, 0x6D,
-    0xD4, 0x52, 0x11, 0x8D, 0xB8, 0x88, 0x67, 0x9A, 0x86, 0x02, 0x55, 0x66,
-    0x06, 0x20, 0xA6, 0x61, 0xC9, 0x83, 0x52, 0x54, 0xF1, 0xA0, 0xDF, 0xEF,
-    0xF4, 0xA1, 0xFD, 0x0E, 0x5C, 0x0E, 0x9C, 0xD2, 0x07, 0x3D, 0x54, 0x62,
-    0xD6, 0xCA, 0x54, 0x26, 0xEF, 0xF7, 0xD7, 0x6C, 0x7B, 0xCD, 0x71, 0x5A,
-    0x49, 0xA6, 0xE3, 0x2A, 0x41, 0x0B, 0xBA, 0x9A, 0x55, 0x0A, 0x1A, 0x6C,
-    0x54, 0x99, 0x4B, 0x59, 0xB5, 0x0F, 0x58, 0xBE, 0xFD, 0x3B, 0x89, 0x1D,
-    0x1F, 0x8F, 0xC2, 0xC8, 0xD9, 0xDE, 0xBA, 0x7F, 0xF2, 0x14, 0x8F, 0x76,
-    0xD3, 0x83, 0xCC, 0x9C, 0x32, 0x09, 0x74, 0x2C, 0x09, 0x5D, 0x22, 0x66,
-    0x0E, 0x55, 0x62, 0xD5, 0x08, 0x60, 0xF0, 0x9C, 0x7A, 0xA6, 0x95, 0x2E,
-    0xA7, 0xE9, 0x6A, 0x37, 0x4D, 0xD3, 0x1E, 0xAA, 0xF0, 0x1A, 0x85, 0x94,
-    0xD0, 0x4B, 0x84, 0x20, 0xCC, 0x9B, 0xE4, 0xCA, 0xD5, 0x55, 0xE3, 0x56,
-    0x4B, 0xE9, 0x98, 0x08, 0x8F, 0xB0, 0x58, 0x29, 0x97, 0x34, 0x2A, 0x54,
-    0x6B, 0xBD, 0x28, 0x94, 0x4F, 0x57, 0x09, 0x55, 0x59, 0x9F, 0x78, 0x34,
-    0xC4, 0xB0, 0xE3, 0xCB, 0xB9, 0x3E, 0x4B, 0xD7, 0xD5, 0xC5, 0x97, 0x96,
-    0x27, 0x63, 0x2A, 0x37, 0xBA, 0xDB, 0x8A, 0x5F, 0x74, 0xBD, 0xD4, 0x8A,
-    0x0E, 0x87, 0x6C, 0x12, 0x99, 0xD6, 0x4A, 0x2B, 0x72, 0x0A, 0x9F, 0x6F,
-    0xD3, 0xBA, 0xDB, 0xE4, 0xA2, 0xEA, 0xD8, 0x80, 0xE4, 0xBE, 0x17, 0x4E,
-    0x54, 0x81, 0xFC, 0xF9, 0x9A, 0x06, 0xA6, 0xF5, 0xF3, 0xE5, 0x67, 0x38,
-    0x3E, 0x2A, 0x8C, 0x66, 0x11, 0xA5, 0xA1, 0x11, 0x97, 0x0B, 0x38, 0x35,
-    0x1E, 0xEF, 0xB5, 0x16, 0x95, 0x4D, 0x6F, 0x4A, 0x50, 0xBD, 0x5B, 0xF9,
-    0x32, 0x4C, 0xC6, 0xE4, 0x10, 0x7B, 0xF2, 0x1C, 0xCC, 0x97, 0xAA, 0x96,
-    0x3D, 0x81, 0x1F, 0x1F, 0xDF, 0x18, 0x80, 0x17, 0xA8, 0xCC, 0xCC, 0xD3,
-    0x14, 0xFE, 0x46, 0xD8, 0xDC, 0xF4, 0x26, 0x4F, 0x04, 0x7C, 0x77, 0x0C,
-    0x27, 0xF6, 0xB5, 0xF9, 0x0D, 0x9F, 0xBB, 0xC4, 0x18, 0xD0, 0x7F, 0x10,
-    0xFA, 0xF2, 0x67, 0xEA, 0x64, 0x01, 0x61, 0x43, 0x60, 0x17, 0x5E, 0x98,
-    0xF9, 0x84, 0xFD, 0x11, 0xA6, 0xDA, 0xF4, 0x2E, 0x4F, 0x93, 0x63, 0x6C,
-    0xEC, 0xF0, 0x78, 0x44, 0x3D, 0x39, 0xC7, 0xCA, 0x93, 0x07, 0x86, 0xBD,
-    0x88, 0x0A, 0x23, 0x7B, 0x23, 0x9E, 0x53, 0xF7, 0x16, 0xDC, 0x14, 0x98,
-    0x43, 0x39, 0x99, 0xF1, 0x70, 0x01, 0xC9, 0xE1, 0x2D, 0x48, 0xF6, 0x24,
-    0x61, 0xC3, 0x23, 0x3E, 0xE5, 0xA9, 0xE6, 0xD0, 0x6C, 0xCF, 0x64, 0x94,
-    0xFD, 0xFC, 0xC2, 0xF2, 0x2F, 0x7C, 0xDC, 0xCC, 0x2F,
-};
-const uint8_t g_esLA_Locale[] = {
-    0x78, 0x9C, 0x9D, 0x56, 0xCD, 0x4E, 0xDC, 0x30, 0x10, 0x3E, 0x53, 0xA9,
-    0xEF, 0x60, 0x45, 0x45, 0x80, 0x04, 0x9B, 0xF6, 0xB8, 0x28, 0x44, 0x5A,
-    0x01, 0xA5, 0x15, 0x0D, 0x5A, 0x75, 0x51, 0x4B, 0xB9, 0x54, 0x4E, 0x62,
-    0x36, 0x86, 0xC4, 0x5E, 0x39, 0x09, 0x68, 0xA3, 0xBE, 0x40, 0x4F, 0x3D,
-    0xF4, 0xD4, 0x63, 0x2B, 0x21, 0xB5, 0x07, 0xD4, 0x47, 0xE8, 0x81, 0x67,
-    0x41, 0xF0, 0x18, 0x9D, 0xFC, 0x6E, 0x12, 0x3B, 0xE9, 0xD2, 0x9C, 0x3C,
-    0xDF, 0x7C, 0x9F, 0x77, 0xE6, 0xB3, 0x33, 0x1B, 0xC3, 0xE7, 0x0E, 0xF6,
-    0x09, 0x62, 0x38, 0x20, 0x3B, 0x1A, 0x09, 0x3F, 0x5A, 0x27, 0x1A, 0x72,
-    0x49, 0xE8, 0xEC, 0x68, 0x0F, 0xD7, 0x7F, 0xEE, 0xBF, 0xDC, 0xDC, 0x7F,
-    0xFE, 0xF6, 0xF0, 0xFB, 0x66, 0xFD, 0xEE, 0xC7, 0x4F, 0x88, 0xEF, 0xBE,
-    0x5E, 0x6F, 0x68, 0xE6, 0xD3, 0x27, 0x08, 0x19, 0xA9, 0x8A, 0xB9, 0x58,
-    0x4C, 0xE6, 0x81, 0xCD, 0xFD, 0xB0, 0xD8, 0x60, 0x2A, 0xC8, 0x94, 0x0B,
-    0x8A, 0x59, 0xCA, 0x5A, 0x41, 0x46, 0xC0, 0x59, 0xE4, 0x1D, 0x41, 0x2A,
-    0x4C, 0xE3, 0x95, 0x3C, 0x36, 0x09, 0x23, 0x82, 0x1B, 0x7A, 0x1E, 0xD4,
-    0xF0, 0x33, 0x62, 0x0B, 0x75, 0x26, 0xC0, 0x22, 0x51, 0xE1, 0xD8, 0x16,
-    0xD4, 0x57, 0xF2, 0xE7, 0x2A, 0xFA, 0x79, 0xCC, 0xA8, 0x1A, 0xF7, 0x95,
-    0x38, 0x9E, 0xF2, 0x30, 0x52, 0x25, 0x42, 0x32, 0x8B, 0x28, 0x09, 0xA0,
-    0x5C, 0x45, 0x92, 0x3B, 0x51, 0xAC, 0xCE, 0x30, 0x7E, 0xD9, 0xA9, 0x72,
-    0xA9, 0x23, 0xE5, 0x50, 0xB1, 0xAE, 0x1C, 0xAC, 0x3B, 0x8A, 0xB0, 0x6D,
-    0x8B, 0x1D, 0xED, 0x85, 0xD6, 0xB2, 0x56, 0x6D, 0xAC, 0xDA, 0x54, 0xB5,
-    0xA5, 0x6A, 0x43, 0xD5, 0x7E, 0xAA, 0xDD, 0x54, 0x7B, 0xA9, 0x36, 0x52,
-    0xED, 0xA0, 0xDA, 0x3D, 0xB5, 0x6F, 0xFD, 0x8E, 0xB9, 0x78, 0x5E, 0xBB,
-    0x81, 0x10, 0x99, 0x2E, 0x0F, 0x28, 0x4B, 0xCB, 0x49, 0x83, 0x0A, 0xF5,
-    0x63, 0x46, 0xC2, 0x16, 0x06, 0x16, 0x45, 0x32, 0x48, 0x6F, 0x7F, 0x09,
-    0x87, 0xFB, 0x52, 0xE2, 0x3C, 0x26, 0x97, 0x12, 0x08, 0x27, 0x2E, 0xE4,
-    0x8D, 0xC3, 0xDB, 0xEF, 0x36, 0x76, 0x17, 0x25, 0xA0, 0x6C, 0xA5, 0xA8,
-    0xBA, 0x75, 0xCA, 0x45, 0xF9, 0x72, 0xE9, 0x72, 0xE1, 0x8A, 0xAA, 0xE5,
-    0x7A, 0xE5, 0x62, 0x15, 0x85, 0x76, 0x57, 0x19, 0x10, 0x41, 0x5D, 0xB8,
-    0xB6, 0xF5, 0x57, 0xBC, 0x80, 0xCC, 0x91, 0x05, 0x67, 0x51, 0x06, 0xCD,
-    0xD4, 0xB8, 0x95, 0x42, 0x8B, 0xB0, 0xB6, 0x39, 0x11, 0xB8, 0xB6, 0x2F,
-    0x44, 0x26, 0x1E, 0xEC, 0x0E, 0x0C, 0x3D, 0x5D, 0x55, 0x90, 0x5B, 0x87,
-    0x50, 0xB6, 0x2A, 0x45, 0x30, 0xA5, 0xF4, 0xD6, 0x98, 0xCA, 0x51, 0x17,
-    0x47, 0x64, 0x8C, 0xA3, 0x08, 0x0E, 0xA6, 0x72, 0xBB, 0x42, 0x8A, 0x49,
-    0x76, 0x16, 0xFB, 0xBE, 0x66, 0xEE, 0xC3, 0x83, 0xF6, 0xD6, 0x60, 0x22,
-    0xA2, 0x35, 0x0B, 0x9E, 0x7C, 0xF5, 0x01, 0x9E, 0xD4, 0x89, 0x4A, 0xD3,
-    0xB5, 0x89, 0xCF, 0xD9, 0x54, 0x33, 0xFF, 0x5F, 0x1F, 0x10, 0x17, 0xE4,
-    0x7B, 0xBA, 0x65, 0xE9, 0x4B, 0x6B, 0x42, 0x8F, 0x8B, 0x68, 0xA1, 0x6A,
-    0x6B, 0x10, 0x6A, 0x20, 0x85, 0x23, 0x11, 0x0D, 0x5A, 0x8E, 0xD4, 0x90,
-    0x86, 0x23, 0x9E, 0xB7, 0x6D, 0x59, 0xDB, 0x93, 0x09, 0x1A, 0xA1, 0x53,
-    0x43, 0xAF, 0xB1, 0xBA, 0x64, 0xB9, 0x07, 0x8F, 0x96, 0x65, 0xAD, 0x2F,
-    0x54, 0x4B, 0x69, 0x8A, 0xD6, 0x33, 0x95, 0x2C, 0x49, 0x3B, 0x6F, 0xF5,
-    0x59, 0xDC, 0x85, 0x63, 0x40, 0xCB, 0x0B, 0x72, 0x10, 0x5B, 0xD1, 0x85,
-    0x17, 0x84, 0x93, 0xFD, 0xBD, 0x97, 0x57, 0xEF, 0xB1, 0x77, 0x98, 0x9C,
-    0xE6, 0x86, 0xD5, 0x49, 0x99, 0x92, 0xC5, 0x81, 0x4D, 0x44, 0xD3, 0xB5,
-    0x06, 0x56, 0x54, 0x05, 0x18, 0xDC, 0x6D, 0x47, 0x33, 0x93, 0xCD, 0x24,
-    0x19, 0x0E, 0x92, 0x24, 0x31, 0xF4, 0x06, 0xAF, 0x5B, 0xEA, 0xC4, 0x42,
-    0x10, 0xE6, 0xCC, 0x35, 0xF3, 0x59, 0x2E, 0x1E, 0x0E, 0x3F, 0xAD, 0x57,
-    0xCB, 0x8D, 0xA5, 0xF7, 0x99, 0x11, 0xE1, 0x10, 0x16, 0x15, 0x25, 0xAC,
-    0xCA, 0xBA, 0xD4, 0x1B, 0xA9, 0x9F, 0xAA, 0xC7, 0x45, 0xDB, 0x2B, 0x4D,
-    0xA8, 0xD8, 0xDE, 0x25, 0x0E, 0x0D, 0x30, 0x5C, 0x8E, 0x41, 0xB9, 0x4B,
-    0x9E, 0xEE, 0x14, 0x4C, 0x05, 0x8F, 0x67, 0x34, 0xBD, 0x17, 0x9B, 0x4B,
-    0x2A, 0xAA, 0x0E, 0x56, 0x97, 0x14, 0xC0, 0x84, 0x8F, 0x43, 0xCD, 0xDC,
-    0x5A, 0x92, 0x9E, 0xC0, 0x77, 0x87, 0x66, 0x3E, 0x97, 0xD8, 0x0B, 0x63,
-    0x1A, 0x67, 0x5F, 0x1E, 0x4C, 0xC3, 0x99, 0x26, 0x58, 0xDE, 0xC9, 0x2C,
-    0x80, 0x03, 0x84, 0x59, 0xD4, 0xC8, 0xF7, 0x68, 0x68, 0xC8, 0xD3, 0x85,
-    0x66, 0x5A, 0x27, 0x47, 0x8F, 0x90, 0xD5, 0x8F, 0x41, 0x12, 0x65, 0xC3,
-    0x50, 0xAA, 0x3A, 0x7D, 0xF5, 0xE7, 0x33, 0x72, 0x86, 0x9D, 0x72, 0xE8,
-    0x96, 0x61, 0xB1, 0xA7, 0x35, 0x87, 0xAF, 0x39, 0x17, 0x8D, 0xC1, 0x1D,
-    0x5D, 0x4D, 0xA0, 0xF0, 0x49, 0xC5, 0x7A, 0x08, 0xBB, 0x3C, 0x16, 0xF0,
-    0x17, 0x88, 0x26, 0x91, 0xDB, 0xC1, 0x18, 0xB9, 0xDC, 0x26, 0x68, 0x4C,
-    0xFF, 0x49, 0x79, 0x95, 0x7E, 0x1F, 0x5E, 0xF5, 0x52, 0x46, 0x02, 0xDB,
-    0xF0, 0xAE, 0xF5, 0x51, 0x8E, 0x3D, 0x4C, 0x3B, 0x08, 0x87, 0x3C, 0x89,
-    0x2F, 0x30, 0x3A, 0xE0, 0x91, 0x47, 0x9D, 0xB4, 0xA7, 0xAD, 0x77, 0xAF,
-    0x91, 0xD5, 0x4F, 0x06, 0x03, 0x1C, 0x8F, 0x97, 0xE4, 0xB7, 0xBD, 0x3F,
-    0x0D, 0xDC, 0x69, 0xDA, 0x25, 0x7A, 0xD3, 0x4B, 0x9B, 0xF0, 0xA5, 0x68,
-    0xD6, 0x3C, 0x66, 0xD3, 0x73, 0x9E, 0x31, 0xF3, 0x22, 0xB3, 0x11, 0x57,
-    0x3B, 0x4F, 0x43, 0xCF, 0x3F, 0xEF, 0xCD, 0xBF, 0xC4, 0xB5, 0xD4, 0x04};
-const uint8_t g_deDE_Loacale[] = {
-    0x78, 0x9C, 0x95, 0x56, 0x4D, 0x6F, 0xD4, 0x30, 0x10, 0xBD, 0x23, 0xF1,
-    0x1F, 0xAC, 0x88, 0xAA, 0x20, 0xB5, 0x1B, 0x38, 0xB6, 0xDA, 0x46, 0x5A,
-    0x75, 0xFB, 0x41, 0x4B, 0xCA, 0xAA, 0x69, 0x41, 0xF4, 0x82, 0xBC, 0x89,
-    0xBB, 0x71, 0x9B, 0xD8, 0x2B, 0xC7, 0x69, 0xB5, 0x39, 0xF2, 0x37, 0xB8,
-    0x72, 0x04, 0x71, 0xE4, 0x04, 0x17, 0xFE, 0x09, 0x52, 0x25, 0x7E, 0x06,
-    0x93, 0x8D, 0x93, 0x26, 0xB6, 0xBB, 0x0D, 0xB9, 0xAC, 0xE7, 0xCD, 0x7B,
-    0xB3, 0x33, 0xCF, 0x89, 0x93, 0x61, 0xC2, 0x43, 0x9C, 0x10, 0xC4, 0x70,
-    0x4A, 0x76, 0x9C, 0x88, 0x7C, 0x1C, 0xEF, 0x39, 0x28, 0x22, 0x59, 0xB8,
-    0xE3, 0xDC, 0xFD, 0xFA, 0xF1, 0xF7, 0xFB, 0xB7, 0xE7, 0xF0, 0x73, 0xF7,
-    0xF9, 0xE7, 0x0B, 0xC7, 0x1B, 0x96, 0x44, 0x16, 0x61, 0x11, 0x2C, 0xD2,
-    0x29, 0x4F, 0x32, 0xA5, 0x99, 0x09, 0x32, 0xE3, 0x82, 0x62, 0x06, 0x8C,
-    0x94, 0x33, 0x19, 0x9F, 0x00, 0x9C, 0xA9, 0xB5, 0x77, 0x84, 0x59, 0x8E,
-    0xC5, 0xD0, 0xAD, 0xA2, 0xA7, 0x4F, 0x14, 0xBC, 0x4F, 0xA6, 0xC2, 0x86,
-    0xFB, 0xBF, 0xBF, 0x88, 0xC2, 0x40, 0x47, 0x73, 0x41, 0x13, 0x93, 0x8B,
-    0xA9, 0x81, 0x1D, 0xE5, 0xCC, 0x06, 0x26, 0x26, 0x38, 0xCA, 0x67, 0x79,
-    0x26, 0x0D, 0x38, 0x20, 0x73, 0x49, 0xD2, 0x29, 0x31, 0x5B, 0x7B, 0x7B,
-    0x2D, 0xB9, 0x0D, 0x3F, 0xE1, 0x37, 0x76, 0xC1, 0x98, 0x14, 0x7A, 0xC2,
-    0x6D, 0x19, 0x54, 0xF3, 0x96, 0x11, 0xC2, 0xD3, 0xA9, 0xD8, 0x71, 0x5E,
-    0x39, 0x2D, 0xDF, 0x6C, 0xA6, 0x99, 0x26, 0xD8, 0xED, 0xEA, 0x6B, 0x96,
-    0xCD, 0x2B, 0x9B, 0x55, 0x36, 0x9F, 0x6C, 0x0E, 0xD9, 0xDC, 0xB1, 0x19,
-    0xF3, 0xB0, 0x27, 0x11, 0x5E, 0xA8, 0x1B, 0x08, 0x56, 0x5E, 0xC0, 0x19,
-    0x93, 0x18, 0xFE, 0xBE, 0x0C, 0xAA, 0xAC, 0xE7, 0x73, 0x03, 0x1A, 0x53,
-    0xC2, 0x32, 0x83, 0x47, 0xA5, 0xBC, 0xE5, 0x61, 0xDC, 0x65, 0x42, 0x41,
-    0x22, 0x0C, 0xEE, 0xBE, 0x20, 0x54, 0xC7, 0x02, 0x9C, 0x76, 0x78, 0x6E,
-    0xD3, 0x5A, 0xAB, 0xCD, 0xD6, 0xC6, 0x55, 0xFD, 0x6A, 0xAD, 0x6A, 0x6D,
-    0x6A, 0x0D, 0x6A, 0xAD, 0x69, 0x2D, 0x69, 0xDD, 0xD8, 0x1B, 0x49, 0x89,
-    0xA0, 0x11, 0x25, 0x69, 0xFD, 0xD4, 0xA9, 0xD0, 0x1B, 0xF9, 0xE0, 0x6C,
-    0x1D, 0xB4, 0x78, 0xDE, 0x44, 0x4B, 0xB8, 0xDD, 0x0A, 0x80, 0x10, 0x81,
-    0x55, 0x35, 0x58, 0x79, 0x37, 0x03, 0xB4, 0x1B, 0x8B, 0xC1, 0xD0, 0x2D,
-    0x83, 0x2A, 0xEB, 0x31, 0x0D, 0x73, 0x1B, 0x49, 0x19, 0x68, 0xE7, 0x44,
-    0x35, 0x81, 0x24, 0x13, 0x2C, 0x25, 0x11, 0x6C, 0xB9, 0xB3, 0x4D, 0xA4,
-    0x0E, 0x91, 0xCB, 0x3C, 0x49, 0x1C, 0x6F, 0x0F, 0xAE, 0x0D, 0x34, 0x1E,
-    0x20, 0x1F, 0x2E, 0xF4, 0x01, 0xAE, 0x72, 0xD6, 0x86, 0xAB, 0x15, 0x52,
-    0xD2, 0x84, 0xB3, 0x99, 0xE3, 0xFD, 0xA7, 0x28, 0x25, 0x11, 0x68, 0xC6,
-    0x03, 0xDF, 0x1F, 0xF4, 0x54, 0x64, 0x31, 0x17, 0xF2, 0x5E, 0x63, 0x28,
-    0xDC, 0xCE, 0x88, 0x00, 0x48, 0x9A, 0xB6, 0x46, 0x6E, 0x45, 0x9D, 0x91,
-    0x0F, 0xB7, 0x7D, 0x7F, 0x1D, 0x9D, 0xC7, 0x02, 0xAD, 0x5F, 0x0C, 0xDD,
-    0x16, 0x4B, 0x2B, 0xD1, 0x19, 0xF6, 0xB0, 0x54, 0x6D, 0x07, 0x01, 0xEA,
-    0x23, 0x59, 0x8E, 0x5A, 0x2B, 0x7A, 0xF0, 0xD5, 0xA0, 0x4B, 0x85, 0x41,
-    0x77, 0x3B, 0x53, 0x29, 0xA3, 0xCE, 0x00, 0xAB, 0xF7, 0xFA, 0xE0, 0xCA,
-    0x97, 0xD7, 0x87, 0x69, 0x16, 0xEC, 0x8D, 0xF7, 0x6F, 0xDF, 0xE3, 0xF8,
-    0xB8, 0xB8, 0xA8, 0xAC, 0x69, 0x93, 0x40, 0xC7, 0xF2, 0xF2, 0x68, 0xBC,
-    0xF7, 0xA7, 0x13, 0xAB, 0x4E, 0x00, 0x83, 0x5B, 0x33, 0x74, 0xBC, 0x62,
-    0xA3, 0x28, 0xB6, 0x06, 0x45, 0x01, 0xC7, 0x46, 0x87, 0x67, 0x14, 0x52,
-    0xC2, 0x30, 0x17, 0x82, 0xB0, 0x70, 0x51, 0x2B, 0xB7, 0xB6, 0xD0, 0xB3,
-    0x9E, 0xD2, 0x39, 0x11, 0x21, 0x61, 0x52, 0x29, 0xD7, 0x2C, 0x2A, 0x57,
-    0x6B, 0xBD, 0x29, 0x54, 0x4F, 0xD7, 0x09, 0x9B, 0x17, 0x6B, 0x48, 0x53,
-    0x0C, 0xFB, 0xBD, 0x51, 0xEB, 0xAB, 0xB4, 0xAE, 0x6E, 0xDE, 0xA9, 0x3C,
-    0x9F, 0xD3, 0x72, 0xAB, 0x07, 0xBD, 0xF8, 0x4D, 0xD7, 0x6B, 0xBD, 0xE8,
-    0x29, 0x65, 0x79, 0xE6, 0x78, 0x9B, 0xBD, 0xC8, 0x05, 0x11, 0xDC, 0xF1,
-    0x5E, 0x9A, 0x5C, 0xB7, 0x3B, 0x36, 0x20, 0xB5, 0xEF, 0x8D, 0x13, 0x5D,
-    0xA0, 0xBE, 0xC1, 0x96, 0x81, 0xE3, 0xFD, 0xF9, 0xF4, 0x15, 0xCE, 0x8A,
-    0x0E, 0xC3, 0x2C, 0xA2, 0x34, 0x34, 0xE3, 0xE5, 0x02, 0x8E, 0x88, 0xF3,
-    0xD3, 0xDE, 0xA2, 0xB6, 0xE9, 0xA6, 0xC4, 0xD5, 0xBB, 0x2D, 0x9F, 0x86,
-    0xC5, 0x9C, 0x5C, 0xE2, 0xB0, 0x3C, 0xFA, 0xEA, 0xA5, 0xAA, 0xE5, 0x2F,
-    0xE0, 0x13, 0x27, 0x42, 0x13, 0xF0, 0xC2, 0x6D, 0x33, 0xEB, 0x34, 0x65,
-    0x94, 0xB3, 0x07, 0xD3, 0xBB, 0x3C, 0x17, 0x94, 0x08, 0x14, 0xC8, 0xC8,
-    0x9A, 0x1F, 0x45, 0xF0, 0x69, 0x81, 0x26, 0xF4, 0x11, 0xC2, 0x21, 0x7C,
-    0x35, 0x91, 0xDB, 0x15, 0x84, 0x91, 0xC0, 0x53, 0x78, 0x60, 0x1E, 0x26,
-    0x9C, 0xC5, 0x98, 0x5A, 0xD3, 0xC7, 0xBC, 0xC8, 0xAF, 0x31, 0x3A, 0xE0,
-    0x32, 0xA6, 0x61, 0x39, 0xC7, 0xE6, 0xBB, 0xD7, 0xC8, 0x5F, 0x45, 0x85,
-    0x91, 0xC3, 0x98, 0xD7, 0xD4, 0xD3, 0x15, 0x7F, 0x0A, 0xCC, 0x59, 0x39,
-    0x19, 0x7A, 0xB3, 0x82, 0x04, 0x6F, 0xFA, 0xC7, 0x49, 0xFE, 0x22, 0x67,
-    0xB3, 0x2B, 0xBE, 0xE4, 0xA9, 0xE6, 0xDC, 0xFB, 0x3D, 0x2B, 0xA3, 0xEA,
-    0x73, 0x16, 0x96, 0xFF, 0x00, 0x29, 0x27, 0xAF, 0x17,
-};
-const uint8_t g_frFR_Locale[] = {
-    0x78, 0x9C, 0x95, 0x56, 0x4D, 0x6F, 0xD3, 0x40, 0x10, 0xBD, 0x23, 0xF1,
-    0x1F, 0x56, 0x16, 0x55, 0x41, 0x6A, 0xBD, 0x70, 0x4C, 0x95, 0x5A, 0xAA,
-    0xFA, 0x15, 0x28, 0x46, 0x51, 0x53, 0x40, 0xF4, 0x82, 0x36, 0xF6, 0x36,
-    0xDE, 0xD4, 0xDE, 0x8D, 0xD6, 0x76, 0x4A, 0x7C, 0xE4, 0x3F, 0x70, 0xE2,
-    0xC2, 0xB5, 0x12, 0x88, 0x03, 0x47, 0xC4, 0x85, 0xFE, 0x13, 0x24, 0x10,
-    0x3F, 0x83, 0x71, 0xBC, 0x76, 0xED, 0x5D, 0x27, 0xB8, 0xBE, 0x64, 0xE7,
-    0xCD, 0x7B, 0xE3, 0x99, 0xB7, 0xF6, 0xC6, 0xFD, 0x50, 0x78, 0x24, 0xA4,
-    0x88, 0x93, 0x88, 0xEE, 0x5A, 0x17, 0xF2, 0xED, 0xD1, 0xA9, 0x85, 0x7C,
-    0x1A, 0x7B, 0xBB, 0xD6, 0x9F, 0x6F, 0x1F, 0xFE, 0x7E, 0xFD, 0xF2, 0x10,
-    0x7E, 0x7E, 0x7F, 0xFC, 0xF1, 0xC8, 0x72, 0xFA, 0x39, 0x91, 0xFB, 0x44,
-    0x8E, 0x16, 0xD1, 0x58, 0x84, 0xB1, 0xD2, 0x4C, 0x24, 0x9D, 0x08, 0xC9,
-    0x08, 0x07, 0x46, 0x24, 0x78, 0x12, 0xBC, 0x00, 0x38, 0x56, 0x6B, 0x67,
-    0x4A, 0xF8, 0x9C, 0x51, 0xD9, 0xC7, 0x45, 0x78, 0xFF, 0x9E, 0xC2, 0x2F,
-    0x6E, 0xAE, 0xE7, 0xB2, 0x2D, 0x11, 0x11, 0x19, 0x1B, 0x20, 0x01, 0x6E,
-    0xD8, 0x42, 0x65, 0x06, 0x36, 0x4D, 0x19, 0x6F, 0x03, 0xC3, 0x90, 0x26,
-    0x66, 0x59, 0x71, 0xF3, 0xDD, 0x44, 0x63, 0x3A, 0x4B, 0x68, 0x34, 0x96,
-    0xD4, 0xC8, 0x08, 0x2F, 0x11, 0x6D, 0x38, 0x17, 0xF3, 0x76, 0x81, 0x7F,
-    0x73, 0xED, 0xE9, 0x19, 0x5C, 0x33, 0xA9, 0x24, 0x2E, 0x23, 0x44, 0xC6,
-    0x63, 0xB9, 0x6B, 0x3D, 0xB1, 0xEA, 0xDE, 0xD9, 0xED, 0xCE, 0x99, 0xF0,
-    0x2A, 0xDF, 0xDA, 0x98, 0x77, 0xB0, 0xCD, 0x94, 0xAF, 0x36, 0xCD, 0xE4,
-    0x82, 0x61, 0x26, 0x08, 0x6E, 0x99, 0x60, 0xEE, 0x94, 0xBD, 0xDA, 0x25,
-    0x9F, 0x2C, 0xD4, 0x63, 0x05, 0x2B, 0xC7, 0x67, 0x11, 0xE1, 0x5E, 0x00,
-    0xAE, 0xE6, 0x51, 0x91, 0x76, 0xC2, 0x94, 0xFB, 0xAC, 0x81, 0x80, 0x25,
-    0x3A, 0x42, 0xA5, 0x27, 0xA9, 0x06, 0x4E, 0x69, 0xAA, 0x21, 0x73, 0x78,
-    0xCC, 0x0D, 0x5A, 0x0C, 0xF7, 0xAF, 0x41, 0xB8, 0x6A, 0xA9, 0xD6, 0x5E,
-    0x6D, 0x0B, 0x55, 0x9F, 0xB6, 0xDE, 0xA3, 0xAD, 0xB7, 0x68, 0xEB, 0x1D,
-    0xDA, 0x7A, 0x77, 0xB6, 0xDE, 0x9C, 0xAD, 0x37, 0x66, 0xB7, 0xB7, 0x05,
-    0xC5, 0x98, 0xCF, 0x68, 0x54, 0xBE, 0x91, 0x2A, 0x74, 0xF6, 0x5C, 0xF0,
-    0xB7, 0x0C, 0x6A, 0x3C, 0x67, 0xA8, 0x25, 0x70, 0xB3, 0x02, 0x20, 0x54,
-    0x12, 0x55, 0x0D, 0x56, 0xF0, 0x7C, 0xD9, 0xE8, 0x99, 0xBD, 0xBD, 0x0F,
-    0xF7, 0xCF, 0xC3, 0x22, 0xEF, 0x90, 0x99, 0x8E, 0xE2, 0x4A, 0x96, 0x07,
-    0xDA, 0x39, 0x52, 0xCC, 0x91, 0xD0, 0x21, 0x49, 0x12, 0x2A, 0xF9, 0x72,
-    0x8F, 0xAB, 0xA8, 0x3C, 0x98, 0xD2, 0x30, 0xB4, 0x9C, 0x43, 0xB8, 0xD0,
-    0x01, 0x72, 0xE1, 0x42, 0x6F, 0xE0, 0xCA, 0xA7, 0xAD, 0x98, 0x5A, 0x19,
-    0x25, 0x0C, 0x05, 0x9F, 0x58, 0xCE, 0xDD, 0x34, 0xB0, 0xCF, 0x4A, 0x82,
-    0x3A, 0xF1, 0xE3, 0x40, 0xC8, 0x04, 0x14, 0x07, 0xD8, 0x75, 0x71, 0x8B,
-    0x02, 0x37, 0xA6, 0x03, 0x20, 0x61, 0x51, 0x6D, 0xDA, 0x5A, 0xD4, 0x98,
-    0x76, 0x30, 0xD8, 0x44, 0x01, 0xDA, 0x84, 0x2E, 0xCE, 0xFB, 0xB8, 0x46,
-    0xD2, 0x2A, 0x34, 0x06, 0x1D, 0x0C, 0x76, 0x5C, 0x77, 0x67, 0x34, 0xEA,
-    0x24, 0x59, 0xCE, 0x59, 0x2A, 0x3A, 0xF0, 0xD5, 0x9C, 0x4B, 0x85, 0x41,
-    0xC7, 0x8D, 0xA1, 0x94, 0x4F, 0x67, 0x80, 0x95, 0xBB, 0x7C, 0x4C, 0xDC,
-    0xE9, 0xE5, 0x20, 0x8A, 0x47, 0x87, 0x07, 0x47, 0x57, 0xAF, 0xDF, 0x05,
-    0x27, 0xD9, 0x79, 0xE1, 0x4C, 0x9D, 0x04, 0x3A, 0x9E, 0x46, 0x63, 0x2A,
-    0x6F, 0xED, 0x69, 0xC4, 0xAA, 0x13, 0xC0, 0xE0, 0xC1, 0xF4, 0x2C, 0x27,
-    0xDB, 0xCA, 0xB2, 0x9E, 0x9D, 0x65, 0x59, 0x1F, 0x37, 0x78, 0x46, 0x21,
-    0x25, 0xF4, 0x52, 0x29, 0x29, 0xF7, 0x16, 0xA5, 0xB2, 0xD7, 0x43, 0x0F,
-    0x3A, 0x4A, 0x67, 0x70, 0x76, 0x50, 0x9E, 0x28, 0xE5, 0x46, 0x8B, 0x0A,
-    0x6B, 0xAD, 0x57, 0x85, 0xCA, 0xE9, 0x1A, 0xA1, 0x2A, 0xEB, 0x53, 0x0F,
-    0x4E, 0x33, 0xD8, 0xEE, 0xAD, 0x52, 0x5F, 0xA4, 0x75, 0x75, 0xF5, 0x6F,
-    0x2B, 0xD2, 0x19, 0xCB, 0xB7, 0xFA, 0xE7, 0xA7, 0x4E, 0x82, 0xAA, 0xED,
-    0x8D, 0x4E, 0xF4, 0x88, 0xF1, 0x34, 0xB6, 0x9C, 0xED, 0x4E, 0xE4, 0x8C,
-    0x4A, 0x61, 0x39, 0x8F, 0x4D, 0x2E, 0x6E, 0xCE, 0x0D, 0x48, 0x69, 0x7C,
-    0x65, 0x45, 0x13, 0x28, 0x9F, 0xB0, 0x65, 0x60, 0x39, 0xBF, 0xDE, 0x7F,
-    0x86, 0x63, 0xA2, 0xC1, 0x30, 0x8B, 0x28, 0x0D, 0x8B, 0x45, 0xBE, 0x80,
-    0xD3, 0xE1, 0xE5, 0x69, 0x67, 0x51, 0xDD, 0x75, 0x53, 0x82, 0xF5, 0x6E,
-    0xF3, 0xD7, 0x61, 0x31, 0xA3, 0x17, 0xC4, 0xCB, 0x4F, 0xBE, 0x72, 0xA9,
-    0x6A, 0xB9, 0x0B, 0xF8, 0xFA, 0xF1, 0xD1, 0x10, 0xBC, 0xC0, 0x75, 0x66,
-    0x99, 0x66, 0x9C, 0x09, 0xBE, 0x32, 0xBD, 0x2F, 0xD2, 0xFC, 0x3B, 0x08,
-    0x8D, 0x12, 0xBF, 0x35, 0xBF, 0xE7, 0x8B, 0x31, 0x45, 0x43, 0xF6, 0x1F,
-    0xC2, 0x80, 0xC2, 0x57, 0xC6, 0xD5, 0x1A, 0xC2, 0x9E, 0x24, 0x63, 0x78,
-    0x63, 0x56, 0x13, 0xCE, 0x02, 0xC2, 0x5A, 0xD3, 0x27, 0x22, 0x4B, 0x2F,
-    0x09, 0x3A, 0x16, 0x49, 0xC0, 0xBC, 0x7C, 0x8E, 0xED, 0x57, 0x4F, 0x91,
-    0xBB, 0x8E, 0x0A, 0x23, 0x7B, 0x81, 0x28, 0xA9, 0xA7, 0x6B, 0x6E, 0x0A,
-    0xCC, 0x49, 0x3E, 0x19, 0x7A, 0xBE, 0x86, 0x34, 0x12, 0x1D, 0x48, 0xEE,
-    0x22, 0xE5, 0x93, 0xA9, 0x58, 0xF2, 0x54, 0x73, 0xF8, 0x76, 0xCF, 0xF2,
-    0xA8, 0xF8, 0xD2, 0x85, 0xE5, 0x3F, 0x5D, 0x49, 0xBE, 0x1B};
-const uint8_t g_itIT_Locale[] = {
-    0x78, 0x9C, 0x95, 0x56, 0xD1, 0x6A, 0xD4, 0x40, 0x14, 0x7D, 0x17, 0xFC,
-    0x87, 0x21, 0x58, 0x50, 0x68, 0x3B, 0xFA, 0xD8, 0x92, 0x06, 0x4A, 0x5B,
-    0xBB, 0xA5, 0x46, 0x96, 0xEE, 0xAA, 0xD8, 0x17, 0x99, 0x64, 0xA6, 0xD9,
-    0xB1, 0xC9, 0xCC, 0x32, 0x49, 0x5A, 0x92, 0x47, 0xF1, 0xC1, 0x37, 0x7F,
-    0x42, 0x10, 0x41, 0xF1, 0x23, 0xFC, 0x13, 0xA1, 0xE2, 0x67, 0x78, 0xB3,
-    0x99, 0xA4, 0xC9, 0x64, 0xBA, 0xA6, 0x79, 0xD9, 0xB9, 0xE7, 0x9E, 0x73,
-    0x73, 0xEF, 0x99, 0x64, 0x36, 0x6E, 0x2C, 0x43, 0x12, 0x33, 0x24, 0x48,
-    0xC2, 0xF6, 0x1C, 0x9E, 0xBD, 0x3B, 0x99, 0x3B, 0x88, 0xB2, 0x34, 0xDC,
-    0x73, 0xFE, 0x7C, 0xFC, 0x7C, 0xF3, 0xE5, 0xEB, 0xCD, 0xA7, 0x6F, 0x7F,
-    0x7F, 0xFE, 0x78, 0xDC, 0x06, 0x4F, 0x1C, 0xCF, 0xAD, 0x14, 0x82, 0x12,
-    0x35, 0x2B, 0x92, 0x40, 0xC6, 0xA9, 0x16, 0x47, 0x8A, 0x45, 0x52, 0x71,
-    0x22, 0x80, 0x91, 0x48, 0x91, 0x2D, 0x5E, 0x02, 0x9C, 0xEA, 0xB5, 0x17,
-    0x31, 0x21, 0x08, 0x97, 0x2E, 0xAE, 0xC3, 0x87, 0x0F, 0x34, 0x7E, 0xC1,
-    0x82, 0x40, 0xD9, 0x12, 0x09, 0x51, 0xE5, 0x10, 0x25, 0x4B, 0xC5, 0x63,
-    0x66, 0x21, 0x47, 0x91, 0xA5, 0x46, 0xC4, 0xF3, 0x48, 0x0C, 0xE1, 0x38,
-    0x8F, 0x62, 0x0B, 0x9B, 0x44, 0x32, 0xCD, 0x86, 0x70, 0xCA, 0xB2, 0x8C,
-    0x25, 0x81, 0x1A, 0xDE, 0x55, 0x66, 0x99, 0xB4, 0xE1, 0x42, 0x5E, 0xD9,
-    0x05, 0x94, 0x87, 0x66, 0x02, 0x77, 0xAC, 0x6A, 0x78, 0xAB, 0x08, 0x11,
-    0x30, 0x66, 0xCF, 0x79, 0xE6, 0x74, 0x1C, 0xB4, 0xB9, 0x67, 0x33, 0xCE,
-    0x66, 0x9B, 0xCD, 0x33, 0x9B, 0x61, 0x36, 0xB7, 0x6C, 0x56, 0xD9, 0x7C,
-    0xB2, 0x39, 0x64, 0x73, 0xC7, 0x66, 0xCC, 0xDD, 0x9E, 0x50, 0x52, 0xE8,
-    0x47, 0x09, 0x56, 0x1E, 0x95, 0x09, 0x13, 0x3C, 0x24, 0x2E, 0xAE, 0xA2,
-    0x3A, 0x0D, 0x3D, 0x0A, 0x46, 0x7F, 0x7D, 0xEF, 0x61, 0xE0, 0x43, 0x36,
-    0x04, 0x99, 0x0A, 0x65, 0x3C, 0x80, 0xE1, 0xE1, 0xB9, 0x1A, 0x80, 0x57,
-    0x4C, 0x30, 0x65, 0x82, 0x29, 0x09, 0x48, 0xF5, 0x90, 0x68, 0x08, 0xB7,
-    0xCD, 0x75, 0x1A, 0xED, 0x6C, 0x9D, 0xEE, 0xD8, 0x6C, 0xD6, 0x6C, 0xD4,
-    0xEC, 0xD1, 0x6C, 0xCE, 0xEC, 0xCB, 0x6C, 0xC9, 0xDE, 0x0F, 0x14, 0xE2,
-    0x94, 0xB3, 0xA4, 0x79, 0x11, 0x75, 0xE8, 0xED, 0xFB, 0x60, 0x71, 0x13,
-    0x74, 0x78, 0xDE, 0xD4, 0x48, 0xE0, 0x7E, 0x05, 0x40, 0x98, 0x22, 0xBA,
-    0x1A, 0xAC, 0x3C, 0x72, 0xE0, 0xE2, 0xEA, 0xB7, 0x4E, 0x78, 0xF4, 0x36,
-    0xC4, 0x2D, 0xB1, 0x0A, 0x8C, 0x03, 0xA3, 0x6E, 0x3C, 0x63, 0x53, 0x02,
-    0x6F, 0x96, 0x12, 0xAB, 0x8D, 0x6D, 0x23, 0x7D, 0x9A, 0x5C, 0xE4, 0x71,
-    0xEC, 0x78, 0x47, 0x70, 0xA1, 0x43, 0xE4, 0xC3, 0x85, 0xDE, 0xC2, 0x55,
-    0xCD, 0xD7, 0x32, 0x8D, 0x32, 0x5A, 0x18, 0x4B, 0x11, 0x39, 0xDE, 0xE1,
-    0xFD, 0x44, 0x09, 0xA3, 0x95, 0x06, 0x83, 0x04, 0x8F, 0x12, 0xA4, 0x0B,
-    0xA9, 0x32, 0x2D, 0xB1, 0x29, 0x70, 0x6F, 0x3E, 0x00, 0x32, 0x9E, 0x74,
-    0xE6, 0xED, 0x44, 0xBD, 0x79, 0x27, 0x93, 0x5D, 0xDF, 0xDF, 0x9D, 0xCD,
-    0xD0, 0xB9, 0x8B, 0x3B, 0x1C, 0xA3, 0x40, 0x6F, 0xD2, 0xFB, 0x28, 0x56,
-    0x63, 0x36, 0xF7, 0x18, 0xC1, 0xD7, 0x53, 0xAE, 0x14, 0x03, 0x3A, 0xEE,
-    0x8D, 0xA4, 0x5D, 0x9A, 0x03, 0xD6, 0xEC, 0xF2, 0x71, 0xE1, 0xD3, 0xCB,
-    0x49, 0x92, 0xCE, 0x8E, 0x0E, 0x9F, 0x5F, 0xBF, 0x21, 0x8B, 0xD3, 0xF2,
-    0xBC, 0xF6, 0xA5, 0x4B, 0x02, 0x9D, 0xC8, 0x93, 0x80, 0xA9, 0x5B, 0x73,
-    0x7A, 0xB1, 0xEE, 0x04, 0x30, 0x78, 0x14, 0x43, 0xC7, 0x2B, 0x37, 0xCB,
-    0x72, 0x67, 0xBB, 0x2C, 0x4B, 0x17, 0xF7, 0x78, 0x83, 0x42, 0x5A, 0x18,
-    0xE6, 0x4A, 0x31, 0x11, 0x16, 0x8E, 0xF7, 0x08, 0xD5, 0xDA, 0x9D, 0x9D,
-    0x91, 0xD2, 0x25, 0x9C, 0x15, 0x4C, 0x64, 0xFA, 0x9E, 0x1B, 0x16, 0x15,
-    0x36, 0x5A, 0x6F, 0x0B, 0x35, 0xD3, 0xF5, 0x42, 0x5D, 0x96, 0xB2, 0x90,
-    0x27, 0x04, 0x36, 0x7B, 0xB3, 0xD1, 0xD7, 0x69, 0x53, 0xDD, 0xFE, 0xAD,
-    0xCA, 0x7C, 0xC9, 0xAB, 0x9D, 0xDE, 0x1E, 0xC5, 0x6F, 0xBB, 0xDE, 0x18,
-    0x45, 0x4F, 0xB8, 0xC8, 0x53, 0xC7, 0xDB, 0x1A, 0x45, 0x2E, 0x99, 0x92,
-    0x8E, 0xF7, 0x74, 0xC8, 0xC5, 0xFD, 0xB1, 0x01, 0x69, 0x7C, 0x6F, 0x9D,
-    0xE8, 0x03, 0xCD, 0x03, 0xB6, 0x0A, 0x1C, 0xEF, 0xF7, 0x07, 0x38, 0x65,
-    0xFB, 0x8C, 0x61, 0x91, 0xE6, 0x23, 0x25, 0x95, 0xD5, 0x02, 0x0E, 0x87,
-    0x57, 0x67, 0xA3, 0x45, 0x5D, 0xD3, 0x87, 0x12, 0x6C, 0x76, 0x5B, 0xBD,
-    0x0D, 0xC5, 0x92, 0x5D, 0x90, 0xB0, 0x3A, 0xEA, 0x9A, 0xA5, 0xAE, 0xE5,
-    0x17, 0xF0, 0x95, 0x43, 0xD1, 0x14, 0xBC, 0xC0, 0x5D, 0x66, 0x93, 0xE6,
-    0x82, 0x4B, 0x71, 0x67, 0xFA, 0x40, 0xE6, 0x8A, 0x33, 0x85, 0x66, 0x19,
-    0xB5, 0xE6, 0xF7, 0xA9, 0x0C, 0x18, 0x9A, 0xF2, 0xFF, 0x10, 0x26, 0x0C,
-    0xBE, 0x23, 0xAE, 0xD7, 0x10, 0xF6, 0x15, 0x09, 0xE0, 0x85, 0xB9, 0x9B,
-    0x30, 0x5F, 0x10, 0x6E, 0x4D, 0x9F, 0xCA, 0x32, 0xBF, 0x24, 0xE8, 0x58,
-    0x66, 0x0B, 0x1E, 0x56, 0x73, 0x6C, 0xBD, 0x3E, 0x41, 0xFE, 0x3A, 0x2A,
-    0x8C, 0x1C, 0x2E, 0x64, 0x43, 0x3D, 0x5B, 0x73, 0x53, 0x60, 0x46, 0xD5,
-    0x64, 0xE8, 0xC5, 0x1A, 0xD2, 0x4C, 0x8E, 0x20, 0xF9, 0x45, 0x2E, 0xA2,
-    0xF7, 0x72, 0xC5, 0xD3, 0xCD, 0xE1, 0xDB, 0x3D, 0xAB, 0xA2, 0xFA, 0xD3,
-    0x16, 0x96, 0xFF, 0x00, 0x20, 0x8B, 0xBE, 0xF7};
-const uint8_t g_ptBR_Locale[] = {
-    0x78, 0x9C, 0x9D, 0x56, 0x3D, 0x6F, 0xD4, 0x40, 0x10, 0xAD, 0x83, 0xC4,
-    0x7F, 0x58, 0x59, 0x89, 0x0E, 0xA4, 0x24, 0x86, 0x92, 0xC8, 0x67, 0xE9,
-    0x92, 0x0B, 0x39, 0x94, 0x18, 0x9D, 0xCE, 0x11, 0x88, 0x34, 0x68, 0x6D,
-    0xEF, 0xD9, 0x9B, 0xD8, 0xBB, 0xC7, 0xDA, 0x4E, 0xB0, 0x6B, 0x1A, 0x3A,
-    0x28, 0x29, 0x53, 0x20, 0x2A, 0x44, 0x83, 0x44, 0x49, 0x91, 0xDF, 0x82,
-    0xB8, 0x9F, 0xC1, 0xFA, 0xF3, 0xFC, 0xB1, 0x36, 0x06, 0x37, 0xDE, 0x99,
-    0x79, 0x6F, 0x3D, 0xF3, 0x76, 0x76, 0x64, 0xC5, 0xA5, 0x26, 0x74, 0x11,
-    0x20, 0xD0, 0x43, 0x63, 0x69, 0x15, 0xBC, 0x3E, 0x5C, 0x48, 0xC0, 0x42,
-    0xBE, 0x39, 0x96, 0xD6, 0x1F, 0x6F, 0xD7, 0x1F, 0xDE, 0xFD, 0x7E, 0xFF,
-    0x69, 0xFD, 0xED, 0xEB, 0x83, 0x5F, 0x3F, 0xBE, 0xAF, 0x3F, 0xFF, 0x7C,
-    0x28, 0xA9, 0xF7, 0xEF, 0x01, 0xA0, 0x24, 0x14, 0x62, 0x41, 0xA6, 0x47,
-    0x9E, 0x41, 0x5D, 0x3F, 0x67, 0xDB, 0x0C, 0xD9, 0x94, 0x61, 0x48, 0x12,
-    0xD4, 0x16, 0x50, 0x3C, 0x4A, 0x02, 0xE7, 0x39, 0x0F, 0xF9, 0x89, 0xBD,
-    0x95, 0xD9, 0xEA, 0x25, 0x24, 0x08, 0x33, 0xAA, 0xC8, 0x99, 0x59, 0x89,
-    0x2C, 0xD1, 0x35, 0x62, 0x1D, 0x31, 0x0F, 0xB2, 0xBB, 0x2F, 0xA2, 0x00,
-    0x34, 0x18, 0x76, 0x85, 0x04, 0x2C, 0x82, 0x5F, 0x86, 0xC4, 0x11, 0xFB,
-    0x5D, 0xA1, 0x1F, 0xDA, 0xD4, 0x0F, 0x44, 0x01, 0x1F, 0x05, 0xC8, 0x33,
-    0x84, 0xB9, 0xD2, 0x30, 0x08, 0xC5, 0x11, 0x42, 0xAF, 0xBB, 0x48, 0x16,
-    0x8A, 0x9B, 0x21, 0x90, 0xAF, 0x4B, 0x09, 0xAB, 0x92, 0x02, 0x68, 0x18,
-    0x6C, 0x2C, 0x3D, 0x96, 0x1A, 0xDA, 0x8A, 0x75, 0x15, 0x2B, 0x2A, 0x96,
-    0x53, 0x2C, 0xA6, 0x58, 0x4B, 0xB1, 0x92, 0x62, 0x1D, 0xC5, 0x22, 0x8A,
-    0xF5, 0x13, 0x6B, 0x27, 0x96, 0xAD, 0x5F, 0x31, 0x0B, 0x46, 0x95, 0x16,
-    0xE4, 0x96, 0x6A, 0x51, 0x0F, 0x93, 0x24, 0x9D, 0xC4, 0x28, 0xBD, 0x3E,
-    0xB2, 0x43, 0xDE, 0xD2, 0x7B, 0x4B, 0xDE, 0x80, 0xB0, 0x11, 0x0B, 0x10,
-    0x6F, 0x3E, 0x71, 0xE8, 0x4D, 0x08, 0x59, 0xD0, 0x15, 0xC2, 0xA4, 0x23,
-    0xE4, 0xA3, 0xB7, 0x5D, 0x91, 0xBB, 0x5B, 0x03, 0x5A, 0x9B, 0xE4, 0x40,
-    0xBA, 0x12, 0xD4, 0xD3, 0x38, 0xFF, 0xBC, 0xB0, 0x76, 0x51, 0xED, 0x52,
-    0xDA, 0x15, 0xB4, 0x13, 0x6F, 0xE7, 0x2B, 0xC8, 0xB3, 0x3B, 0x49, 0x0F,
-    0x31, 0x6C, 0x61, 0xE4, 0x55, 0x2F, 0x7F, 0xEE, 0x52, 0x27, 0x1A, 0x3F,
-    0xA4, 0xC2, 0xA8, 0x87, 0xE6, 0x8D, 0x10, 0xD8, 0x98, 0x95, 0xCD, 0x11,
-    0x83, 0x95, 0x7D, 0xB9, 0xA5, 0x1E, 0x1E, 0x29, 0x72, 0xF2, 0x2E, 0x1D,
-    0x93, 0x69, 0xE9, 0x00, 0xE9, 0xAA, 0x20, 0xF0, 0xD9, 0x25, 0x37, 0x86,
-    0x57, 0xE6, 0xB5, 0x60, 0x80, 0xE6, 0x30, 0xE0, 0xF2, 0x90, 0x52, 0xE8,
-    0xD2, 0x93, 0xCF, 0xB7, 0x65, 0xE8, 0xBA, 0x92, 0x7A, 0xCC, 0x9F, 0x5D,
-    0x30, 0x1D, 0xF1, 0x29, 0x09, 0x46, 0x1A, 0x7F, 0xB2, 0xD5, 0x2B, 0xFE,
-    0x24, 0x32, 0x94, 0xA4, 0xAE, 0x5D, 0x5C, 0x4A, 0x6C, 0x49, 0xFD, 0x7F,
-    0xBE, 0x87, 0x2C, 0x4E, 0x9F, 0xCA, 0x9A, 0x26, 0x0F, 0xE6, 0xF8, 0x0E,
-    0x65, 0xC1, 0x86, 0xD5, 0xE4, 0x00, 0x50, 0xF3, 0xE4, 0x92, 0x04, 0xD8,
-    0x6B, 0x48, 0x52, 0xF1, 0xD4, 0x24, 0x99, 0xCD, 0x46, 0x0E, 0x2F, 0x65,
-    0xC4, 0xEF, 0xD5, 0x48, 0xD7, 0x47, 0xFE, 0x08, 0x5C, 0x28, 0x72, 0x05,
-    0xDC, 0xC5, 0xCE, 0xA4, 0x48, 0xC9, 0x19, 0x77, 0x38, 0x35, 0x55, 0x61,
-    0x36, 0x3B, 0xD0, 0xB4, 0x03, 0x5D, 0x1F, 0xC4, 0xC8, 0x35, 0x48, 0x39,
-    0x4D, 0x42, 0x22, 0x40, 0xA3, 0xDC, 0xBC, 0x27, 0xCE, 0xB9, 0xB7, 0x68,
-    0x94, 0x93, 0x48, 0xB3, 0xAE, 0x66, 0x9E, 0xAF, 0x1F, 0x4F, 0x9F, 0xDE,
-    0xBC, 0x84, 0xCE, 0x69, 0x7C, 0x91, 0xE9, 0x56, 0x05, 0xA5, 0x4C, 0x12,
-    0x7A, 0x06, 0x62, 0x75, 0xF1, 0x6A, 0xBE, 0x3C, 0x27, 0xEE, 0xE3, 0xFD,
-    0x6D, 0x4A, 0x6A, 0xBC, 0x1B, 0xC7, 0x4F, 0xF6, 0xE3, 0x98, 0x0F, 0xB3,
-    0x1A, 0xAE, 0x9B, 0x6A, 0x86, 0x8C, 0x21, 0x62, 0x46, 0x92, 0xBA, 0x0D,
-    0x0A, 0xF6, 0x60, 0xF2, 0x0A, 0x31, 0x13, 0x91, 0x20, 0xFF, 0xEE, 0x4E,
-    0x9B, 0x97, 0x08, 0xD2, 0x2A, 0xA2, 0x2C, 0x6C, 0x53, 0xEB, 0x56, 0xDD,
-    0x95, 0x6F, 0x6F, 0x21, 0x13, 0x7B, 0x90, 0x37, 0xC6, 0x6E, 0xB1, 0x4B,
-    0x16, 0xEE, 0x24, 0xD8, 0x8C, 0x86, 0x2B, 0x9C, 0x34, 0xC3, 0xFE, 0x40,
-    0x46, 0x59, 0xC1, 0xCE, 0x40, 0x02, 0xEF, 0xAF, 0xD0, 0x97, 0xD4, 0xBD,
-    0x81, 0xF0, 0x18, 0x31, 0x2A, 0xA9, 0x8F, 0x5A, 0xE8, 0x8D, 0x30, 0xB5,
-    0x03, 0x2F, 0x4E, 0xA3, 0xA6, 0x4C, 0xDD, 0x59, 0xB4, 0x61, 0x6A, 0x48,
-    0xEA, 0x62, 0x9B, 0x4F, 0xA2, 0x1A, 0xA0, 0x87, 0x84, 0x7D, 0x9A, 0x2C,
-    0x24, 0xF5, 0x70, 0x71, 0xF6, 0x0F, 0xB4, 0xEA, 0x39, 0xB4, 0x48, 0xE9,
-    0x28, 0x6C, 0xA5, 0x9D, 0xDC, 0xFB, 0x68, 0x85, 0x96, 0xD0, 0x2C, 0xC6,
-    0x6D, 0x61, 0xE6, 0x7B, 0x6A, 0x11, 0xFF, 0xC3, 0xB3, 0xC0, 0x9C, 0xCB,
-    0x23, 0x8B, 0x01, 0x98, 0x60, 0x4A, 0x7A, 0x00, 0x47, 0x34, 0x64, 0x18,
-    0x31, 0xA0, 0x07, 0x56, 0x07, 0x62, 0x62, 0x51, 0x03, 0x81, 0x39, 0xFE,
-    0x2B, 0x64, 0x86, 0x0C, 0x86, 0x6E, 0x7A, 0x21, 0x13, 0x06, 0x0D, 0x7E,
-    0xC3, 0xFA, 0x20, 0xE7, 0x0E, 0xC4, 0x1D, 0x80, 0x53, 0x1A, 0x87, 0x57,
-    0x10, 0x9C, 0xD0, 0xC0, 0xC1, 0x66, 0x52, 0xD3, 0xDE, 0x8B, 0x67, 0x40,
-    0xEB, 0x07, 0x73, 0x01, 0x4C, 0x87, 0x16, 0xE0, 0x45, 0xEF, 0xA7, 0x39,
-    0xD6, 0x4E, 0xAA, 0x04, 0x67, 0xBD, 0x30, 0x9D, 0x0E, 0x82, 0x69, 0x51,
-    0x48, 0xEC, 0x4B, 0x9A, 0x22, 0xB3, 0x24, 0xD3, 0xC1, 0x56, 0x39, 0x4F,
-    0x45, 0xCE, 0xFE, 0xF7, 0xD5, 0x3F, 0x30, 0xBB, 0xD9, 0x9B};
-const uint8_t g_nlNL_Locale[] = {
-    0x78, 0x9C, 0x95, 0x56, 0x4D, 0x4F, 0xDC, 0x30, 0x10, 0x3D, 0x53, 0xA9,
-    0xFF, 0xC1, 0x8A, 0x8A, 0x68, 0x25, 0x96, 0x2D, 0x47, 0x50, 0x88, 0xB4,
-    0x05, 0x0A, 0x15, 0x04, 0xAD, 0x58, 0xDA, 0xAA, 0x5C, 0x2A, 0x6F, 0x62,
-    0x76, 0xBD, 0x24, 0xF6, 0xCA, 0x89, 0x41, 0xC9, 0xB1, 0x52, 0x8F, 0xFD,
-    0x27, 0xAD, 0xDA, 0x5B, 0xFF, 0x4F, 0xA5, 0x4A, 0xFC, 0x8C, 0x8E, 0xF3,
-    0x45, 0x12, 0x3B, 0x69, 0xC8, 0x05, 0xCF, 0x9B, 0xF7, 0xBC, 0x33, 0xCF,
-    0xCE, 0x10, 0x3B, 0xE0, 0x1E, 0x0E, 0x08, 0x62, 0x38, 0x24, 0x07, 0x16,
-    0x0B, 0x3E, 0x5F, 0x9C, 0x5B, 0xC8, 0x27, 0x91, 0x77, 0x60, 0x3D, 0x7C,
-    0xFB, 0xFD, 0xF7, 0xEB, 0xAF, 0x87, 0x9F, 0x3F, 0x5E, 0xE6, 0xAB, 0x57,
-    0x96, 0xF3, 0xFC, 0x19, 0x42, 0xB6, 0xE2, 0x33, 0x1F, 0x8B, 0x59, 0x12,
-    0xCE, 0x79, 0x10, 0x15, 0xD2, 0x85, 0x20, 0x0B, 0x2E, 0x28, 0x66, 0x8A,
-    0xB5, 0x81, 0xEC, 0x90, 0xB3, 0x78, 0x79, 0x01, 0xA9, 0x48, 0xC5, 0x1B,
-    0x79, 0xEC, 0xAC, 0x30, 0x93, 0x58, 0x50, 0x7B, 0x9C, 0x87, 0xB5, 0xCC,
-    0x0D, 0x99, 0x8B, 0x8E, 0x54, 0x88, 0xB1, 0x88, 0x0D, 0x38, 0x5E, 0x0B,
-    0x1A, 0x98, 0xF8, 0xC4, 0xB4, 0xCB, 0x4A, 0x32, 0x33, 0x1C, 0x98, 0x60,
-    0x2C, 0x17, 0x32, 0x8A, 0x65, 0x64, 0x48, 0x45, 0x64, 0x1D, 0x93, 0x70,
-    0x4E, 0x84, 0x21, 0xC7, 0x6F, 0x63, 0x6E, 0xCE, 0x30, 0x7E, 0xD7, 0x25,
-    0xF2, 0x89, 0xD7, 0x4E, 0xA1, 0x62, 0x5D, 0x19, 0x58, 0x37, 0x14, 0xE1,
-    0xF9, 0x5C, 0x1C, 0x58, 0xBB, 0x56, 0xCB, 0x59, 0xB3, 0xAB, 0x26, 0x83,
-    0xBA, 0xEC, 0x7C, 0x8A, 0x99, 0x66, 0x2F, 0xCD, 0x56, 0x9A, 0x5D, 0x34,
-    0xFB, 0x67, 0xF6, 0xCE, 0x6C, 0x5B, 0xBF, 0x63, 0x3E, 0x4E, 0x6A, 0x17,
-    0x10, 0x22, 0x27, 0xE5, 0x70, 0x71, 0xA1, 0x1A, 0xB5, 0xAE, 0x40, 0xB8,
-    0x5E, 0x06, 0xD4, 0xA7, 0x2C, 0xD2, 0xD1, 0x7B, 0x4E, 0x4C, 0xB0, 0x0F,
-    0xFB, 0x12, 0xA1, 0xE3, 0x77, 0x82, 0xAE, 0x74, 0x34, 0xC5, 0x71, 0x93,
-    0x8C, 0xB2, 0x95, 0xA1, 0xF2, 0xD6, 0x49, 0xE7, 0x2D, 0x68, 0xE5, 0x6B,
-    0x95, 0x6B, 0x45, 0x6B, 0xE5, 0x6A, 0x75, 0x6A, 0x25, 0x76, 0x17, 0x17,
-    0x12, 0x41, 0x7D, 0x4A, 0xC2, 0xFA, 0xCB, 0x5D, 0x40, 0xCE, 0xC4, 0x85,
-    0x63, 0x28, 0x83, 0x66, 0x6A, 0xDA, 0x4A, 0xA1, 0xC7, 0xB0, 0xB6, 0x39,
-    0x11, 0xB8, 0xB6, 0x2F, 0x44, 0xCE, 0x9B, 0x43, 0x7B, 0xAC, 0xFE, 0x56,
-    0xC0, 0xE4, 0xA8, 0x02, 0x50, 0xB6, 0x2A, 0x05, 0x30, 0x9B, 0xC6, 0xAD,
-    0xE1, 0x94, 0xA3, 0x3E, 0x18, 0x3E, 0xC5, 0x31, 0xB8, 0xCE, 0x2A, 0x83,
-    0x2B, 0xA4, 0x98, 0x5F, 0x37, 0x32, 0x08, 0x2C, 0xE7, 0x18, 0x1E, 0x74,
-    0x84, 0x5C, 0x78, 0xD0, 0x27, 0x78, 0x54, 0xEF, 0x15, 0xB3, 0x4B, 0x1A,
-    0x70, 0xB6, 0xB0, 0x9C, 0xA7, 0xAA, 0x42, 0xE2, 0x83, 0x68, 0x04, 0x9A,
-    0xD1, 0x60, 0x4D, 0xB4, 0xE4, 0x22, 0xCE, 0x54, 0x23, 0x5D, 0x81, 0x50,
-    0x03, 0x29, 0x7A, 0x8F, 0x69, 0xD8, 0xEA, 0xBD, 0x86, 0x34, 0x7A, 0x3F,
-    0xDD, 0x77, 0xDD, 0xFD, 0xD9, 0x6C, 0x0B, 0x49, 0x29, 0xB6, 0xD0, 0xB5,
-    0x3D, 0xAE, 0x11, 0xBB, 0x94, 0x79, 0xEB, 0x85, 0x72, 0xA0, 0x26, 0x6B,
-    0xBC, 0x90, 0x0C, 0x12, 0x14, 0x5D, 0x2B, 0x49, 0x9B, 0xAF, 0x7A, 0x6E,
-    0x75, 0x58, 0x9C, 0xF7, 0x15, 0xA0, 0xE5, 0x25, 0x38, 0x49, 0x5C, 0xFF,
-    0xF6, 0x34, 0x8C, 0x66, 0xC7, 0x47, 0x6F, 0xEF, 0x3F, 0xE2, 0xE5, 0x59,
-    0x7A, 0x9D, 0x5B, 0x55, 0x27, 0x65, 0x4A, 0x26, 0xD5, 0x20, 0x6E, 0xFA,
-    0xD5, 0xC0, 0xCA, 0x7F, 0x94, 0x52, 0xDD, 0x5D, 0xCF, 0x72, 0xD2, 0xED,
-    0x34, 0xDD, 0xDB, 0x49, 0xD3, 0xD4, 0x1E, 0x37, 0x78, 0xDD, 0x52, 0x4F,
-    0x0A, 0x41, 0x98, 0x97, 0x58, 0xCE, 0x0B, 0x94, 0xAB, 0xF7, 0xF6, 0xA2,
-    0xC1, 0xEA, 0x35, 0x11, 0x1E, 0x61, 0x71, 0xF1, 0xC3, 0x9B, 0xBA, 0x4E,
-    0x39, 0xA2, 0x75, 0x51, 0x75, 0xF6, 0xD8, 0xEC, 0x46, 0x13, 0x2A, 0xB6,
-    0x87, 0x99, 0x4A, 0x43, 0x0C, 0x97, 0x61, 0xBB, 0xDC, 0x25, 0x4F, 0x77,
-    0x0A, 0x16, 0x82, 0xCB, 0x35, 0x55, 0x97, 0x60, 0x67, 0xA0, 0xA2, 0xEA,
-    0x60, 0x73, 0xA0, 0x20, 0xA4, 0x4C, 0x46, 0x96, 0x33, 0x1A, 0x48, 0x4F,
-    0x89, 0xE0, 0x96, 0xF3, 0x5A, 0x63, 0x3F, 0x1A, 0xD3, 0x38, 0xF1, 0xF2,
-    0x38, 0x1A, 0xCE, 0x34, 0xC1, 0xF2, 0x1A, 0x66, 0x81, 0xE5, 0xFC, 0xF9,
-    0xF2, 0x1D, 0xE6, 0x4C, 0x83, 0xD1, 0xA3, 0xA2, 0x11, 0x57, 0x0B, 0x18,
-    0x2D, 0xEF, 0x2F, 0x9F, 0x20, 0xAB, 0x1F, 0x84, 0x26, 0xCA, 0x06, 0x9D,
-    0x56, 0xB7, 0x7A, 0xD9, 0x93, 0x35, 0xB9, 0xC1, 0x5E, 0x39, 0x4C, 0xCB,
-    0xB0, 0xD8, 0xD3, 0x4D, 0xE0, 0xFB, 0xCC, 0x47, 0x53, 0xF0, 0x67, 0x6C,
-    0x26, 0x50, 0x46, 0x39, 0xEB, 0x21, 0x1C, 0x72, 0x29, 0x28, 0x11, 0x68,
-    0x16, 0xFB, 0x1D, 0x8C, 0x89, 0x0F, 0xDF, 0x3F, 0x68, 0x4A, 0xFF, 0x4B,
-    0x39, 0x85, 0xEF, 0x3D, 0x72, 0xDF, 0x4B, 0x99, 0x08, 0x3C, 0x87, 0x77,
-    0xAC, 0x8F, 0x72, 0xB5, 0xC4, 0xB4, 0x83, 0x70, 0xC6, 0x53, 0x79, 0x8B,
-    0xD1, 0x09, 0x8F, 0x97, 0xD4, 0x53, 0x3D, 0x8D, 0x3E, 0xBC, 0x43, 0x6E,
-    0x3F, 0x19, 0x0C, 0xF0, 0x96, 0xBC, 0x24, 0x5F, 0xF6, 0xFE, 0x34, 0x70,
-    0x17, 0xAA, 0x4B, 0x74, 0xDE, 0x4B, 0x9B, 0xF1, 0x41, 0x34, 0x37, 0x91,
-    0x6C, 0xB1, 0xE2, 0x19, 0x33, 0x2F, 0x32, 0x1B, 0x6D, 0xB5, 0xF3, 0xB4,
-    0xC7, 0xF9, 0xA7, 0xBA, 0xF3, 0x0F, 0xD5, 0xFA, 0xC0, 0xFA};
-const uint8_t g_ruRU_Locale[] = {
-    0x78, 0x9C, 0xAD, 0x57, 0x4D, 0x4F, 0x13, 0x41, 0x18, 0x3E, 0x63, 0xE2,
-    0x7F, 0x98, 0x6C, 0x24, 0x68, 0x02, 0xAD, 0x1E, 0x25, 0x65, 0x13, 0x22,
-    0x0A, 0x06, 0xD7, 0x90, 0x16, 0x34, 0x72, 0x31, 0xDB, 0xDD, 0xA1, 0x5D,
-    0xE8, 0xEE, 0x90, 0xE9, 0x6E, 0xB0, 0x7B, 0x2A, 0x85, 0xE8, 0x05, 0x25,
-    0xE1, 0xA0, 0x47, 0xF4, 0xE4, 0xC9, 0x50, 0xBE, 0x12, 0x82, 0xB6, 0x24,
-    0xFE, 0x82, 0xD9, 0xFF, 0x60, 0xD4, 0x9F, 0xE1, 0x3B, 0xFB, 0xD1, 0xEE,
-    0xB7, 0xC5, 0xD8, 0x1E, 0x3A, 0xF3, 0x3E, 0xCF, 0xF3, 0xCE, 0xFB, 0xB5,
-    0xD3, 0xB6, 0xD4, 0x20, 0x8A, 0xDC, 0xC0, 0xC8, 0x90, 0x75, 0x3C, 0x23,
-    0x50, 0xEB, 0x65, 0x79, 0x45, 0x40, 0x2A, 0x6E, 0x2A, 0x33, 0xC2, 0x8F,
-    0xAB, 0xDD, 0xDF, 0x47, 0x5F, 0x6E, 0xC3, 0xC7, 0xAF, 0xDE, 0x87, 0x9F,
-    0xEF, 0x8F, 0xEE, 0x08, 0xE2, 0xCD, 0x1B, 0x08, 0x95, 0x38, 0xDF, 0x50,
-    0x65, 0x5A, 0x69, 0xE9, 0x55, 0xD2, 0x68, 0xFA, 0xD2, 0x1A, 0xC5, 0x35,
-    0x42, 0x35, 0xD9, 0xE0, 0xAC, 0x31, 0x54, 0xD2, 0x89, 0x61, 0xD6, 0x9F,
-    0x02, 0xD4, 0xE4, 0xFB, 0x31, 0x6F, 0x2F, 0x3A, 0xFB, 0xAC, 0xC7, 0x4E,
-    0x58, 0xD7, 0x69, 0x3B, 0xFB, 0xA5, 0xA2, 0x67, 0x0B, 0xC3, 0xBB, 0xEC,
-    0x9C, 0x9D, 0x38, 0x6D, 0xD6, 0x65, 0x5F, 0x53, 0x09, 0xEC, 0x9B, 0xAB,
-    0xED, 0xB0, 0x6E, 0x1A, 0xD8, 0x65, 0x57, 0xA0, 0x3D, 0xCF, 0xD3, 0xA6,
-    0x02, 0x17, 0xCE, 0x3B, 0xD6, 0xCB, 0x86, 0x32, 0xDC, 0x75, 0x21, 0x91,
-    0x53, 0x67, 0xC7, 0xD9, 0xCE, 0x08, 0xC7, 0xD9, 0x86, 0x50, 0x7A, 0x4E,
-    0x07, 0x72, 0x3E, 0xCE, 0xC8, 0x97, 0xF5, 0xD9, 0x65, 0x3E, 0xA1, 0xC7,
-    0xFA, 0x79, 0xF0, 0x19, 0x1C, 0x71, 0x09, 0x91, 0xC4, 0x09, 0xC8, 0x5F,
-    0x0F, 0x1A, 0x10, 0x6E, 0x08, 0x92, 0xAB, 0x55, 0x3A, 0x23, 0xDC, 0x13,
-    0x92, 0x9D, 0x29, 0xE4, 0x34, 0x25, 0x0D, 0x1B, 0xA1, 0x1F, 0x99, 0xB2,
-    0xFF, 0xDD, 0x8A, 0xD4, 0xD8, 0xFD, 0x1E, 0xA4, 0x06, 0xE1, 0x16, 0x3F,
-    0x15, 0xF1, 0xAB, 0x9E, 0x8A, 0xB9, 0x25, 0x2F, 0xE4, 0xD7, 0x5A, 0x95,
-    0x5B, 0xA1, 0xD1, 0x87, 0x9D, 0x08, 0x01, 0xF6, 0x21, 0x98, 0x4B, 0x3E,
-    0x9F, 0x7E, 0x50, 0x7B, 0xEC, 0xBC, 0x54, 0xE4, 0xD8, 0x90, 0x74, 0x05,
-    0x31, 0xF5, 0x00, 0x3C, 0x73, 0x87, 0x78, 0x0F, 0xD6, 0x17, 0xEC, 0x32,
-    0x4E, 0x3A, 0x81, 0x72, 0xF7, 0xC1, 0x4F, 0x1A, 0x08, 0xC3, 0xD8, 0x76,
-    0xF5, 0xDD, 0x38, 0xF0, 0x06, 0xCE, 0xED, 0x40, 0x14, 0xE7, 0x40, 0x38,
-    0x4D, 0x9C, 0xEB, 0xEC, 0x03, 0x08, 0x0E, 0x9D, 0xD7, 0x49, 0xE5, 0xB6,
-    0xB3, 0xC3, 0x8E, 0xE1, 0xDD, 0xF7, 0xDA, 0xEC, 0x83, 0xC8, 0x5D, 0xA5,
-    0xE4, 0x1C, 0x9B, 0x2E, 0xD7, 0xFF, 0x81, 0xB3, 0x1D, 0x3F, 0xF2, 0x90,
-    0xF5, 0xE2, 0xA6, 0x03, 0xA7, 0x13, 0x37, 0x7D, 0x72, 0xDA, 0x71, 0xD3,
-    0xE7, 0x24, 0xEB, 0x30, 0x45, 0xC8, 0x8E, 0xB3, 0x43, 0xD5, 0x31, 0xD5,
-    0x54, 0x0D, 0xEB, 0xE1, 0xEB, 0xC9, 0x37, 0x89, 0xB3, 0x12, 0xB4, 0x33,
-    0xD8, 0x44, 0xA1, 0xA5, 0x18, 0x84, 0x86, 0xDB, 0x90, 0x73, 0x4C, 0xE5,
-    0x90, 0x5F, 0xD8, 0xF1, 0x91, 0xE9, 0x23, 0xD6, 0x2B, 0x38, 0x6F, 0x61,
-    0x6C, 0xB8, 0x61, 0x88, 0x44, 0x8D, 0xC8, 0x5D, 0x05, 0x6A, 0xB8, 0x6A,
-    0x8B, 0xB1, 0xBB, 0xD6, 0xB3, 0xAA, 0xB2, 0x89, 0x97, 0x64, 0xD3, 0xC4,
-    0xD4, 0x18, 0xD4, 0x7E, 0x60, 0xF1, 0xAF, 0xE3, 0x35, 0xAB, 0xD1, 0x10,
-    0xC4, 0x39, 0x24, 0xC1, 0x0B, 0xBD, 0x80, 0x17, 0x9A, 0x80, 0x27, 0x64,
-    0x82, 0x57, 0x62, 0x40, 0xCD, 0xD2, 0x36, 0x88, 0x51, 0xFB, 0x57, 0xAD,
-    0x8E, 0x55, 0x90, 0xCE, 0x15, 0x24, 0xA9, 0xC0, 0x95, 0x23, 0x69, 0x9A,
-    0x75, 0x42, 0xCD, 0xA1, 0x2A, 0xAE, 0x41, 0x28, 0x62, 0xF1, 0x8B, 0x60,
-    0x6A, 0x7A, 0xAC, 0x08, 0x21, 0x4B, 0xA4, 0x08, 0x0B, 0xD3, 0x92, 0x34,
-    0x5D, 0xA9, 0xA0, 0xD5, 0x52, 0x31, 0x44, 0xC9, 0xD2, 0x78, 0xC9, 0x5F,
-    0x4F, 0xE3, 0x26, 0xED, 0x4B, 0x46, 0x12, 0xF8, 0x19, 0x73, 0x49, 0x9C,
-    0xCF, 0xB3, 0x8D, 0xE5, 0xE6, 0xB7, 0x7C, 0x19, 0xAC, 0xC1, 0x1C, 0xCC,
-    0xCB, 0xC6, 0xFA, 0xC6, 0x82, 0xDE, 0xAC, 0x3C, 0x9C, 0x7B, 0xB4, 0xF5,
-    0xFC, 0x55, 0x7D, 0xD1, 0x5E, 0xF5, 0x8A, 0x14, 0x26, 0xB9, 0x4A, 0xC3,
-    0xD2, 0xAB, 0x98, 0x46, 0x2B, 0x15, 0xB1, 0xF9, 0x21, 0x81, 0x0D, 0x66,
-    0x59, 0x11, 0x44, 0x7B, 0xD2, 0xB6, 0xEF, 0x17, 0x6C, 0xDB, 0x2E, 0x15,
-    0x23, 0xBC, 0x6C, 0xA9, 0x62, 0x51, 0x8A, 0x0D, 0xA5, 0x35, 0xD4, 0xDE,
-    0x1A, 0x59, 0xBB, 0x89, 0xA9, 0x82, 0x0D, 0xD3, 0x97, 0x8E, 0x27, 0x75,
-    0xBC, 0x1E, 0x89, 0x1C, 0x06, 0x79, 0x0D, 0x53, 0x1D, 0x8B, 0x9A, 0x7C,
-    0xF7, 0x2A, 0x56, 0x34, 0x5D, 0x86, 0x21, 0x98, 0x0C, 0xBC, 0x78, 0x70,
-    0xA6, 0xA0, 0x46, 0x89, 0xB5, 0xA9, 0xF1, 0x11, 0xF8, 0xFE, 0x71, 0x44,
-    0xC9, 0x20, 0x85, 0xF1, 0x11, 0x05, 0xBA, 0x66, 0x58, 0x4D, 0x41, 0x9C,
-    0x1A, 0x91, 0x6E, 0x63, 0x4A, 0x04, 0xF1, 0x6E, 0x82, 0x3D, 0xAC, 0x4C,
-    0xA4, 0xE1, 0x41, 0x37, 0x22, 0xA5, 0x89, 0x1A, 0x83, 0x29, 0x74, 0x37,
-    0x82, 0xE8, 0x7E, 0x47, 0x47, 0x19, 0x39, 0x2A, 0xAD, 0x49, 0xF8, 0x42,
-    0x10, 0xCB, 0x2B, 0xE5, 0x6B, 0xC8, 0xC2, 0x9D, 0x48, 0x88, 0xDC, 0xAB,
-    0x2E, 0x11, 0x37, 0x7F, 0xCA, 0x5B, 0x9B, 0x78, 0x4D, 0x56, 0x82, 0xBB,
-    0x35, 0xD8, 0xFA, 0x3E, 0xA5, 0x16, 0xFC, 0xE0, 0x54, 0xD1, 0x12, 0xD4,
-    0xA7, 0x98, 0x4E, 0xD0, 0x0C, 0x8D, 0x18, 0x39, 0x84, 0x07, 0xC4, 0xA2,
-    0x1A, 0xA6, 0xA8, 0x62, 0xAA, 0x19, 0x8C, 0x59, 0x95, 0x54, 0x31, 0x5A,
-    0xD2, 0xFE, 0x4A, 0x59, 0xC0, 0x55, 0x8A, 0xB7, 0x72, 0x29, 0xB3, 0x54,
-    0xAE, 0xC2, 0x23, 0x96, 0x47, 0x59, 0xAE, 0xCB, 0x5A, 0x06, 0x61, 0x91,
-    0xD8, 0xD6, 0x86, 0x8C, 0xE6, 0x89, 0x59, 0xD7, 0x14, 0x9E, 0xD3, 0xD4,
-    0xB3, 0xC7, 0x48, 0xCA, 0x27, 0x43, 0x01, 0x94, 0x3A, 0x09, 0xC8, 0xE5,
-    0xDC, 0xA3, 0x81, 0x5B, 0xE3, 0x59, 0xA2, 0x27, 0xB9, 0xB4, 0x0A, 0x19,
-    0x89, 0x26, 0xB5, 0x2C, 0xA3, 0xB6, 0x4E, 0x5C, 0xA6, 0x17, 0xA4, 0x7B,
-    0xB3, 0x85, 0xFA, 0x59, 0x2A, 0x7A, 0xFF, 0x3D, 0xC4, 0x3F, 0xDE, 0xCB,
-    0x8B, 0xC4};
-static IFX_Locale* XFA_GetLocaleFromBuffer(const uint8_t* pBuf, int nBufLen) {
-  if (pBuf == NULL || nBufLen <= 0) {
-    return NULL;
-  }
-  CFX_GEModule* pGeModule = CFX_GEModule::Get();
-  if (!pGeModule) {
-    return NULL;
-  }
-  CCodec_ModuleMgr* pCodecMgr = pGeModule->GetCodecModule();
-  if (!pCodecMgr) {
-    return NULL;
-  }
-  CXML_Element* pLocale = NULL;
-  uint8_t* pOut = NULL;
-  FX_DWORD dwSize;
-  pCodecMgr->GetFlateModule()->FlateOrLZWDecode(FALSE, pBuf, nBufLen, TRUE, 0,
-                                                0, 0, 0, 0, pOut, dwSize);
-  if (pOut) {
-    pLocale = CXML_Element::Parse(pOut, dwSize);
-    FX_Free(pOut);
-  }
-  if (pLocale) {
-    return new CXFA_XMLLocale(pLocale);
-  }
-  return NULL;
-}
-static FX_WORD XFA_GetLanguage(CFX_WideString wsLanguage) {
-  FX_WORD dwLangueID = XFA_LANGID_en_US;
-  if (wsLanguage.GetLength() < 2) {
-    return dwLangueID;
-  }
-  wsLanguage.MakeLower();
-  FX_DWORD dwIDFirst = wsLanguage.GetAt(0) << 8 | wsLanguage.GetAt(1);
-  FX_DWORD dwIDSecond = wsLanguage.GetLength() >= 5
-                            ? wsLanguage.GetAt(3) << 8 | wsLanguage.GetAt(4)
-                            : 0;
-  switch (dwIDFirst) {
-    case FXBSTR_ID(0, 0, 'z', 'h'): {
-      if (dwIDSecond == FXBSTR_ID(0, 0, 'c', 'n')) {
-        dwLangueID = XFA_LANGID_zh_CN;
-      } else if (dwIDSecond == FXBSTR_ID(0, 0, 't', 'w')) {
-        dwLangueID = XFA_LANGID_zh_TW;
-      } else if (dwIDSecond == FXBSTR_ID(0, 0, 'h', 'k')) {
-        dwLangueID = XFA_LANGID_zh_HK;
-      }
-    } break;
-    case FXBSTR_ID(0, 0, 'j', 'a'):
-      dwLangueID = XFA_LANGID_ja_JP;
-      break;
-    case FXBSTR_ID(0, 0, 'k', 'o'):
-      dwLangueID = XFA_LANGID_ko_KR;
-      break;
-    case FXBSTR_ID(0, 0, 'e', 'n'): {
-      if (dwIDSecond == FXBSTR_ID(0, 0, 'g', 'b')) {
-        dwLangueID = XFA_LANGID_en_GB;
-      } else {
-        dwLangueID = XFA_LANGID_en_US;
-      }
-    } break;
-    case FXBSTR_ID(0, 0, 'd', 'e'):
-      dwLangueID = XFA_LANGID_de_DE;
-      break;
-    case FXBSTR_ID(0, 0, 'f', 'r'):
-      dwLangueID = XFA_LANGID_fr_FR;
-      break;
-    case FXBSTR_ID(0, 0, 'e', 's'): {
-      if (dwIDSecond == FXBSTR_ID(0, 0, 'e', 's')) {
-        dwLangueID = XFA_LANGID_es_ES;
-      } else {
-        dwLangueID = XFA_LANGID_es_LA;
-      }
-    } break;
-    case FXBSTR_ID(0, 0, 'i', 't'):
-      dwLangueID = XFA_LANGID_it_IT;
-      break;
-    case FXBSTR_ID(0, 0, 'p', 't'):
-      dwLangueID = XFA_LANGID_pt_BR;
-      break;
-    case FXBSTR_ID(0, 0, 'n', 'l'):
-      dwLangueID = XFA_LANGID_nl_NL;
-      break;
-    case FXBSTR_ID(0, 0, 'r', 'u'):
-      dwLangueID = XFA_LANGID_ru_RU;
-      break;
-  }
-  return dwLangueID;
-}
-CXFA_LocaleMgr::CXFA_LocaleMgr(CXFA_Node* pLocaleSet, CFX_WideString wsDeflcid)
-    : m_dwLocaleFlags(0x00) {
-  m_dwDeflcid = XFA_GetLanguage(wsDeflcid);
-  CXFA_Node* pNodeLocale = NULL;
-  if (pLocaleSet &&
-      (pNodeLocale = pLocaleSet->GetNodeItem(XFA_NODEITEM_FirstChild))) {
-    while (pNodeLocale) {
-      m_LocaleArray.Add(new CXFA_NodeLocale(pNodeLocale));
-      pNodeLocale = pNodeLocale->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-  }
-  m_pDefLocale = GetLocaleByName(wsDeflcid);
-}
-CXFA_LocaleMgr::~CXFA_LocaleMgr() {
-  int32_t iCount = m_LocaleArray.GetSize();
-  for (int32_t i = 0; i < iCount; i++) {
-    ((IFX_Locale*)m_LocaleArray[i])->Release();
-  }
-  int32_t iXmls = m_XMLLocaleArray.GetSize();
-  for (int32_t j = 0; j < iXmls; j++) {
-    ((IFX_Locale*)m_XMLLocaleArray[j])->Release();
-  }
-}
-void CXFA_LocaleMgr::Release() {
-  delete this;
-}
-FX_WORD CXFA_LocaleMgr::GetDefLocaleID() {
-  return m_dwDeflcid;
-}
-IFX_Locale* CXFA_LocaleMgr::GetDefLocale() {
-  if (m_pDefLocale) {
-    return m_pDefLocale;
-  } else if (m_LocaleArray.GetSize()) {
-    return (IFX_Locale*)m_LocaleArray[0];
-  } else if (m_XMLLocaleArray.GetSize()) {
-    return (IFX_Locale*)m_XMLLocaleArray[0];
-  }
-  m_pDefLocale = GetLocale(m_dwDeflcid);
-  if (m_pDefLocale)
-    m_XMLLocaleArray.Add(m_pDefLocale);
-  return m_pDefLocale;
-}
-IFX_Locale* CXFA_LocaleMgr::GetLocale(FX_WORD lcid) {
-  IFX_Locale* pLocal = NULL;
-  switch (lcid) {
-    case XFA_LANGID_zh_CN:
-      pLocal = XFA_GetLocaleFromBuffer(g_zhCN_Locale, sizeof(g_zhCN_Locale));
-      break;
-    case XFA_LANGID_zh_TW:
-      pLocal = XFA_GetLocaleFromBuffer(g_zhTW_Locale, sizeof(g_zhTW_Locale));
-      break;
-    case XFA_LANGID_zh_HK:
-      pLocal = XFA_GetLocaleFromBuffer(g_zhHK_Locale, sizeof(g_zhHK_Locale));
-      break;
-    case XFA_LANGID_ja_JP:
-      pLocal = XFA_GetLocaleFromBuffer(g_jaJP_Locale, sizeof(g_jaJP_Locale));
-      break;
-    case XFA_LANGID_ko_KR:
-      pLocal = XFA_GetLocaleFromBuffer(g_koKR_Locale, sizeof(g_koKR_Locale));
-      break;
-    case XFA_LANGID_en_GB:
-      pLocal = XFA_GetLocaleFromBuffer(g_enGB_Locale, sizeof(g_enGB_Locale));
-      break;
-    case XFA_LANGID_es_LA:
-      pLocal = XFA_GetLocaleFromBuffer(g_esLA_Locale, sizeof(g_esLA_Locale));
-      break;
-    case XFA_LANGID_es_ES:
-      pLocal = XFA_GetLocaleFromBuffer(g_esES_Locale, sizeof(g_esES_Locale));
-      break;
-    case XFA_LANGID_de_DE:
-      pLocal = XFA_GetLocaleFromBuffer(g_deDE_Loacale, sizeof(g_deDE_Loacale));
-      break;
-    case XFA_LANGID_fr_FR:
-      pLocal = XFA_GetLocaleFromBuffer(g_frFR_Locale, sizeof(g_frFR_Locale));
-      break;
-    case XFA_LANGID_it_IT:
-      pLocal = XFA_GetLocaleFromBuffer(g_itIT_Locale, sizeof(g_itIT_Locale));
-      break;
-    case XFA_LANGID_pt_BR:
-      pLocal = XFA_GetLocaleFromBuffer(g_ptBR_Locale, sizeof(g_ptBR_Locale));
-      break;
-    case XFA_LANGID_nl_NL:
-      pLocal = XFA_GetLocaleFromBuffer(g_nlNL_Locale, sizeof(g_nlNL_Locale));
-      break;
-    case XFA_LANGID_ru_RU:
-      pLocal = XFA_GetLocaleFromBuffer(g_ruRU_Locale, sizeof(g_ruRU_Locale));
-      break;
-    case XFA_LANGID_en_US:
-    default:
-      pLocal = XFA_GetLocaleFromBuffer(g_enUS_Locale, sizeof(g_enUS_Locale));
-      break;
-  }
-  return pLocal;
-}
-IFX_Locale* CXFA_LocaleMgr::GetLocaleByName(
-    const CFX_WideStringC& wsLocaleName) {
-  int32_t iCount = m_LocaleArray.GetSize();
-  int32_t i = 0;
-  for (i = 0; i < iCount; i++) {
-    IFX_Locale* pLocale = ((IFX_Locale*)m_LocaleArray[i]);
-    if (pLocale->GetName() == wsLocaleName) {
-      return pLocale;
-    }
-  }
-  int32_t iLen = wsLocaleName.GetLength();
-  if (iLen < 2) {
-    return NULL;
-  }
-  iCount = m_XMLLocaleArray.GetSize();
-  for (i = 0; i < iCount; i++) {
-    IFX_Locale* pLocale = ((IFX_Locale*)m_XMLLocaleArray[i]);
-    if (pLocale->GetName() == wsLocaleName) {
-      return pLocale;
-    }
-  }
-  FX_WORD dwLangueID = XFA_GetLanguage(wsLocaleName);
-  IFX_Locale* pLocale = GetLocale(dwLangueID);
-  if (pLocale)
-    m_XMLLocaleArray.Add(pLocale);
-  return pLocale;
-}
-void CXFA_LocaleMgr::SetDefLocale(IFX_Locale* pLocale) {
-  m_pDefLocale = pLocale;
-}
-CFX_WideStringC CXFA_LocaleMgr::GetConfigLocaleName(CXFA_Node* pConfig) {
-  if (!(m_dwLocaleFlags & 0x01)) {
-    m_wsConfigLocale.Empty();
-    if (pConfig) {
-      CXFA_Node* pChildfConfig =
-          pConfig->GetFirstChildByClass(XFA_ELEMENT_Acrobat);
-      if (!pChildfConfig) {
-        pChildfConfig = pConfig->GetFirstChildByClass(XFA_ELEMENT_Present);
-      }
-      CXFA_Node* pCommon =
-          pChildfConfig
-              ? pChildfConfig->GetFirstChildByClass(XFA_ELEMENT_Common)
-              : NULL;
-      CXFA_Node* pLocale =
-          pCommon ? pCommon->GetFirstChildByClass(XFA_ELEMENT_Locale) : NULL;
-      if (pLocale) {
-        pLocale->TryCData(XFA_ATTRIBUTE_Value, m_wsConfigLocale, FALSE);
-      }
-    }
-    m_dwLocaleFlags |= 0x01;
-  }
-  return m_wsConfigLocale;
-}
-static CXFA_TimeZoneProvider* g_pProvider = NULL;
-IXFA_TimeZoneProvider* IXFA_TimeZoneProvider::Create() {
-  FXSYS_assert(!g_pProvider);
-  g_pProvider = new CXFA_TimeZoneProvider();
-  return g_pProvider;
-}
-IXFA_TimeZoneProvider* IXFA_TimeZoneProvider::Get() {
-  if (!g_pProvider) {
-    g_pProvider = new CXFA_TimeZoneProvider();
-  }
-  return g_pProvider;
-}
-void IXFA_TimeZoneProvider::Destroy() {
-  delete g_pProvider;
-  g_pProvider = NULL;
-}
-#include <time.h>
-CXFA_TimeZoneProvider::CXFA_TimeZoneProvider() {
-#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-  _tzset();
-  m_tz.tzHour = (int8_t)(_timezone / 3600 * -1);
-  m_tz.tzMinute = (int8_t)((FXSYS_abs(_timezone) % 3600) / 60);
-#else
-  tzset();
-  m_tz.tzHour = (int8_t)(timezone / 3600 * -1);
-  m_tz.tzMinute = (int8_t)((FXSYS_abs((int)timezone) % 3600) / 60);
-#endif
-}
-CXFA_TimeZoneProvider::~CXFA_TimeZoneProvider() {}
-void CXFA_TimeZoneProvider::SetTimeZone(FX_TIMEZONE& tz) {
-  m_tz = tz;
-}
-void CXFA_TimeZoneProvider::GetTimeZone(FX_TIMEZONE& tz) {
-  tz = m_tz;
-}
diff --git a/xfa/src/fxfa/parser/xfa_localemgr.h b/xfa/src/fxfa/parser/xfa_localemgr.h
deleted file mode 100644
index 0af6f5f2d3..0000000000
--- a/xfa/src/fxfa/parser/xfa_localemgr.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_LOCALEMGR_H_
-#define XFA_SRC_FXFA_PARSER_XFA_LOCALEMGR_H_
-
-#include "xfa/include/fxfa/fxfa_objectacc.h"
-#include "xfa/src/fgas/localization/fgas_datetime.h"
-#include "xfa/src/fgas/localization/fgas_locale.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-
-class CXFA_Node;
-class IFX_Locale;
-
-#define XFA_LANGID_zh_CN 0x0804
-#define XFA_LANGID_zh_TW 0x0404
-#define XFA_LANGID_zh_HK 0x0c04
-#define XFA_LANGID_ja_JP 0x0411
-#define XFA_LANGID_ko_KR 0x0412
-#define XFA_LANGID_en_US 0x0409
-#define XFA_LANGID_en_GB 0x0809
-#define XFA_LANGID_es_ES 0x0c0a
-#define XFA_LANGID_es_LA 0x080a
-#define XFA_LANGID_de_DE 0x0407
-#define XFA_LANGID_fr_FR 0x040c
-#define XFA_LANGID_it_IT 0x0410
-#define XFA_LANGID_pt_BR 0x0416
-#define XFA_LANGID_nl_NL 0x0413
-#define XFA_LANGID_ru_RU 0x0419
-
-class CXFA_LocaleMgr : public IFX_LocaleMgr {
- public:
-  CXFA_LocaleMgr(CXFA_Node* pLocaleSet, CFX_WideString wsDeflcid);
-  virtual void Release();
-  virtual FX_WORD GetDefLocaleID();
-  virtual IFX_Locale* GetDefLocale();
-  virtual IFX_Locale* GetLocale(FX_WORD lcid);
-  virtual IFX_Locale* GetLocaleByName(const CFX_WideStringC& wsLocaleName);
-  ~CXFA_LocaleMgr();
-  void SetDefLocale(IFX_Locale* pLocale);
-  CFX_WideStringC GetConfigLocaleName(CXFA_Node* pConfig);
-
- protected:
-  CFX_PtrArray m_LocaleArray;
-  CFX_PtrArray m_XMLLocaleArray;
-  IFX_Locale* m_pDefLocale;
-  CFX_WideString m_wsConfigLocale;
-  FX_WORD m_dwDeflcid;
-  FX_WORD m_dwLocaleFlags;
-};
-
-class IXFA_TimeZoneProvider {
- public:
-  static IXFA_TimeZoneProvider* Create();
-  static IXFA_TimeZoneProvider* Get();
-  static void Destroy();
-
-  virtual ~IXFA_TimeZoneProvider() {}
-
-  virtual void SetTimeZone(FX_TIMEZONE& tz) = 0;
-
-  virtual void GetTimeZone(FX_TIMEZONE& tz) = 0;
-};
-class CXFA_TimeZoneProvider : public IXFA_TimeZoneProvider {
- public:
-  CXFA_TimeZoneProvider();
-  virtual ~CXFA_TimeZoneProvider();
-  virtual void SetTimeZone(FX_TIMEZONE& tz);
-  virtual void GetTimeZone(FX_TIMEZONE& tz);
-
- private:
-  FX_TIMEZONE m_tz;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_LOCALEMGR_H_
diff --git a/xfa/src/fxfa/parser/xfa_localevalue.cpp b/xfa/src/fxfa/parser/xfa_localevalue.cpp
deleted file mode 100644
index 5b9dc27681..0000000000
--- a/xfa/src/fxfa/parser/xfa_localevalue.cpp
+++ /dev/null
@@ -1,981 +0,0 @@
-// 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/src/fxfa/parser/xfa_localevalue.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-static const FX_DOUBLE fraction_scales[] = {0.1,
-                                            0.01,
-                                            0.001,
-                                            0.0001,
-                                            0.00001,
-                                            0.000001,
-                                            0.0000001,
-                                            0.00000001,
-                                            0.000000001,
-                                            0.0000000001,
-                                            0.00000000001,
-                                            0.000000000001,
-                                            0.0000000000001,
-                                            0.00000000000001,
-                                            0.000000000000001,
-                                            0.0000000000000001};
-CXFA_LocaleValue::CXFA_LocaleValue() {
-  m_dwType = XFA_VT_NULL;
-  m_bValid = TRUE;
-  m_pLocaleMgr = NULL;
-}
-CXFA_LocaleValue::CXFA_LocaleValue(const CXFA_LocaleValue& value) {
-  m_dwType = XFA_VT_NULL;
-  m_bValid = TRUE;
-  m_pLocaleMgr = NULL;
-  *this = value;
-}
-CXFA_LocaleValue::CXFA_LocaleValue(FX_DWORD dwType,
-                                   CXFA_LocaleMgr* pLocaleMgr) {
-  m_dwType = dwType;
-  m_bValid = (m_dwType != XFA_VT_NULL);
-  m_pLocaleMgr = pLocaleMgr;
-}
-CXFA_LocaleValue::CXFA_LocaleValue(FX_DWORD dwType,
-                                   const CFX_WideString& wsValue,
-                                   CXFA_LocaleMgr* pLocaleMgr) {
-  m_wsValue = wsValue;
-  m_dwType = dwType;
-  m_pLocaleMgr = pLocaleMgr;
-  m_bValid = ValidateCanonicalValue(wsValue, dwType);
-}
-CXFA_LocaleValue::CXFA_LocaleValue(FX_DWORD dwType,
-                                   const CFX_WideString& wsValue,
-                                   const CFX_WideString& wsFormat,
-                                   IFX_Locale* pLocale,
-                                   CXFA_LocaleMgr* pLocaleMgr) {
-  m_pLocaleMgr = pLocaleMgr;
-  m_bValid = TRUE;
-  m_dwType = dwType;
-  m_bValid = ParsePatternValue(wsValue, wsFormat, pLocale);
-}
-CXFA_LocaleValue& CXFA_LocaleValue::operator=(const CXFA_LocaleValue& value) {
-  m_wsValue = value.m_wsValue;
-  m_dwType = value.m_dwType;
-  m_bValid = value.m_bValid;
-  m_pLocaleMgr = value.m_pLocaleMgr;
-  return *this;
-}
-CXFA_LocaleValue::~CXFA_LocaleValue() {}
-static FX_LOCALECATEGORY XFA_ValugeCategory(FX_LOCALECATEGORY eCategory,
-                                            FX_DWORD dwValueType) {
-  if (eCategory == FX_LOCALECATEGORY_Unknown) {
-    switch (dwValueType) {
-      case XFA_VT_BOOLEAN:
-      case XFA_VT_INTEGER:
-      case XFA_VT_DECIMAL:
-      case XFA_VT_FLOAT:
-        return FX_LOCALECATEGORY_Num;
-      case XFA_VT_TEXT:
-        return FX_LOCALECATEGORY_Text;
-      case XFA_VT_DATE:
-        return FX_LOCALECATEGORY_Date;
-      case XFA_VT_TIME:
-        return FX_LOCALECATEGORY_Time;
-      case XFA_VT_DATETIME:
-        return FX_LOCALECATEGORY_DateTime;
-    }
-  }
-  return eCategory;
-}
-FX_BOOL CXFA_LocaleValue::ValidateValue(const CFX_WideString& wsValue,
-                                        const CFX_WideString& wsPattern,
-                                        IFX_Locale* pLocale,
-                                        CFX_WideString* pMatchFormat) {
-  CFX_WideString wsOutput;
-  IFX_Locale* locale = m_pLocaleMgr->GetDefLocale();
-  if (pLocale) {
-    m_pLocaleMgr->SetDefLocale(pLocale);
-  }
-  IFX_FormatString* pFormat = IFX_FormatString::Create(m_pLocaleMgr, FALSE);
-  CFX_WideStringArray wsPatterns;
-  pFormat->SplitFormatString(wsPattern, wsPatterns);
-  FX_BOOL bRet = FALSE;
-  int32_t iCount = wsPatterns.GetSize();
-  int32_t i = 0;
-  for (; i < iCount && !bRet; i++) {
-    CFX_WideString wsFormat = wsPatterns[i];
-    FX_LOCALECATEGORY eCategory = pFormat->GetCategory(wsFormat);
-    eCategory = XFA_ValugeCategory(eCategory, m_dwType);
-    switch (eCategory) {
-      case FX_LOCALECATEGORY_Null:
-        bRet = pFormat->ParseNull(wsValue, wsFormat);
-        if (!bRet) {
-          bRet = wsValue.IsEmpty();
-        }
-        break;
-      case FX_LOCALECATEGORY_Zero:
-        bRet = pFormat->ParseZero(wsValue, wsFormat);
-        if (!bRet) {
-          bRet = wsValue == FX_WSTRC(L"0");
-        }
-        break;
-      case FX_LOCALECATEGORY_Num: {
-        CFX_WideString fNum;
-        bRet = pFormat->ParseNum(wsValue, wsFormat, fNum);
-        if (!bRet) {
-          bRet = pFormat->FormatNum(wsValue, wsFormat, wsOutput);
-        }
-        break;
-      }
-      case FX_LOCALECATEGORY_Text:
-        bRet = pFormat->ParseText(wsValue, wsFormat, wsOutput);
-        wsOutput.Empty();
-        if (!bRet) {
-          bRet = pFormat->FormatText(wsValue, wsFormat, wsOutput);
-        }
-        break;
-      case FX_LOCALECATEGORY_Date: {
-        CFX_Unitime dt;
-        bRet = ValidateCanonicalDate(wsValue, dt);
-        if (!bRet) {
-          bRet = pFormat->ParseDateTime(wsValue, wsFormat, FX_DATETIMETYPE_Date,
-                                        dt);
-          if (!bRet) {
-            bRet = pFormat->FormatDateTime(wsValue, wsFormat, wsOutput,
-                                           FX_DATETIMETYPE_Date);
-          }
-        }
-        break;
-      }
-      case FX_LOCALECATEGORY_Time: {
-        CFX_Unitime dt;
-        bRet =
-            pFormat->ParseDateTime(wsValue, wsFormat, FX_DATETIMETYPE_Time, dt);
-        if (!bRet) {
-          bRet = pFormat->FormatDateTime(wsValue, wsFormat, wsOutput,
-                                         FX_DATETIMETYPE_Time);
-        }
-        break;
-      }
-      case FX_LOCALECATEGORY_DateTime: {
-        CFX_Unitime dt;
-        bRet = pFormat->ParseDateTime(wsValue, wsFormat,
-                                      FX_DATETIMETYPE_DateTime, dt);
-        if (!bRet) {
-          bRet = pFormat->FormatDateTime(wsValue, wsFormat, wsOutput,
-                                         FX_DATETIMETYPE_DateTime);
-        }
-        break;
-      }
-      default:
-        bRet = FALSE;
-        break;
-    }
-  }
-  if (bRet && pMatchFormat) {
-    *pMatchFormat = wsPatterns[i - 1];
-  }
-  pFormat->Release();
-  if (pLocale) {
-    m_pLocaleMgr->SetDefLocale(locale);
-  }
-  return bRet;
-}
-CFX_WideString CXFA_LocaleValue::GetValue() const {
-  return m_wsValue;
-}
-FX_DWORD CXFA_LocaleValue::GetType() const {
-  return m_dwType;
-}
-void CXFA_LocaleValue::SetValue(const CFX_WideString& wsValue,
-                                FX_DWORD dwType) {
-  m_wsValue = wsValue;
-  m_dwType = dwType;
-}
-CFX_WideString CXFA_LocaleValue::GetText() const {
-  if (m_bValid && m_dwType == XFA_VT_TEXT) {
-    return m_wsValue;
-  }
-  return CFX_WideString();
-}
-FX_FLOAT CXFA_LocaleValue::GetNum() const {
-  if (m_bValid && (m_dwType == XFA_VT_BOOLEAN || m_dwType == XFA_VT_INTEGER ||
-                   m_dwType == XFA_VT_DECIMAL || m_dwType == XFA_VT_FLOAT)) {
-    int64_t nIntegral = 0;
-    FX_DWORD dwFractional = 0;
-    int32_t nExponent = 0;
-    int cc = 0;
-    FX_BOOL bNegative = FALSE, bExpSign = FALSE;
-    const FX_WCHAR* str = (const FX_WCHAR*)m_wsValue;
-    int len = m_wsValue.GetLength();
-    while (XFA_IsSpace(str[cc]) && cc < len) {
-      cc++;
-    }
-    if (cc >= len) {
-      return 0;
-    }
-    if (str[0] == '+') {
-      cc++;
-    } else if (str[0] == '-') {
-      bNegative = TRUE;
-      cc++;
-    }
-    int nIntegralLen = 0;
-    while (cc < len) {
-      if (str[cc] == '.' || !XFA_IsDigit(str[cc]) || nIntegralLen > 17) {
-        break;
-      }
-      nIntegral = nIntegral * 10 + str[cc] - '0';
-      cc++;
-      nIntegralLen++;
-    }
-    nIntegral = bNegative ? -nIntegral : nIntegral;
-    int scale = 0;
-    double fraction = 0.0;
-    if (cc < len && str[cc] == '.') {
-      cc++;
-      while (cc < len) {
-        fraction += fraction_scales[scale] * (str[cc] - '0');
-        scale++;
-        cc++;
-        if (scale == sizeof fraction_scales / sizeof(double) ||
-            !XFA_IsDigit(str[cc])) {
-          break;
-        }
-      }
-      dwFractional = (FX_DWORD)(fraction * 4294967296.0);
-    }
-    if (cc < len && (str[cc] == 'E' || str[cc] == 'e')) {
-      cc++;
-      if (cc < len) {
-        if (str[cc] == '+') {
-          cc++;
-        } else if (str[cc] == '-') {
-          bExpSign = TRUE;
-          cc++;
-        }
-      }
-      while (cc < len) {
-        if (str[cc] == '.' || !XFA_IsDigit(str[cc])) {
-          break;
-        }
-        nExponent = nExponent * 10 + str[cc] - '0';
-        cc++;
-      }
-      nExponent = bExpSign ? -nExponent : nExponent;
-    }
-    FX_FLOAT fValue = (FX_FLOAT)(dwFractional / 4294967296.0);
-    fValue = nIntegral + (nIntegral >= 0 ? fValue : -fValue);
-    if (nExponent != 0) {
-      fValue *= FXSYS_pow(10, (FX_FLOAT)nExponent);
-    }
-    return fValue;
-  }
-  return 0;
-}
-FX_DOUBLE CXFA_LocaleValue::GetDoubleNum() const {
-  if (m_bValid && (m_dwType == XFA_VT_BOOLEAN || m_dwType == XFA_VT_INTEGER ||
-                   m_dwType == XFA_VT_DECIMAL || m_dwType == XFA_VT_FLOAT)) {
-    int64_t nIntegral = 0;
-    FX_DWORD dwFractional = 0;
-    int32_t nExponent = 0;
-    int32_t cc = 0;
-    FX_BOOL bNegative = FALSE, bExpSign = FALSE;
-    const FX_WCHAR* str = (const FX_WCHAR*)m_wsValue;
-    int len = m_wsValue.GetLength();
-    while (XFA_IsSpace(str[cc]) && cc < len) {
-      cc++;
-    }
-    if (cc >= len) {
-      return 0;
-    }
-    if (str[0] == '+') {
-      cc++;
-    } else if (str[0] == '-') {
-      bNegative = TRUE;
-      cc++;
-    }
-    int32_t nIntegralLen = 0;
-    while (cc < len) {
-      if (str[cc] == '.' || !XFA_IsDigit(str[cc]) || nIntegralLen > 17) {
-        break;
-      }
-      nIntegral = nIntegral * 10 + str[cc] - '0';
-      cc++;
-      nIntegralLen++;
-    }
-    nIntegral = bNegative ? -nIntegral : nIntegral;
-    int32_t scale = 0;
-    FX_DOUBLE fraction = 0.0;
-    if (cc < len && str[cc] == '.') {
-      cc++;
-      while (cc < len) {
-        fraction += fraction_scales[scale] * (str[cc] - '0');
-        scale++;
-        cc++;
-        if (scale == sizeof fraction_scales / sizeof(FX_DOUBLE) ||
-            !XFA_IsDigit(str[cc])) {
-          break;
-        }
-      }
-      dwFractional = (FX_DWORD)(fraction * 4294967296.0);
-    }
-    if (cc < len && (str[cc] == 'E' || str[cc] == 'e')) {
-      cc++;
-      if (cc < len) {
-        if (str[cc] == '+') {
-          cc++;
-        } else if (str[cc] == '-') {
-          bExpSign = TRUE;
-          cc++;
-        }
-      }
-      while (cc < len) {
-        if (str[cc] == '.' || !XFA_IsDigit(str[cc])) {
-          break;
-        }
-        nExponent = nExponent * 10 + str[cc] - '0';
-        cc++;
-      }
-      nExponent = bExpSign ? -nExponent : nExponent;
-    }
-    FX_DOUBLE dValue = (dwFractional / 4294967296.0);
-    dValue = nIntegral + (nIntegral >= 0 ? dValue : -dValue);
-    if (nExponent != 0) {
-      dValue *= FXSYS_pow(10, (FX_FLOAT)nExponent);
-    }
-    return dValue;
-  }
-  return 0;
-}
-CFX_Unitime CXFA_LocaleValue::GetDate() const {
-  if (m_bValid && m_dwType == XFA_VT_DATE) {
-    CFX_Unitime dt;
-    FX_DateFromCanonical(m_wsValue, dt);
-    return dt;
-  }
-  return CFX_Unitime();
-}
-CFX_Unitime CXFA_LocaleValue::GetTime() const {
-  if (m_bValid && m_dwType == XFA_VT_TIME) {
-    CFX_Unitime dt(0);
-    FXSYS_assert(m_pLocaleMgr);
-    FX_TimeFromCanonical(m_wsValue, dt, m_pLocaleMgr->GetDefLocale());
-    return dt;
-  }
-  return CFX_Unitime();
-}
-CFX_Unitime CXFA_LocaleValue::GetDateTime() const {
-  if (m_bValid && m_dwType == XFA_VT_DATETIME) {
-    int32_t index = m_wsValue.Find('T');
-    CFX_Unitime dt;
-    FX_DateFromCanonical(m_wsValue.Left(index), dt);
-    FXSYS_assert(m_pLocaleMgr);
-    FX_TimeFromCanonical(m_wsValue.Right(m_wsValue.GetLength() - index - 1), dt,
-                         m_pLocaleMgr->GetDefLocale());
-    return dt;
-  }
-  return CFX_Unitime();
-}
-FX_BOOL CXFA_LocaleValue::SetText(const CFX_WideString& wsText) {
-  m_dwType = XFA_VT_TEXT;
-  m_wsValue = wsText;
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::SetText(const CFX_WideString& wsText,
-                                  const CFX_WideString& wsFormat,
-                                  IFX_Locale* pLocale) {
-  m_dwType = XFA_VT_TEXT;
-  return m_bValid = ParsePatternValue(wsText, wsFormat, pLocale);
-}
-FX_BOOL CXFA_LocaleValue::SetNum(FX_FLOAT fNum) {
-  m_dwType = XFA_VT_FLOAT;
-  m_wsValue.Format(L"%.8g", (FX_DOUBLE)fNum);
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::SetNum(const CFX_WideString& wsNum,
-                                 const CFX_WideString& wsFormat,
-                                 IFX_Locale* pLocale) {
-  m_dwType = XFA_VT_FLOAT;
-  return m_bValid = ParsePatternValue(wsNum, wsFormat, pLocale);
-}
-FX_BOOL CXFA_LocaleValue::SetDate(const CFX_Unitime& d) {
-  m_dwType = XFA_VT_DATE;
-  m_wsValue.Format(L"%04d-%02d-%02d", d.GetYear(), d.GetMonth(), d.GetDay());
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::SetDate(const CFX_WideString& wsDate,
-                                  const CFX_WideString& wsFormat,
-                                  IFX_Locale* pLocale) {
-  m_dwType = XFA_VT_DATE;
-  return m_bValid = ParsePatternValue(wsDate, wsFormat, pLocale);
-}
-FX_BOOL CXFA_LocaleValue::SetTime(const CFX_Unitime& t) {
-  m_dwType = XFA_VT_TIME;
-  m_wsValue.Format(L"%02d:%02d:%02d", t.GetHour(), t.GetMinute(),
-                   t.GetSecond());
-  if (t.GetMillisecond() > 0) {
-    CFX_WideString wsTemp;
-    wsTemp.Format(L"%:03d", t.GetMillisecond());
-    m_wsValue += wsTemp;
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::SetTime(const CFX_WideString& wsTime,
-                                  const CFX_WideString& wsFormat,
-                                  IFX_Locale* pLocale) {
-  m_dwType = XFA_VT_TIME;
-  return m_bValid = ParsePatternValue(wsTime, wsFormat, pLocale);
-}
-FX_BOOL CXFA_LocaleValue::SetDateTime(const CFX_Unitime& dt) {
-  m_dwType = XFA_VT_DATETIME;
-  m_wsValue.Format(L"%04d-%02d-%02dT%02d:%02d:%02d", dt.GetYear(),
-                   dt.GetMonth(), dt.GetDay(), dt.GetHour(), dt.GetMinute(),
-                   dt.GetSecond());
-  if (dt.GetMillisecond() > 0) {
-    CFX_WideString wsTemp;
-    wsTemp.Format(L"%:03d", dt.GetMillisecond());
-    m_wsValue += wsTemp;
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::SetDateTime(const CFX_WideString& wsDateTime,
-                                      const CFX_WideString& wsFormat,
-                                      IFX_Locale* pLocale) {
-  m_dwType = XFA_VT_DATETIME;
-  return m_bValid = ParsePatternValue(wsDateTime, wsFormat, pLocale);
-}
-FX_BOOL CXFA_LocaleValue::FormatPatterns(CFX_WideString& wsResult,
-                                         const CFX_WideString& wsFormat,
-                                         IFX_Locale* pLocale,
-                                         XFA_VALUEPICTURE eValueType) const {
-  wsResult.Empty();
-  FX_BOOL bRet = FALSE;
-  IFX_FormatString* pFormat = IFX_FormatString::Create(m_pLocaleMgr, FALSE);
-  CFX_WideStringArray wsPatterns;
-  pFormat->SplitFormatString(wsFormat, wsPatterns);
-  int32_t iCount = wsPatterns.GetSize();
-  for (int32_t i = 0; i < iCount; i++) {
-    bRet = FormatSinglePattern(wsResult, wsPatterns[i], pLocale, eValueType);
-    if (bRet) {
-      break;
-    }
-  }
-  pFormat->Release();
-  return bRet;
-}
-FX_BOOL CXFA_LocaleValue::FormatSinglePattern(
-    CFX_WideString& wsResult,
-    const CFX_WideString& wsFormat,
-    IFX_Locale* pLocale,
-    XFA_VALUEPICTURE eValueType) const {
-  IFX_Locale* locale = m_pLocaleMgr->GetDefLocale();
-  if (pLocale) {
-    m_pLocaleMgr->SetDefLocale(pLocale);
-  }
-  wsResult.Empty();
-  FX_BOOL bRet = FALSE;
-  IFX_FormatString* pFormat = IFX_FormatString::Create(m_pLocaleMgr, FALSE);
-  FX_LOCALECATEGORY eCategory = pFormat->GetCategory(wsFormat);
-  eCategory = XFA_ValugeCategory(eCategory, m_dwType);
-  switch (eCategory) {
-    case FX_LOCALECATEGORY_Null:
-      if (m_wsValue.IsEmpty()) {
-        bRet = pFormat->FormatNull(wsFormat, wsResult);
-      }
-      break;
-    case FX_LOCALECATEGORY_Zero:
-      if (m_wsValue == FX_WSTRC(L"0")) {
-        bRet = pFormat->FormatZero(wsFormat, wsResult);
-      }
-      break;
-    case FX_LOCALECATEGORY_Num:
-      bRet = pFormat->FormatNum(m_wsValue, wsFormat, wsResult);
-      break;
-    case FX_LOCALECATEGORY_Text:
-      bRet = pFormat->FormatText(m_wsValue, wsFormat, wsResult);
-      break;
-    case FX_LOCALECATEGORY_Date:
-      bRet = pFormat->FormatDateTime(m_wsValue, wsFormat, wsResult,
-                                     FX_DATETIMETYPE_Date);
-      break;
-    case FX_LOCALECATEGORY_Time:
-      bRet = pFormat->FormatDateTime(m_wsValue, wsFormat, wsResult,
-                                     FX_DATETIMETYPE_Time);
-      break;
-    case FX_LOCALECATEGORY_DateTime:
-      bRet = pFormat->FormatDateTime(m_wsValue, wsFormat, wsResult,
-                                     FX_DATETIMETYPE_DateTime);
-      break;
-    default:
-      wsResult = m_wsValue;
-      bRet = TRUE;
-  }
-  pFormat->Release();
-  if (!bRet && (eCategory != FX_LOCALECATEGORY_Num ||
-                eValueType != XFA_VALUEPICTURE_Display)) {
-    wsResult = m_wsValue;
-  }
-  if (pLocale) {
-    m_pLocaleMgr->SetDefLocale(locale);
-  }
-  return bRet;
-}
-static FX_BOOL XFA_ValueSplitDateTime(const CFX_WideString& wsDateTime,
-                                      CFX_WideString& wsDate,
-                                      CFX_WideString& wsTime) {
-  wsDate = L"";
-  wsTime = L"";
-  if (wsDateTime.IsEmpty()) {
-    return FALSE;
-  }
-  int nSplitIndex = -1;
-  nSplitIndex = wsDateTime.Find('T');
-  if (nSplitIndex < 0) {
-    nSplitIndex = wsDateTime.Find(' ');
-  }
-  if (nSplitIndex < 0) {
-    return FALSE;
-  }
-  wsDate = wsDateTime.Left(nSplitIndex);
-  wsTime = wsDateTime.Right(wsDateTime.GetLength() - nSplitIndex - 1);
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::ValidateCanonicalValue(const CFX_WideString& wsValue,
-                                                 FX_DWORD dwVType) {
-  if (wsValue.IsEmpty()) {
-    return TRUE;
-  }
-  CFX_Unitime dt;
-  switch (dwVType) {
-    case XFA_VT_DATE: {
-      if (ValidateCanonicalDate(wsValue, dt)) {
-        return TRUE;
-      }
-      CFX_WideString wsDate, wsTime;
-      if (XFA_ValueSplitDateTime(wsValue, wsDate, wsTime) &&
-          ValidateCanonicalDate(wsDate, dt)) {
-        return TRUE;
-      }
-      return FALSE;
-    }
-    case XFA_VT_TIME: {
-      if (ValidateCanonicalTime(wsValue)) {
-        return TRUE;
-      }
-      CFX_WideString wsDate, wsTime;
-      if (XFA_ValueSplitDateTime(wsValue, wsDate, wsTime) &&
-          ValidateCanonicalTime(wsTime)) {
-        return TRUE;
-      }
-      return FALSE;
-    }
-    case XFA_VT_DATETIME: {
-      CFX_WideString wsDate, wsTime;
-      if (XFA_ValueSplitDateTime(wsValue, wsDate, wsTime) &&
-          ValidateCanonicalDate(wsDate, dt) && ValidateCanonicalTime(wsTime)) {
-        return TRUE;
-      }
-    } break;
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::ValidateCanonicalDate(const CFX_WideString& wsDate,
-                                                CFX_Unitime& unDate) {
-  const FX_WORD LastDay[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-  const FX_WORD wCountY = 4, wCountM = 2, wCountD = 2;
-  int nLen = wsDate.GetLength();
-  if (nLen < wCountY || nLen > wCountY + wCountM + wCountD + 2) {
-    return FALSE;
-  }
-  const bool bSymbol = wsDate.Find(0x2D) != -1;
-  FX_WORD wYear = 0;
-  FX_WORD wMonth = 0;
-  FX_WORD wDay = 0;
-  const FX_WCHAR* pDate = (const FX_WCHAR*)wsDate;
-  int nIndex = 0, nStart = 0;
-  while (pDate[nIndex] != '\0' && nIndex < wCountY) {
-    if (!XFA_IsDigit(pDate[nIndex])) {
-      return FALSE;
-    }
-    wYear = (pDate[nIndex] - '0') + wYear * 10;
-    nIndex++;
-  }
-  if (bSymbol) {
-    if (pDate[nIndex] != 0x2D) {
-      return FALSE;
-    }
-    nIndex++;
-  }
-  nStart = nIndex;
-  while (pDate[nIndex] != '\0' && nIndex - nStart < wCountM && nIndex < nLen) {
-    if (!XFA_IsDigit(pDate[nIndex])) {
-      return FALSE;
-    }
-    wMonth = (pDate[nIndex] - '0') + wMonth * 10;
-    nIndex++;
-  }
-  if (bSymbol) {
-    if (pDate[nIndex] != 0x2D) {
-      return FALSE;
-    }
-    nIndex++;
-  }
-  nStart = nIndex;
-  while (pDate[nIndex] != '\0' && nIndex - nStart < wCountD && nIndex < nLen) {
-    if (!XFA_IsDigit(pDate[nIndex])) {
-      return FALSE;
-    }
-    wDay = (pDate[nIndex] - '0') + wDay * 10;
-    nIndex++;
-  }
-  if (nIndex != nLen) {
-    return FALSE;
-  }
-  if (wYear < 1900 || wYear > 2029) {
-    return FALSE;
-  }
-  if (wMonth < 1 || wMonth > 12) {
-    if (wMonth == 0 && nLen == wCountY) {
-      return TRUE;
-    }
-    return FALSE;
-  }
-  if (wDay < 1) {
-    if (wDay == 0 && (nLen == wCountY + wCountM)) {
-      return TRUE;
-    }
-    return FALSE;
-  }
-  if (wMonth == 2) {
-    if (wYear % 400 == 0 || (wYear % 100 != 0 && wYear % 4 == 0)) {
-      if (wDay > 29) {
-        return FALSE;
-      }
-    } else {
-      if (wDay > 28) {
-        return FALSE;
-      }
-    }
-  } else if (wDay > LastDay[wMonth - 1]) {
-    return FALSE;
-  }
-  CFX_Unitime ut;
-  ut.Set(wYear, static_cast<uint8_t>(wMonth), static_cast<uint8_t>(wDay));
-  unDate = unDate + ut;
-  return TRUE;
-}
-FX_BOOL CXFA_LocaleValue::ValidateCanonicalTime(const CFX_WideString& wsTime) {
-  int nLen = wsTime.GetLength();
-  if (nLen < 2)
-    return FALSE;
-  const FX_WORD wCountH = 2;
-  const FX_WORD wCountM = 2;
-  const FX_WORD wCountS = 2;
-  const FX_WORD wCountF = 3;
-  const bool bSymbol = wsTime.Find(':') != -1;
-  FX_WORD wHour = 0;
-  FX_WORD wMinute = 0;
-  FX_WORD wSecond = 0;
-  FX_WORD wFraction = 0;
-  const FX_WCHAR* pTime = (const FX_WCHAR*)wsTime;
-  int nIndex = 0;
-  int nStart = 0;
-  while (nIndex - nStart < wCountH && pTime[nIndex]) {
-    if (!XFA_IsDigit(pTime[nIndex]))
-      return FALSE;
-    wHour = pTime[nIndex] - '0' + wHour * 10;
-    nIndex++;
-  }
-  if (bSymbol) {
-    if (nIndex < nLen && pTime[nIndex] != ':')
-      return FALSE;
-    nIndex++;
-  }
-  nStart = nIndex;
-  while (nIndex - nStart < wCountM && nIndex < nLen && pTime[nIndex]) {
-    if (!XFA_IsDigit(pTime[nIndex]))
-      return FALSE;
-    wMinute = pTime[nIndex] - '0' + wMinute * 10;
-    nIndex++;
-  }
-  if (bSymbol) {
-    if (nIndex < nLen && pTime[nIndex] != ':')
-      return FALSE;
-    nIndex++;
-  }
-  nStart = nIndex;
-  while (nIndex - nStart < wCountS && nIndex < nLen && pTime[nIndex]) {
-    if (!XFA_IsDigit(pTime[nIndex]))
-      return FALSE;
-    wSecond = pTime[nIndex] - '0' + wSecond * 10;
-    nIndex++;
-  }
-  if (wsTime.Find('.') > 0) {
-    if (pTime[nIndex] != '.')
-      return FALSE;
-    nIndex++;
-    nStart = nIndex;
-    while (nIndex - nStart < wCountF && nIndex < nLen && pTime[nIndex]) {
-      if (!XFA_IsDigit(pTime[nIndex]))
-        return FALSE;
-      wFraction = pTime[nIndex] - '0' + wFraction * 10;
-      nIndex++;
-    }
-  }
-  if (nIndex < nLen) {
-    if (pTime[nIndex] == 'Z') {
-      nIndex++;
-    } else if (pTime[nIndex] == '-' || pTime[nIndex] == '+') {
-      int16_t nOffsetH = 0;
-      int16_t nOffsetM = 0;
-      nIndex++;
-      nStart = nIndex;
-      while (nIndex - nStart < wCountH && nIndex < nLen && pTime[nIndex]) {
-        if (!XFA_IsDigit(pTime[nIndex]))
-          return FALSE;
-        nOffsetH = pTime[nIndex] - '0' + nOffsetH * 10;
-        nIndex++;
-      }
-      if (bSymbol) {
-        if (nIndex < nLen && pTime[nIndex] != ':')
-          return FALSE;
-        nIndex++;
-      }
-      nStart = nIndex;
-      while (nIndex - nStart < wCountM && nIndex < nLen && pTime[nIndex]) {
-        if (!XFA_IsDigit(pTime[nIndex]))
-          return FALSE;
-        nOffsetM = pTime[nIndex] - '0' + nOffsetM * 10;
-        nIndex++;
-      }
-      if (nOffsetH > 12 || nOffsetM >= 60)
-        return FALSE;
-    }
-  }
-  return nIndex == nLen && wHour < 24 && wMinute < 60 && wSecond < 60 &&
-         wFraction <= 999;
-}
-FX_BOOL CXFA_LocaleValue::ValidateCanonicalDateTime(
-    const CFX_WideString& wsDateTime) {
-  CFX_WideString wsDate, wsTime;
-  if (wsDateTime.IsEmpty()) {
-    return FALSE;
-  }
-  int nSplitIndex = -1;
-  nSplitIndex = wsDateTime.Find('T');
-  if (nSplitIndex < 0) {
-    nSplitIndex = wsDateTime.Find(' ');
-  }
-  if (nSplitIndex < 0) {
-    return FALSE;
-  }
-  wsDate = wsDateTime.Left(nSplitIndex);
-  wsTime = wsDateTime.Right(wsDateTime.GetLength() - nSplitIndex - 1);
-  CFX_Unitime dt;
-  return ValidateCanonicalDate(wsDate, dt) && ValidateCanonicalTime(wsTime);
-}
-FX_BOOL CXFA_LocaleValue::ParsePatternValue(const CFX_WideString& wsValue,
-                                            const CFX_WideString& wsPattern,
-                                            IFX_Locale* pLocale) {
-  IFX_Locale* locale = m_pLocaleMgr->GetDefLocale();
-  if (pLocale) {
-    m_pLocaleMgr->SetDefLocale(pLocale);
-  }
-  IFX_FormatString* pFormat = IFX_FormatString::Create(m_pLocaleMgr, FALSE);
-  CFX_WideStringArray wsPatterns;
-  pFormat->SplitFormatString(wsPattern, wsPatterns);
-  FX_BOOL bRet = FALSE;
-  int32_t iCount = wsPatterns.GetSize();
-  for (int32_t i = 0; i < iCount && !bRet; i++) {
-    CFX_WideString wsFormat = wsPatterns[i];
-    FX_LOCALECATEGORY eCategory = pFormat->GetCategory(wsFormat);
-    eCategory = XFA_ValugeCategory(eCategory, m_dwType);
-    switch (eCategory) {
-      case FX_LOCALECATEGORY_Null:
-        bRet = pFormat->ParseNull(wsValue, wsFormat);
-        if (bRet) {
-          m_wsValue.Empty();
-        }
-        break;
-      case FX_LOCALECATEGORY_Zero:
-        bRet = pFormat->ParseZero(wsValue, wsFormat);
-        if (bRet) {
-          m_wsValue = FX_WSTRC(L"0");
-        }
-        break;
-      case FX_LOCALECATEGORY_Num: {
-        CFX_WideString fNum;
-        bRet = pFormat->ParseNum(wsValue, wsFormat, fNum);
-        if (bRet) {
-          m_wsValue = fNum;
-        }
-        break;
-      }
-      case FX_LOCALECATEGORY_Text:
-        bRet = pFormat->ParseText(wsValue, wsFormat, m_wsValue);
-        break;
-      case FX_LOCALECATEGORY_Date: {
-        CFX_Unitime dt;
-        bRet = ValidateCanonicalDate(wsValue, dt);
-        if (!bRet) {
-          bRet = pFormat->ParseDateTime(wsValue, wsFormat, FX_DATETIMETYPE_Date,
-                                        dt);
-        }
-        if (bRet) {
-          SetDate(dt);
-        }
-        break;
-      }
-      case FX_LOCALECATEGORY_Time: {
-        CFX_Unitime dt;
-        bRet =
-            pFormat->ParseDateTime(wsValue, wsFormat, FX_DATETIMETYPE_Time, dt);
-        if (bRet) {
-          SetTime(dt);
-        }
-        break;
-      }
-      case FX_LOCALECATEGORY_DateTime: {
-        CFX_Unitime dt;
-        bRet = pFormat->ParseDateTime(wsValue, wsFormat,
-                                      FX_DATETIMETYPE_DateTime, dt);
-        if (bRet) {
-          SetDateTime(dt);
-        }
-        break;
-      }
-      default:
-        m_wsValue = wsValue;
-        bRet = TRUE;
-        break;
-    }
-  }
-  if (!bRet) {
-    m_wsValue = wsValue;
-  }
-  pFormat->Release();
-  if (pLocale) {
-    m_pLocaleMgr->SetDefLocale(locale);
-  }
-  return bRet;
-}
-void CXFA_LocaleValue::GetNumbericFormat(CFX_WideString& wsFormat,
-                                         int32_t nIntLen,
-                                         int32_t nDecLen,
-                                         FX_BOOL bSign) {
-  FXSYS_assert(wsFormat.IsEmpty());
-  FXSYS_assert(nIntLen >= -1 && nDecLen >= -1);
-  int32_t nTotalLen = (nIntLen >= 0 ? nIntLen : 2) + (bSign ? 1 : 0) +
-                      (nDecLen >= 0 ? nDecLen : 2) + (nDecLen == 0 ? 0 : 1);
-  FX_WCHAR* lpBuf = wsFormat.GetBuffer(nTotalLen);
-  int32_t nPos = 0;
-  if (bSign) {
-    lpBuf[nPos++] = L's';
-  }
-  if (nIntLen == -1) {
-    lpBuf[nPos++] = L'z';
-    lpBuf[nPos++] = L'*';
-  } else {
-    while (nIntLen) {
-      lpBuf[nPos++] = L'z';
-      nIntLen--;
-    }
-  }
-  if (nDecLen != 0) {
-    lpBuf[nPos++] = L'.';
-  }
-  if (nDecLen == -1) {
-    lpBuf[nPos++] = L'z';
-    lpBuf[nPos++] = L'*';
-  } else {
-    while (nDecLen) {
-      lpBuf[nPos++] = L'z';
-      nDecLen--;
-    }
-  }
-  wsFormat.ReleaseBuffer(nTotalLen);
-}
-FX_BOOL CXFA_LocaleValue::ValidateNumericTemp(CFX_WideString& wsNumeric,
-                                              CFX_WideString& wsFormat,
-                                              IFX_Locale* pLocale,
-                                              int32_t* pos) {
-  if (wsFormat.IsEmpty() || wsNumeric.IsEmpty()) {
-    return TRUE;
-  }
-  const FX_WCHAR* pNum = wsNumeric.c_str();
-  const FX_WCHAR* pFmt = wsFormat.c_str();
-  int32_t n = 0, nf = 0;
-  FX_WCHAR c = pNum[n];
-  FX_WCHAR cf = pFmt[nf];
-  if (cf == L's') {
-    if (c == L'-' || c == L'+') {
-      ++n;
-    }
-    ++nf;
-  }
-  FX_BOOL bLimit = TRUE;
-  int32_t nCount = wsNumeric.GetLength();
-  int32_t nCountFmt = wsFormat.GetLength();
-  while (n < nCount && (bLimit ? nf < nCountFmt : TRUE) &&
-         XFA_IsDigit(c = pNum[n])) {
-    if (bLimit == TRUE) {
-      if ((cf = pFmt[nf]) == L'*') {
-        bLimit = FALSE;
-      } else if (cf == L'z') {
-        nf++;
-      } else {
-        return FALSE;
-      }
-    }
-    n++;
-  }
-  if (n == nCount) {
-    return TRUE;
-  }
-  if (nf == nCountFmt) {
-    return FALSE;
-  }
-  while (nf < nCountFmt && (cf = pFmt[nf]) != L'.') {
-    FXSYS_assert(cf == L'z' || cf == L'*');
-    ++nf;
-  }
-  CFX_WideString wsDecimalSymbol;
-  if (pLocale) {
-    pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Decimal, wsDecimalSymbol);
-  } else {
-    wsDecimalSymbol = CFX_WideString(L'.');
-  }
-  if (pFmt[nf] != L'.') {
-    return FALSE;
-  }
-  if (wsDecimalSymbol != CFX_WideStringC(c) && c != L'.') {
-    return FALSE;
-  }
-  ++nf;
-  ++n;
-  bLimit = TRUE;
-  while (n < nCount && (bLimit ? nf < nCountFmt : TRUE) &&
-         XFA_IsDigit(c = pNum[n])) {
-    if (bLimit == TRUE) {
-      if ((cf = pFmt[nf]) == L'*') {
-        bLimit = FALSE;
-      } else if (cf == L'z') {
-        nf++;
-      } else {
-        return FALSE;
-      }
-    }
-    n++;
-  }
-  return n == nCount;
-}
diff --git a/xfa/src/fxfa/parser/xfa_localevalue.h b/xfa/src/fxfa/parser/xfa_localevalue.h
deleted file mode 100644
index bcdf037fcd..0000000000
--- a/xfa/src/fxfa/parser/xfa_localevalue.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_LOCALEVALUE_H_
-#define XFA_SRC_FXFA_PARSER_XFA_LOCALEVALUE_H_
-
-#include "xfa/include/fxfa/fxfa_objectacc.h"
-
-class IFX_Locale;
-class CFX_Unitime;
-class CXFA_LocaleMgr;
-
-#define XFA_VT_NULL 0
-#define XFA_VT_BOOLEAN 1
-#define XFA_VT_INTEGER 2
-#define XFA_VT_DECIMAL 4
-#define XFA_VT_FLOAT 8
-#define XFA_VT_TEXT 16
-#define XFA_VT_DATE 32
-#define XFA_VT_TIME 64
-#define XFA_VT_DATETIME 128
-
-class CXFA_LocaleValue {
- public:
-  CXFA_LocaleValue();
-  CXFA_LocaleValue(const CXFA_LocaleValue& value);
-  CXFA_LocaleValue(FX_DWORD dwType, CXFA_LocaleMgr* pLocaleMgr);
-  CXFA_LocaleValue(FX_DWORD dwType,
-                   const CFX_WideString& wsValue,
-                   CXFA_LocaleMgr* pLocaleMgr);
-  CXFA_LocaleValue(FX_DWORD dwType,
-                   const CFX_WideString& wsValue,
-                   const CFX_WideString& wsFormat,
-                   IFX_Locale* pLocale,
-                   CXFA_LocaleMgr* pLocaleMgr);
-  ~CXFA_LocaleValue();
-  CXFA_LocaleValue& operator=(const CXFA_LocaleValue& value);
-
-  FX_BOOL ValidateValue(const CFX_WideString& wsValue,
-                        const CFX_WideString& wsPattern,
-                        IFX_Locale* pLocale,
-                        CFX_WideString* pMatchFormat = NULL);
-  FX_BOOL FormatPatterns(CFX_WideString& wsResult,
-                         const CFX_WideString& wsFormat,
-                         IFX_Locale* pLocale,
-                         XFA_VALUEPICTURE eValueType) const;
-  FX_BOOL FormatSinglePattern(CFX_WideString& wsResult,
-                              const CFX_WideString& wsFormat,
-                              IFX_Locale* pLocale,
-                              XFA_VALUEPICTURE eValueType) const;
-  FX_BOOL ValidateCanonicalValue(const CFX_WideString& wsValue,
-                                 FX_DWORD dwVType);
-  FX_BOOL ValidateCanonicalDate(const CFX_WideString& wsDate,
-                                CFX_Unitime& unDate);
-  FX_BOOL ValidateCanonicalTime(const CFX_WideString& wsTime);
-  FX_BOOL ValidateCanonicalDateTime(const CFX_WideString& wsDateTime);
-  void GetNumbericFormat(CFX_WideString& wsFormat,
-                         int32_t nIntLen,
-                         int32_t nDecLen,
-                         FX_BOOL bSign = TRUE);
-  FX_BOOL ValidateNumericTemp(CFX_WideString& wsNumeric,
-                              CFX_WideString& wsFormat,
-                              IFX_Locale* pLocale = NULL,
-                              int32_t* pos = NULL);
-
-  CFX_WideString GetValue() const;
-  FX_DWORD GetType() const;
-  void SetValue(const CFX_WideString& wsValue, FX_DWORD dwType);
-  CFX_WideString GetText() const;
-  FX_FLOAT GetNum() const;
-  FX_DOUBLE GetDoubleNum() const;
-  CFX_Unitime GetDate() const;
-  CFX_Unitime GetTime() const;
-  CFX_Unitime GetDateTime() const;
-  FX_BOOL SetText(const CFX_WideString& wsText);
-  FX_BOOL SetText(const CFX_WideString& wsText,
-                  const CFX_WideString& wsFormat,
-                  IFX_Locale* pLocale);
-  FX_BOOL SetNum(FX_FLOAT fNum);
-  FX_BOOL SetNum(const CFX_WideString& wsNum,
-                 const CFX_WideString& wsFormat,
-                 IFX_Locale* pLocale);
-  FX_BOOL SetDate(const CFX_Unitime& d);
-  FX_BOOL SetDate(const CFX_WideString& wsDate,
-                  const CFX_WideString& wsFormat,
-                  IFX_Locale* pLocale);
-  FX_BOOL SetTime(const CFX_Unitime& t);
-  FX_BOOL SetTime(const CFX_WideString& wsTime,
-                  const CFX_WideString& wsFormat,
-                  IFX_Locale* pLocale);
-  FX_BOOL SetDateTime(const CFX_Unitime& dt);
-  FX_BOOL SetDateTime(const CFX_WideString& wsDateTime,
-                      const CFX_WideString& wsFormat,
-                      IFX_Locale* pLocale);
-  bool IsNull() const { return m_dwType == XFA_VT_NULL; }
-  FX_BOOL IsEmpty() const { return m_wsValue.IsEmpty(); }
-  FX_BOOL IsValid() const { return m_bValid; }
-
- protected:
-  FX_BOOL ParsePatternValue(const CFX_WideString& wsValue,
-                            const CFX_WideString& wsPattern,
-                            IFX_Locale* pLocale);
-  CXFA_LocaleMgr* m_pLocaleMgr;
-  CFX_WideString m_wsValue;
-  FX_DWORD m_dwType;
-  FX_BOOL m_bValid;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_LOCALEVALUE_H_
diff --git a/xfa/src/fxfa/parser/xfa_object.h b/xfa/src/fxfa/parser/xfa_object.h
deleted file mode 100644
index 949ca8739f..0000000000
--- a/xfa/src/fxfa/parser/xfa_object.h
+++ /dev/null
@@ -1,803 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_OBJECT_H_
-#define XFA_SRC_FXFA_PARSER_XFA_OBJECT_H_
-
-#include "xfa/src/fde/xml/fde_xml.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-class CXFA_Document;
-class CXFA_Node;
-class CXFA_NodeList;
-class CXFA_OrdinaryObject;
-
-enum XFA_OBJECTTYPE {
-  XFA_OBJECTTYPE_OrdinaryObject = 0x0,
-  XFA_OBJECTTYPE_OrdinaryList = 0x1,
-  XFA_OBJECTTYPE_NodeList = 0x2,
-  XFA_OBJECTTYPE_Node = 0x4,
-  XFA_OBJECTTYPE_NodeC = 0x5,
-  XFA_OBJECTTYPE_NodeV = 0x6,
-  XFA_OBJECTTYPE_ModelNode = 0x8,
-  XFA_OBJECTTYPE_TextNode = 0x9,
-  XFA_OBJECTTYPE_ContainerNode = 0xA,
-  XFA_OBJECTTYPE_ContentNode = 0xB,
-  XFA_OBJECTTYPE_VariablesThis = 0xC,
-  XFA_OBJECTTYPEMASK = 0xF,
-  XFA_NODEFLAG_Initialized = 0x00020,
-  XFA_NODEFLAG_HasRemoved = 0x00200,
-  XFA_NODEFLAG_NeedsInitApp = 0x00400,
-  XFA_NODEFLAG_BindFormItems = 0x00800,
-  XFA_NODEFLAG_UserInteractive = 0x01000,
-  XFA_NODEFLAG_SkipDataBinding = 0x02000,
-  XFA_NODEFLAG_OwnXMLNode = 0x04000,
-  XFA_NODEFLAG_UnusedNode = 0x08000,
-  XFA_NODEFLAG_LayoutGeneratedNode = 0x10000,
-};
-class CXFA_Object {
- public:
-  CXFA_Object(CXFA_Document* pDocument, FX_DWORD uFlags);
-  CXFA_Document* GetDocument() const { return m_pDocument; }
-  FX_DWORD GetFlag() const { return m_uFlags; }
-  XFA_OBJECTTYPE GetObjectType() const {
-    return (XFA_OBJECTTYPE)(m_uFlags & XFA_OBJECTTYPEMASK);
-  }
-
-  FX_BOOL IsNode() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) >= XFA_OBJECTTYPE_Node;
-  }
-  FX_BOOL IsOrdinaryObject() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_OrdinaryObject;
-  }
-  FX_BOOL IsNodeList() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_NodeList;
-  }
-  FX_BOOL IsOrdinaryList() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_OrdinaryList;
-  }
-  FX_BOOL IsContentNode() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_ContentNode;
-  }
-  FX_BOOL IsContainerNode() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_ContainerNode;
-  }
-
-  CXFA_Node* AsNode();
-  CXFA_OrdinaryObject* AsOrdinaryObject();
-  CXFA_NodeList* AsNodeList();
-
-  const CXFA_Node* AsNode() const;
-  const CXFA_OrdinaryObject* AsOrdinaryObject() const;
-  const CXFA_NodeList* AsNodeList() const;
-
-  XFA_ELEMENT GetClassID() const;
-  void GetClassName(CFX_WideStringC& wsName) const;
-  uint32_t GetClassHashCode() const;
-  void Script_ObjectClass_ClassName(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void ThrowScriptErrorMessage(int32_t iStringID, ...);
-
- protected:
-  CXFA_Document* const m_pDocument;
-  FX_DWORD m_uFlags;
-};
-
-#define XFA_NODEFILTER_Children 0x01
-#define XFA_NODEFILTER_Properties 0x02
-#define XFA_NODEFILTER_OneOfProperty 0x04
-#define XFA_CLONEFLAG_Content 0x01
-enum XFA_NODEITEM {
-  XFA_NODEITEM_Parent,
-  XFA_NODEITEM_FirstChild,
-  XFA_NODEITEM_NextSibling,
-  XFA_NODEITEM_PrevSibling,
-};
-enum XFA_SOM_MESSAGETYPE {
-  XFA_SOM_ValidationMessage,
-  XFA_SOM_FormatMessage,
-  XFA_SOM_MandatoryMessage
-};
-
-typedef CFX_ArrayTemplate<CXFA_Node*> CXFA_NodeArray;
-typedef CFX_StackTemplate<CXFA_Node*> CXFA_NodeStack;
-typedef CXFA_PtrSetTemplate<CXFA_Node*> CXFA_NodeSet;
-typedef void (*PD_CALLBACK_DUPLICATEDATA)(void*& pData);
-
-struct XFA_MAPDATABLOCKCALLBACKINFO {
-  PD_CALLBACK_FREEDATA pFree;
-  PD_CALLBACK_DUPLICATEDATA pCopy;
-};
-
-struct XFA_MAPDATABLOCK {
-  uint8_t* GetData() const { return (uint8_t*)this + sizeof(XFA_MAPDATABLOCK); }
-  XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo;
-  int32_t iBytes;
-};
-
-struct XFA_MAPMODULEDATA {
-  CFX_MapPtrToPtr m_ValueMap;
-  CFX_MapPtrTemplate<void*, XFA_MAPDATABLOCK*> m_BufferMap;
-};
-
-#define XFA_CalcRefCount (void*)(uintptr_t) FXBSTR_ID('X', 'F', 'A', 'R')
-#define XFA_CalcData (void*)(uintptr_t) FXBSTR_ID('X', 'F', 'A', 'C')
-#define XFA_LAYOUTITEMKEY (void*)(uintptr_t) FXBSTR_ID('L', 'Y', 'I', 'M')
-class CXFA_Node : public CXFA_Object {
- public:
-  XFA_ELEMENT GetClassID() const { return (XFA_ELEMENT)m_eNodeClass; }
-  FX_DWORD GetPacketID() const { return m_ePacket; }
-  FX_BOOL HasFlag(FX_DWORD dwFlag) const;
-  void SetFlag(FX_DWORD dwFlag, FX_BOOL bOn = TRUE, FX_BOOL bNotify = TRUE);
-  FX_BOOL IsAttributeInXML();
-  FX_BOOL IsFormContainer() {
-    return m_ePacket == XFA_XDPPACKET_Form && IsContainerNode();
-  }
-  void SetXMLMappingNode(IFDE_XMLNode* pXMLNode) { m_pXMLNode = pXMLNode; }
-  IFDE_XMLNode* GetXMLMappingNode() const { return m_pXMLNode; }
-  IFDE_XMLNode* CreateXMLMappingNode();
-  FX_BOOL IsNeedSavingXMLNode();
-  FX_DWORD GetNameHash() const { return m_dwNameHash; }
-  bool IsUnnamed() const { return m_dwNameHash == 0; }
-  CXFA_Node* GetModelNode();
-  void UpdateNameHash();
-  FX_BOOL HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit = FALSE);
-  FX_BOOL SetAttribute(XFA_ATTRIBUTE eAttr,
-                       const CFX_WideStringC& wsValue,
-                       FX_BOOL bNotify = FALSE);
-  FX_BOOL GetAttribute(XFA_ATTRIBUTE eAttr,
-                       CFX_WideString& wsValue,
-                       FX_BOOL bUseDefault = TRUE);
-  FX_BOOL SetAttribute(const CFX_WideStringC& wsAttr,
-                       const CFX_WideStringC& wsValue,
-                       FX_BOOL bNotify = FALSE);
-  FX_BOOL GetAttribute(const CFX_WideStringC& wsAttr,
-                       CFX_WideString& wsValue,
-                       FX_BOOL bUseDefault = TRUE);
-  FX_BOOL RemoveAttribute(const CFX_WideStringC& wsAttr);
-  FX_BOOL SetContent(const CFX_WideString& wsContent,
-                     const CFX_WideString& wsXMLValue,
-                     FX_BOOL bNotify = FALSE,
-                     FX_BOOL bScriptModify = FALSE,
-                     FX_BOOL bSyncData = TRUE);
-  FX_BOOL TryContent(CFX_WideString& wsContent,
-                     FX_BOOL bScriptModify = FALSE,
-                     FX_BOOL bProto = TRUE);
-  CFX_WideString GetContent();
-
-  FX_BOOL TryNamespace(CFX_WideString& wsNamespace);
-
-  FX_BOOL SetBoolean(XFA_ATTRIBUTE eAttr,
-                     FX_BOOL bValue,
-                     FX_BOOL bNotify = FALSE) {
-    return SetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, (void*)(uintptr_t)bValue,
-                    bNotify);
-  }
-  FX_BOOL TryBoolean(XFA_ATTRIBUTE eAttr,
-                     FX_BOOL& bValue,
-                     FX_BOOL bUseDefault = TRUE);
-  FX_BOOL GetBoolean(XFA_ATTRIBUTE eAttr) {
-    FX_BOOL bValue;
-    return TryBoolean(eAttr, bValue, TRUE) ? bValue : FALSE;
-  }
-  FX_BOOL SetInteger(XFA_ATTRIBUTE eAttr,
-                     int32_t iValue,
-                     FX_BOOL bNotify = FALSE) {
-    return SetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, (void*)(uintptr_t)iValue,
-                    bNotify);
-  }
-  FX_BOOL TryInteger(XFA_ATTRIBUTE eAttr,
-                     int32_t& iValue,
-                     FX_BOOL bUseDefault = TRUE);
-  int32_t GetInteger(XFA_ATTRIBUTE eAttr) {
-    int32_t iValue;
-    return TryInteger(eAttr, iValue, TRUE) ? iValue : 0;
-  }
-  FX_BOOL SetEnum(XFA_ATTRIBUTE eAttr,
-                  XFA_ATTRIBUTEENUM eValue,
-                  FX_BOOL bNotify = FALSE) {
-    return SetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, (void*)(uintptr_t)eValue,
-                    bNotify);
-  }
-  FX_BOOL TryEnum(XFA_ATTRIBUTE eAttr,
-                  XFA_ATTRIBUTEENUM& eValue,
-                  FX_BOOL bUseDefault = TRUE);
-  XFA_ATTRIBUTEENUM GetEnum(XFA_ATTRIBUTE eAttr) {
-    XFA_ATTRIBUTEENUM eValue;
-    return TryEnum(eAttr, eValue, TRUE) ? eValue : XFA_ATTRIBUTEENUM_Unknown;
-  }
-  FX_BOOL SetCData(XFA_ATTRIBUTE eAttr,
-                   const CFX_WideString& wsValue,
-                   FX_BOOL bNotify = FALSE,
-                   FX_BOOL bScriptModify = FALSE);
-  FX_BOOL SetAttributeValue(const CFX_WideString& wsValue,
-                            const CFX_WideString& wsXMLValue,
-                            FX_BOOL bNotify = FALSE,
-                            FX_BOOL bScriptModify = FALSE);
-  FX_BOOL TryCData(XFA_ATTRIBUTE eAttr,
-                   CFX_WideString& wsValue,
-                   FX_BOOL bUseDefault = TRUE,
-                   FX_BOOL bProto = TRUE);
-  FX_BOOL TryCData(XFA_ATTRIBUTE eAttr,
-                   CFX_WideStringC& wsValue,
-                   FX_BOOL bUseDefault = TRUE,
-                   FX_BOOL bProto = TRUE);
-  CFX_WideStringC GetCData(XFA_ATTRIBUTE eAttr) {
-    CFX_WideStringC wsValue;
-    return TryCData(eAttr, wsValue) ? wsValue : CFX_WideStringC();
-  }
-  FX_BOOL SetMeasure(XFA_ATTRIBUTE eAttr,
-                     CXFA_Measurement mValue,
-                     FX_BOOL bNotify = FALSE);
-  FX_BOOL TryMeasure(XFA_ATTRIBUTE eAttr,
-                     CXFA_Measurement& mValue,
-                     FX_BOOL bUseDefault = TRUE) const;
-  CXFA_Measurement GetMeasure(XFA_ATTRIBUTE eAttr) const;
-  FX_BOOL SetObject(XFA_ATTRIBUTE eAttr,
-                    void* pData,
-                    XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo = NULL);
-  FX_BOOL TryObject(XFA_ATTRIBUTE eAttr, void*& pData);
-  void* GetObject(XFA_ATTRIBUTE eAttr) {
-    void* pData;
-    return TryObject(eAttr, pData) ? pData : NULL;
-  }
-  FX_BOOL SetUserData(void* pKey,
-                      void* pData,
-                      XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo = NULL);
-  FX_BOOL TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso = FALSE);
-  void* GetUserData(void* pKey, FX_BOOL bProtoAlso = FALSE) {
-    void* pData;
-    return TryUserData(pKey, pData, bProtoAlso) ? pData : NULL;
-  }
-  CXFA_Node* GetProperty(int32_t index,
-                         XFA_ELEMENT eProperty,
-                         FX_BOOL bCreateProperty = TRUE);
-  int32_t CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild = FALSE);
-  CXFA_Node* GetChild(int32_t index,
-                      XFA_ELEMENT eElement,
-                      FX_BOOL bOnlyChild = FALSE);
-  int32_t InsertChild(int32_t index, CXFA_Node* pNode);
-  FX_BOOL InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode = NULL);
-  FX_BOOL RemoveChild(CXFA_Node* pNode, FX_BOOL bNotify = TRUE);
-  CXFA_Node* Clone(FX_BOOL bRecursive);
-  CXFA_Node* GetNodeItem(XFA_NODEITEM eItem) const;
-  CXFA_Node* GetNodeItem(XFA_NODEITEM eItem, XFA_OBJECTTYPE eType) const;
-  int32_t GetNodeList(CXFA_NodeArray& nodes,
-                      FX_DWORD dwTypeFilter = XFA_NODEFILTER_Children |
-                                              XFA_NODEFILTER_Properties,
-                      XFA_ELEMENT eElementFilter = XFA_ELEMENT_UNKNOWN,
-                      int32_t iLevel = 1);
-  CXFA_Node* CreateSamePacketNode(XFA_ELEMENT eElement,
-                                  FX_DWORD dwFlags = XFA_NODEFLAG_Initialized);
-  CXFA_Node* CloneTemplateToForm(FX_BOOL bRecursive);
-  CXFA_Node* GetTemplateNode() const;
-  void SetTemplateNode(CXFA_Node* pTemplateNode);
-  CXFA_Node* GetDataDescriptionNode();
-  void SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode);
-  CXFA_Node* GetBindData();
-  int32_t GetBindItems(CXFA_NodeArray& formItems);
-  int32_t AddBindItem(CXFA_Node* pFormNode);
-  int32_t RemoveBindItem(CXFA_Node* pFormNode);
-  FX_BOOL HasBindItem();
-  CXFA_WidgetData* GetWidgetData();
-  CXFA_WidgetData* GetContainerWidgetData();
-  FX_BOOL GetLocaleName(CFX_WideString& wsLocaleName);
-  XFA_ATTRIBUTEENUM GetIntact();
-  CXFA_Node* GetFirstChildByName(const CFX_WideStringC& wsNodeName) const;
-  CXFA_Node* GetFirstChildByName(FX_DWORD dwNodeNameHash) const;
-  CXFA_Node* GetFirstChildByClass(XFA_ELEMENT eNodeClass) const;
-  CXFA_Node* GetNextSameNameSibling(FX_DWORD dwNodeNameHash) const;
-  CXFA_Node* GetNextSameNameSibling(const CFX_WideStringC& wsNodeName) const;
-  CXFA_Node* GetNextSameClassSibling(XFA_ELEMENT eNodeClass) const;
-  int32_t GetNodeSameNameIndex() const;
-  int32_t GetNodeSameClassIndex() const;
-  void GetSOMExpression(CFX_WideString& wsSOMExpression);
-  CXFA_Node* GetInstanceMgrOfSubform();
-
-  CXFA_Node* GetOccurNode();
-  void Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments);
-  void Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments);
-  void Script_Som_ResolveNodeList(FXJSE_HVALUE hValue,
-                                  CFX_WideString wsExpression,
-                                  FX_DWORD dwFlag,
-                                  CXFA_Node* refNode = NULL);
-  void Script_TreeClass_All(FXJSE_HVALUE hValue,
-                            FX_BOOL bSetting,
-                            XFA_ATTRIBUTE eAttribute);
-  void Script_TreeClass_Nodes(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_TreeClass_ClassAll(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute);
-  void Script_TreeClass_Parent(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-  void Script_TreeClass_Index(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_TreeClass_ClassIndex(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_TreeClass_SomExpression(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_Clone(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_IsPropertySpecified(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments);
-  void Script_NodeClass_Ns(FXJSE_HVALUE hValue,
-                           FX_BOOL bSetting,
-                           XFA_ATTRIBUTE eAttribute);
-  void Script_NodeClass_Model(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_NodeClass_IsContainer(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void Script_NodeClass_IsNull(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-  void Script_NodeClass_OneOfChild(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments);
-  void Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments);
-  void Script_ModelClass_ClearErrorList(CFXJSE_Arguments* pArguments);
-  void Script_ModelClass_CreateNode(CFXJSE_Arguments* pArguments);
-  void Script_ModelClass_IsCompatibleNS(CFXJSE_Arguments* pArguments);
-  void Script_ModelClass_Context(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute);
-  void Script_ModelClass_AliasNode(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments);
-  void Script_Delta_Restore(CFXJSE_Arguments* pArguments);
-  void Script_Delta_CurrentValue(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute);
-  void Script_Delta_SavedValue(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-  void Script_Delta_Target(FXJSE_HVALUE hValue,
-                           FX_BOOL bSetting,
-                           XFA_ATTRIBUTE eAttribute);
-  void Script_Attribute_SendAttributeChangeMessage(void* eAttribute,
-                                                   void* eValue,
-                                                   FX_BOOL bScriptModify);
-  void Script_Attribute_Integer(FXJSE_HVALUE hValue,
-                                FX_BOOL bSetting,
-                                XFA_ATTRIBUTE eAttribute);
-  void Script_Attribute_IntegerRead(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void Script_Attribute_BOOL(FXJSE_HVALUE hValue,
-                             FX_BOOL bSetting,
-                             XFA_ATTRIBUTE eAttribute);
-  void Script_Attribute_BOOLRead(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute);
-  void Script_Attribute_String(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-  void Script_Attribute_StringRead(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_Som_ValidationMessage(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void Script_Field_Length(FXJSE_HVALUE hValue,
-                           FX_BOOL bSetting,
-                           XFA_ATTRIBUTE eAttribute);
-  void Script_Som_DefaultValue(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-  void Script_Som_DefaultValue_Read(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void Script_Boolean_Value(FXJSE_HVALUE hValue,
-                            FX_BOOL bSetting,
-                            XFA_ATTRIBUTE eAttribute);
-  void Script_Som_Message(FXJSE_HVALUE hValue,
-                          FX_BOOL bSetting,
-                          XFA_SOM_MESSAGETYPE iMessageType);
-  void Script_Som_BorderColor(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_Som_BorderWidth(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_Som_FillColor(FXJSE_HVALUE hValue,
-                            FX_BOOL bSetting,
-                            XFA_ATTRIBUTE eAttribute);
-  void Script_Som_DataNode(FXJSE_HVALUE hValue,
-                           FX_BOOL bSetting,
-                           XFA_ATTRIBUTE eAttribute);
-  void Script_Som_FontColor(FXJSE_HVALUE hValue,
-                            FX_BOOL bSetting,
-                            XFA_ATTRIBUTE eAttribute);
-  void Script_Som_Mandatory(FXJSE_HVALUE hValue,
-                            FX_BOOL bSetting,
-                            XFA_ATTRIBUTE eAttribute);
-  void Script_Som_MandatoryMessage(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_Som_InstanceIndex(FXJSE_HVALUE hValue,
-                                FX_BOOL bSetting,
-                                XFA_ATTRIBUTE eAttribute);
-  void Script_Draw_DefaultValue(FXJSE_HVALUE hValue,
-                                FX_BOOL bSetting,
-                                XFA_ATTRIBUTE eAttribute);
-  void Script_Field_DefaultValue(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute);
-  void Script_Field_EditValue(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_Field_FormatMessage(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_Field_FormattedValue(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_Field_ParentSubform(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_Field_SelectedIndex(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_Field_ClearItems(CFXJSE_Arguments* pArguments);
-  void Script_Field_ExecEvent(CFXJSE_Arguments* pArguments);
-  void Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments);
-  void Script_Field_DeleteItem(CFXJSE_Arguments* pArguments);
-  void Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments);
-  void Script_Field_BoundItem(CFXJSE_Arguments* pArguments);
-  void Script_Field_GetItemState(CFXJSE_Arguments* pArguments);
-  void Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments);
-  void Script_Field_SetItems(CFXJSE_Arguments* pArguments);
-  void Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments);
-  void Script_Field_SetItemState(CFXJSE_Arguments* pArguments);
-  void Script_Field_AddItem(CFXJSE_Arguments* pArguments);
-  void Script_Field_ExecValidate(CFXJSE_Arguments* pArguments);
-  void Script_ExclGroup_DefaultAndRawValue(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute);
-  void Script_ExclGroup_ErrorText(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_ExclGroup_Transient(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments);
-  void Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments);
-  void Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments);
-  void Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments);
-  void Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments);
-  void Script_Subform_InstanceManager(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_Subform_Locale(FXJSE_HVALUE hValue,
-                             FX_BOOL bSetting,
-                             XFA_ATTRIBUTE eAttribute);
-  void Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments);
-  void Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments);
-  void Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments);
-  void Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments);
-  void Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments);
-
-  int32_t Subform_and_SubformSet_InstanceIndex();
-  void Script_Template_FormNodes(CFXJSE_Arguments* pArguments);
-  void Script_Template_Remerge(CFXJSE_Arguments* pArguments);
-  void Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments);
-  void Script_Template_CreateNode(CFXJSE_Arguments* pArguments);
-  void Script_Template_Recalculate(CFXJSE_Arguments* pArguments);
-  void Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments);
-  void Script_Template_ExecValidate(CFXJSE_Arguments* pArguments);
-  void Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments);
-  void Script_InstanceManager_Count(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void Script_InstanceManager_Max(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_InstanceManager_Min(FXJSE_HVALUE hValue,
-                                  FX_BOOL bSetting,
-                                  XFA_ATTRIBUTE eAttribute);
-  void Script_InstanceManager_MoveInstance(CFXJSE_Arguments* pArguments);
-  void Script_InstanceManager_RemoveInstance(CFXJSE_Arguments* pArguments);
-  void Script_InstanceManager_SetInstances(CFXJSE_Arguments* pArguments);
-  void Script_InstanceManager_AddInstance(CFXJSE_Arguments* pArguments);
-  void Script_InstanceManager_InsertInstance(CFXJSE_Arguments* pArguments);
-  int32_t InstanceManager_SetInstances(int32_t iCount);
-  int32_t InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom);
-  void Script_Occur_Max(FXJSE_HVALUE hValue,
-                        FX_BOOL bSetting,
-                        XFA_ATTRIBUTE eAttribute);
-  void Script_Occur_Min(FXJSE_HVALUE hValue,
-                        FX_BOOL bSetting,
-                        XFA_ATTRIBUTE eAttribute);
-  void Script_Desc_Metadata(CFXJSE_Arguments* pArguments);
-  void Script_Form_FormNodes(CFXJSE_Arguments* pArguments);
-  void Script_Form_Remerge(CFXJSE_Arguments* pArguments);
-  void Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments);
-  void Script_Form_Recalculate(CFXJSE_Arguments* pArguments);
-  void Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments);
-  void Script_Form_ExecValidate(CFXJSE_Arguments* pArguments);
-  void Script_Form_Checksum(FXJSE_HVALUE hValue,
-                            FX_BOOL bSetting,
-                            XFA_ATTRIBUTE eAttribute);
-  void Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments);
-  void Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments);
-  void Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments);
-  void Script_Packet_Content(FXJSE_HVALUE hValue,
-                             FX_BOOL bSetting,
-                             XFA_ATTRIBUTE eAttribute);
-  void Script_Source_Next(CFXJSE_Arguments* pArguments);
-  void Script_Source_CancelBatch(CFXJSE_Arguments* pArguments);
-  void Script_Source_First(CFXJSE_Arguments* pArguments);
-  void Script_Source_UpdateBatch(CFXJSE_Arguments* pArguments);
-  void Script_Source_Previous(CFXJSE_Arguments* pArguments);
-  void Script_Source_IsBOF(CFXJSE_Arguments* pArguments);
-  void Script_Source_IsEOF(CFXJSE_Arguments* pArguments);
-  void Script_Source_Cancel(CFXJSE_Arguments* pArguments);
-  void Script_Source_Update(CFXJSE_Arguments* pArguments);
-  void Script_Source_Open(CFXJSE_Arguments* pArguments);
-  void Script_Source_Delete(CFXJSE_Arguments* pArguments);
-  void Script_Source_AddNew(CFXJSE_Arguments* pArguments);
-  void Script_Source_Requery(CFXJSE_Arguments* pArguments);
-  void Script_Source_Resync(CFXJSE_Arguments* pArguments);
-  void Script_Source_Close(CFXJSE_Arguments* pArguments);
-  void Script_Source_Last(CFXJSE_Arguments* pArguments);
-  void Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments);
-  void Script_Source_Db(FXJSE_HVALUE hValue,
-                        FX_BOOL bSetting,
-                        XFA_ATTRIBUTE eAttribute);
-  void Script_Xfa_This(FXJSE_HVALUE hValue,
-                       FX_BOOL bSetting,
-                       XFA_ATTRIBUTE eAttribute);
-  void Script_Handler_Version(FXJSE_HVALUE hValue,
-                              FX_BOOL bSetting,
-                              XFA_ATTRIBUTE eAttribute);
-  void Script_SubmitFormat_Mode(FXJSE_HVALUE hValue,
-                                FX_BOOL bSetting,
-                                XFA_ATTRIBUTE eAttribute);
-  void Script_Extras_Type(FXJSE_HVALUE hValue,
-                          FX_BOOL bSetting,
-                          XFA_ATTRIBUTE eAttribute);
-  void Script_Encrypt_Format(FXJSE_HVALUE hValue,
-                             FX_BOOL bSetting,
-                             XFA_ATTRIBUTE eAttribute);
-  void Script_Script_Stateless(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-
- protected:
-  CXFA_Node(CXFA_Document* pDoc, FX_WORD ePacket, XFA_ELEMENT eElement);
-  ~CXFA_Node();
-  friend class CXFA_Document;
-  CXFA_Node* Deprecated_GetPrevSibling();
-  FX_BOOL SetValue(XFA_ATTRIBUTE eAttr,
-                   XFA_ATTRIBUTETYPE eType,
-                   void* pValue,
-                   FX_BOOL bNotify);
-  FX_BOOL GetValue(XFA_ATTRIBUTE eAttr,
-                   XFA_ATTRIBUTETYPE eType,
-                   FX_BOOL bUseDefault,
-                   void*& pValue);
-  void OnRemoved(CXFA_Node* pParent, CXFA_Node* pRemoved, FX_BOOL bNotify);
-  void OnChanging(XFA_ATTRIBUTE eAttr, void* pNewValue, FX_BOOL bNotify);
-  void OnChanged(XFA_ATTRIBUTE eAttr,
-                 void* pNewValue,
-                 FX_BOOL bNotify,
-                 FX_BOOL bScriptModify = FALSE);
-  int32_t execSingleEventByName(const CFX_WideStringC& wsEventName,
-                                XFA_ELEMENT eElementType);
-  FX_BOOL SetScriptContent(const CFX_WideString& wsContent,
-                           const CFX_WideString& wsXMLValue,
-                           FX_BOOL bNotify = TRUE,
-                           FX_BOOL bScriptModify = FALSE,
-                           FX_BOOL bSyncData = TRUE);
-  CFX_WideString GetScriptContent(FX_BOOL bScriptModify = FALSE);
-  XFA_MAPMODULEDATA* CreateMapModuleData();
-  XFA_MAPMODULEDATA* GetMapModuleData() const;
-  void SetMapModuleValue(void* pKey, void* pValue);
-  FX_BOOL GetMapModuleValue(void* pKey, void*& pValue);
-  void SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue);
-  FX_BOOL GetMapModuleString(void* pKey, CFX_WideStringC& wsValue);
-  void SetMapModuleBuffer(void* pKey,
-                          void* pValue,
-                          int32_t iBytes,
-                          XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo = NULL);
-  FX_BOOL GetMapModuleBuffer(void* pKey,
-                             void*& pValue,
-                             int32_t& iBytes,
-                             FX_BOOL bProtoAlso = TRUE) const;
-  FX_BOOL HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso = FALSE);
-  void RemoveMapModuleKey(void* pKey = NULL);
-  void MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr = TRUE);
-  void MoveBufferMapData(CXFA_Node* pDstModule, void* pKey);
-  void MoveBufferMapData(CXFA_Node* pSrcModule,
-                         CXFA_Node* pDstModule,
-                         void* pKey,
-                         FX_BOOL bRecursive = FALSE);
-
-  CXFA_Node* m_pNext;
-  CXFA_Node* m_pChild;
-  CXFA_Node* m_pLastChild;
-  CXFA_Node* m_pParent;
-  IFDE_XMLNode* m_pXMLNode;
-  XFA_ELEMENT m_eNodeClass;
-  FX_WORD m_ePacket;
-  FX_DWORD m_dwNameHash;
-  CXFA_Node* m_pAuxNode;
-  XFA_MAPMODULEDATA* m_pMapModuleData;
-};
-class CXFA_OrdinaryObject : public CXFA_Object {
- public:
-  CXFA_OrdinaryObject(CXFA_Document* pDocument, XFA_ELEMENT eElement)
-      : CXFA_Object(pDocument, XFA_OBJECTTYPE_OrdinaryObject),
-        m_uScriptHash(0) {
-    m_eNodeClass = eElement;
-  }
-  XFA_ELEMENT GetClassID() const { return (XFA_ELEMENT)m_eNodeClass; }
-  uint32_t GetScriptObjHash() { return m_uScriptHash; }
-
- protected:
-  XFA_ELEMENT m_eNodeClass;
-  uint32_t m_uScriptHash;
-};
-class CXFA_ThisProxy : public CXFA_Object {
- public:
-  CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode)
-      : CXFA_Object(pThisNode->GetDocument(), XFA_OBJECTTYPE_VariablesThis),
-        m_pThisNode(NULL),
-        m_pScriptNode(NULL) {
-    m_pThisNode = pThisNode;
-    m_pScriptNode = pScriptNode;
-  }
-  virtual ~CXFA_ThisProxy() {}
-  CXFA_Node* GetThisNode() { return m_pThisNode; }
-  CXFA_Node* GetScriptNode() { return m_pScriptNode; }
-
- private:
-  CXFA_Node* m_pThisNode;
-  CXFA_Node* m_pScriptNode;
-};
-class CXFA_NodeList : public CXFA_Object {
- public:
-  explicit CXFA_NodeList(CXFA_Document* pDocument);
-  virtual ~CXFA_NodeList() {}
-  XFA_ELEMENT GetClassID() const { return XFA_ELEMENT_NodeList; }
-  CXFA_Node* NamedItem(const CFX_WideStringC& wsName);
-  virtual int32_t GetLength() = 0;
-  virtual FX_BOOL Append(CXFA_Node* pNode) = 0;
-  virtual FX_BOOL Insert(CXFA_Node* pNewNode, CXFA_Node* pBeforeNode) = 0;
-  virtual FX_BOOL Remove(CXFA_Node* pNode) = 0;
-  virtual CXFA_Node* Item(int32_t iIndex) = 0;
-
-  void Script_ListClass_Append(CFXJSE_Arguments* pArguments);
-  void Script_ListClass_Insert(CFXJSE_Arguments* pArguments);
-  void Script_ListClass_Remove(CFXJSE_Arguments* pArguments);
-  void Script_ListClass_Item(CFXJSE_Arguments* pArguments);
-
-  void Script_TreelistClass_NamedItem(CFXJSE_Arguments* pArguments);
-  void Script_ListClass_Length(FXJSE_HVALUE hValue,
-                               FX_BOOL bSetting,
-                               XFA_ATTRIBUTE eAttribute);
-};
-class CXFA_ArrayNodeList : public CXFA_NodeList {
- public:
-  explicit CXFA_ArrayNodeList(CXFA_Document* pDocument);
-  void SetArrayNodeList(const CXFA_NodeArray& srcArray);
-  virtual int32_t GetLength();
-  virtual FX_BOOL Append(CXFA_Node* pNode);
-  virtual FX_BOOL Insert(CXFA_Node* pNewNode, CXFA_Node* pBeforeNode);
-  virtual FX_BOOL Remove(CXFA_Node* pNode);
-  virtual CXFA_Node* Item(int32_t iIndex);
-
- protected:
-  CXFA_NodeArray m_array;
-};
-class CXFA_AttachNodeList : public CXFA_NodeList {
- public:
-  CXFA_AttachNodeList(CXFA_Document* pDocument, CXFA_Node* pAttachNode);
-
-  virtual int32_t GetLength();
-  virtual FX_BOOL Append(CXFA_Node* pNode);
-  virtual FX_BOOL Insert(CXFA_Node* pNewNode, CXFA_Node* pBeforeNode);
-  virtual FX_BOOL Remove(CXFA_Node* pNode);
-  virtual CXFA_Node* Item(int32_t iIndex);
-
- protected:
-  CXFA_Node* m_pAttachNode;
-};
-class CXFA_TraverseStrategy_XFAContainerNode {
- public:
-  static CXFA_Node* GetFirstChild(CXFA_Node* pTemplateNode,
-                                  void* pUserData = NULL) {
-    return pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild,
-                                      XFA_OBJECTTYPE_ContainerNode);
-  }
-  static CXFA_Node* GetNextSibling(CXFA_Node* pTemplateNode,
-                                   void* pUserData = NULL) {
-    return pTemplateNode->GetNodeItem(XFA_NODEITEM_NextSibling,
-                                      XFA_OBJECTTYPE_ContainerNode);
-  }
-  static CXFA_Node* GetParent(CXFA_Node* pTemplateNode,
-                              void* pUserData = NULL) {
-    return pTemplateNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                      XFA_OBJECTTYPE_ContainerNode);
-  }
-};
-typedef CXFA_NodeIteratorTemplate<CXFA_Node,
-                                  CXFA_TraverseStrategy_XFAContainerNode>
-    CXFA_ContainerIterator;
-class CXFA_TraverseStrategy_XFANode {
- public:
-  static inline CXFA_Node* GetFirstChild(CXFA_Node* pTemplateNode) {
-    return pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  }
-  static inline CXFA_Node* GetNextSibling(CXFA_Node* pTemplateNode) {
-    return pTemplateNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  static inline CXFA_Node* GetParent(CXFA_Node* pTemplateNode) {
-    return pTemplateNode->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-};
-typedef CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
-    CXFA_NodeIterator;
-
-inline CXFA_Node* CXFA_Object::AsNode() {
-  return IsNode() ? static_cast<CXFA_Node*>(this) : nullptr;
-}
-inline CXFA_OrdinaryObject* CXFA_Object::AsOrdinaryObject() {
-  return IsOrdinaryObject() ? static_cast<CXFA_OrdinaryObject*>(this) : nullptr;
-}
-inline CXFA_NodeList* CXFA_Object::AsNodeList() {
-  return IsNodeList() ? static_cast<CXFA_NodeList*>(this) : nullptr;
-}
-
-inline const CXFA_Node* CXFA_Object::AsNode() const {
-  return IsNode() ? static_cast<const CXFA_Node*>(this) : nullptr;
-}
-inline const CXFA_OrdinaryObject* CXFA_Object::AsOrdinaryObject() const {
-  return IsOrdinaryObject() ? static_cast<const CXFA_OrdinaryObject*>(this)
-                            : nullptr;
-}
-inline const CXFA_NodeList* CXFA_Object::AsNodeList() const {
-  return IsNodeList() ? static_cast<const CXFA_NodeList*>(this) : nullptr;
-}
-
-inline CXFA_Node* ToNode(CXFA_Object* pObj) {
-  return pObj ? pObj->AsNode() : nullptr;
-}
-inline CXFA_OrdinaryObject* ToOrdinaryObject(CXFA_Object* pObj) {
-  return pObj ? pObj->AsOrdinaryObject() : nullptr;
-}
-inline CXFA_NodeList* ToNodeList(CXFA_Object* pObj) {
-  return pObj ? pObj->AsNodeList() : nullptr;
-}
-
-inline const CXFA_Node* ToNode(const CXFA_Object* pObj) {
-  return pObj ? pObj->AsNode() : nullptr;
-}
-inline const CXFA_OrdinaryObject* ToOrdinaryObject(const CXFA_Object* pObj) {
-  return pObj ? pObj->AsOrdinaryObject() : nullptr;
-}
-inline const CXFA_NodeList* ToNodeList(const CXFA_Object* pObj) {
-  return pObj ? pObj->AsNodeList() : nullptr;
-}
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_OBJECT_H_
diff --git a/xfa/src/fxfa/parser/xfa_object_imp.cpp b/xfa/src/fxfa/parser/xfa_object_imp.cpp
deleted file mode 100644
index 23b0644074..0000000000
--- a/xfa/src/fxfa/parser/xfa_object_imp.cpp
+++ /dev/null
@@ -1,5408 +0,0 @@
-// 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/src/fxfa/parser/xfa_object.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fgas/crt/fgas_codepage.h"
-#include "xfa/src/fgas/crt/fgas_system.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_Object::CXFA_Object(CXFA_Document* pDocument, FX_DWORD uFlags)
-    : m_pDocument(pDocument), m_uFlags(uFlags) {}
-void CXFA_Object::GetClassName(CFX_WideStringC& wsName) const {
-  wsName = XFA_GetElementByID(GetClassID())->pName;
-}
-uint32_t CXFA_Object::GetClassHashCode() const {
-  return XFA_GetElementByID(GetClassID())->uHash;
-}
-XFA_ELEMENT CXFA_Object::GetClassID() const {
-  if (IsNode()) {
-    return AsNode()->GetClassID();
-  }
-  if (IsOrdinaryObject()) {
-    return AsOrdinaryObject()->GetClassID();
-  }
-  if (IsNodeList()) {
-    return AsNodeList()->GetClassID();
-  }
-  if (IsOrdinaryList()) {
-    return XFA_ELEMENT_List;
-  }
-  ASSERT(FALSE);
-  return (XFA_ELEMENT)0;
-}
-void CXFA_Object::Script_ObjectClass_ClassName(FXJSE_HVALUE hValue,
-                                               FX_BOOL bSetting,
-                                               XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    CFX_WideStringC className;
-    GetClassName(className);
-    FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(className.GetPtr(), className.GetLength()));
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-void CXFA_Object::ThrowScriptErrorMessage(int32_t iStringID, ...) {
-  IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
-  FXSYS_assert(pAppProvider);
-  CFX_WideString wsFormat;
-  pAppProvider->LoadString(iStringID, wsFormat);
-  CFX_WideString wsMessage;
-  va_list arg_ptr;
-  va_start(arg_ptr, iStringID);
-  wsMessage.FormatV((const FX_WCHAR*)wsFormat, arg_ptr);
-  va_end(arg_ptr);
-  FXJSE_ThrowMessage("", FX_UTF8Encode(wsMessage, wsMessage.GetLength()));
-}
-
-static void XFA_DeleteWideString(void* pData) {
-  delete static_cast<CFX_WideString*>(pData);
-}
-
-static void XFA_CopyWideString(void*& pData) {
-  if (pData) {
-    CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
-    pData = pNewData;
-  }
-}
-static XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {
-    XFA_DeleteWideString, XFA_CopyWideString};
-static XFA_OBJECTTYPE XFA_GetElementObjectType(XFA_ELEMENT eElement) {
-  return (XFA_OBJECTTYPE)XFA_GetElementByID(eElement)->eObjectType;
-}
-CXFA_Node::CXFA_Node(CXFA_Document* pDoc, FX_WORD ePacket, XFA_ELEMENT eElement)
-    : CXFA_Object(pDoc, XFA_GetElementObjectType(eElement)),
-      m_pNext(nullptr),
-      m_pChild(nullptr),
-      m_pLastChild(nullptr),
-      m_pParent(nullptr),
-      m_pXMLNode(nullptr),
-      m_eNodeClass(eElement),
-      m_ePacket(ePacket),
-      m_dwNameHash(0),
-      m_pAuxNode(nullptr),
-      m_pMapModuleData(nullptr) {
-  ASSERT(m_pDocument);
-}
-CXFA_Node::~CXFA_Node() {
-  FXSYS_assert(m_pParent == NULL);
-  RemoveMapModuleKey();
-  CXFA_Node *pNext, *pNode = m_pChild;
-  while (pNode) {
-    pNext = pNode->m_pNext;
-    pNode->m_pParent = NULL;
-    delete pNode;
-    pNode = pNext;
-  }
-  if (m_pXMLNode && HasFlag(XFA_NODEFLAG_OwnXMLNode)) {
-    m_pXMLNode->Release();
-  }
-}
-CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) {
-  IXFA_ObjFactory* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_eNodeClass);
-  if (!pClone) {
-    return NULL;
-  }
-  MergeAllData(pClone);
-  pClone->UpdateNameHash();
-  if (IsNeedSavingXMLNode()) {
-    IFDE_XMLNode* pCloneXML = NULL;
-    if (IsAttributeInXML()) {
-      CFX_WideString wsName;
-      GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
-      IFDE_XMLElement* pCloneXMLElement = IFDE_XMLElement::Create(wsName);
-      CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
-      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);
-  }
-  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->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:
-      return m_pParent;
-    case XFA_NODEITEM_PrevSibling:
-      if (m_pParent) {
-        CXFA_Node* pSibling = m_pParent->m_pChild;
-        CXFA_Node* pPrev = NULL;
-        while (pSibling && pSibling != this) {
-          pPrev = pSibling;
-          pSibling = pSibling->m_pNext;
-        }
-        return pPrev;
-      }
-      return NULL;
-    default:
-      break;
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem,
-                                  XFA_OBJECTTYPE eType) const {
-  CXFA_Node* pNode = NULL;
-  switch (eItem) {
-    case XFA_NODEITEM_NextSibling:
-      pNode = m_pNext;
-      if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType) {
-          pNode = pNode->m_pNext;
-        }
-      }
-      break;
-    case XFA_NODEITEM_FirstChild:
-      pNode = m_pChild;
-      if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType) {
-          pNode = pNode->m_pNext;
-        }
-      }
-      break;
-    case XFA_NODEITEM_Parent:
-      pNode = m_pParent;
-      if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType) {
-          pNode = pNode->m_pParent;
-        }
-      }
-      break;
-    case XFA_NODEITEM_PrevSibling:
-      if (m_pParent) {
-        CXFA_Node* pSibling = m_pParent->m_pChild;
-        while (pSibling && pSibling != this) {
-          if (eType == XFA_OBJECTTYPEMASK ||
-              eType == pSibling->GetObjectType()) {
-            pNode = pSibling;
-          }
-          pSibling = pSibling->m_pNext;
-        }
-      }
-      break;
-    default:
-      break;
-  }
-  return pNode;
-}
-int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes,
-                               FX_DWORD dwTypeFilter,
-                               XFA_ELEMENT eElementFilter,
-                               int32_t iLevel) {
-  if (--iLevel < 0) {
-    return nodes.GetSize();
-  }
-  if (eElementFilter != XFA_ELEMENT_UNKNOWN) {
-    CXFA_Node* pChild = m_pChild;
-    while (pChild) {
-      if (pChild->GetClassID() == eElementFilter) {
-        nodes.Add(pChild);
-        if (iLevel > 0) {
-          GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
-        }
-      }
-      pChild = pChild->m_pNext;
-    }
-  } else if (dwTypeFilter ==
-             (XFA_NODEFILTER_Children | XFA_NODEFILTER_Properties)) {
-    CXFA_Node* pChild = m_pChild;
-    while (pChild) {
-      nodes.Add(pChild);
-      if (iLevel > 0) {
-        GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
-      }
-      pChild = pChild->m_pNext;
-    }
-  } else if (dwTypeFilter != 0) {
-    FX_BOOL bFilterChildren = (dwTypeFilter & XFA_NODEFILTER_Children) != 0;
-    FX_BOOL bFilterProperties = (dwTypeFilter & XFA_NODEFILTER_Properties) != 0;
-    FX_BOOL bFilterOneOfProperties =
-        (dwTypeFilter & XFA_NODEFILTER_OneOfProperty) != 0;
-    CXFA_Node* pChild = m_pChild;
-    while (pChild) {
-      const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
-          GetClassID(), pChild->GetClassID(), XFA_XDPPACKET_UNKNOWN);
-      if (pProperty) {
-        if (bFilterProperties) {
-          nodes.Add(pChild);
-        } else if (bFilterOneOfProperties &&
-                   (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
-          nodes.Add(pChild);
-        } else if (bFilterChildren &&
-                   (pChild->GetClassID() == XFA_ELEMENT_Variables ||
-                    pChild->GetClassID() == XFA_ELEMENT_PageSet)) {
-          nodes.Add(pChild);
-        }
-      } else {
-        if (bFilterChildren) {
-          nodes.Add(pChild);
-        }
-      }
-      pChild = pChild->m_pNext;
-    }
-    if (bFilterOneOfProperties && nodes.GetSize() < 1) {
-      int32_t iProperties = 0;
-      const XFA_PROPERTY* pProperty =
-          XFA_GetElementProperties(GetClassID(), iProperties);
-      if (pProperty == NULL || iProperties < 1) {
-        return 0;
-      }
-      for (int32_t i = 0; i < iProperties; i++) {
-        if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
-          IXFA_ObjFactory* 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);
-          nodes.Add(pNewNode);
-          break;
-        }
-      }
-    }
-  }
-  return nodes.GetSize();
-}
-CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_ELEMENT eElement,
-                                           FX_DWORD dwFlags) {
-  IXFA_ObjFactory* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
-  pNode->SetFlag(dwFlags);
-  return pNode;
-}
-CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
-  FXSYS_assert(m_ePacket == XFA_XDPPACKET_Template);
-  IXFA_ObjFactory* 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);
-  return pClone;
-}
-
-CXFA_Node* CXFA_Node::GetTemplateNode() const {
-  return m_pAuxNode;
-}
-
-void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode) {
-  m_pAuxNode = pTemplateNode;
-}
-CXFA_Node* CXFA_Node::GetBindData() {
-  ASSERT(GetPacketID() == XFA_XDPPACKET_Form);
-  return static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
-}
-int32_t CXFA_Node::GetBindItems(CXFA_NodeArray& formItems) {
-  if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
-    CXFA_NodeArray* pItems = NULL;
-    TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
-    formItems.Copy(*pItems);
-    return formItems.GetSize();
-  }
-  CXFA_Node* pFormNode =
-      static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
-  if (pFormNode) {
-    formItems.Add(pFormNode);
-  }
-  return formItems.GetSize();
-}
-
-static void XFA_DataNodeDeleteBindItem(void* pData) {
-  delete static_cast<CXFA_NodeArray*>(pData);
-}
-
-static XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
-    XFA_DataNodeDeleteBindItem, NULL};
-int32_t CXFA_Node::AddBindItem(CXFA_Node* pFormNode) {
-  ASSERT(pFormNode);
-  if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
-    CXFA_NodeArray* pItems = NULL;
-    TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
-    ASSERT(pItems);
-    if (pItems->Find(pFormNode) < 0) {
-      pItems->Add(pFormNode);
-    }
-    return pItems->GetSize();
-  }
-  CXFA_Node* pOldFormItem =
-      static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
-  if (!pOldFormItem) {
-    SetObject(XFA_ATTRIBUTE_BindingNode, pFormNode);
-    return 1;
-  } else if (pOldFormItem == pFormNode) {
-    return 1;
-  }
-  CXFA_NodeArray* pItems = new CXFA_NodeArray;
-  SetObject(XFA_ATTRIBUTE_BindingNode, pItems, &deleteBindItemCallBack);
-  pItems->Add(pOldFormItem);
-  pItems->Add(pFormNode);
-  m_uFlags |= XFA_NODEFLAG_BindFormItems;
-  return 2;
-}
-int32_t CXFA_Node::RemoveBindItem(CXFA_Node* pFormNode) {
-  if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
-    CXFA_NodeArray* pItems = NULL;
-    TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
-    ASSERT(pItems);
-    int32_t iIndex = pItems->Find(pFormNode);
-    int32_t iCount = pItems->GetSize();
-    if (iIndex >= 0) {
-      if (iIndex != iCount - 1) {
-        pItems->SetAt(iIndex, pItems->GetAt(iCount - 1));
-      }
-      pItems->RemoveAt(iCount - 1);
-      if (iCount == 2) {
-        CXFA_Node* pLastFormNode = pItems->GetAt(0);
-        SetObject(XFA_ATTRIBUTE_BindingNode, pLastFormNode);
-        m_uFlags &= ~XFA_NODEFLAG_BindFormItems;
-      }
-      iCount--;
-    }
-    return iCount;
-  }
-  CXFA_Node* pOldFormItem =
-      static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
-  if (pOldFormItem == pFormNode) {
-    SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
-    pOldFormItem = NULL;
-  }
-  return pOldFormItem == NULL ? 0 : 1;
-}
-FX_BOOL CXFA_Node::HasBindItem() {
-  return (GetPacketID() == XFA_XDPPACKET_Datasets) &&
-         GetObject(XFA_ATTRIBUTE_BindingNode) != NULL;
-}
-CXFA_WidgetData* CXFA_Node::GetWidgetData() {
-  return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData);
-}
-CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() {
-  if (GetPacketID() != XFA_XDPPACKET_Form) {
-    return NULL;
-  }
-  XFA_ELEMENT classID = GetClassID();
-  if (classID == XFA_ELEMENT_ExclGroup) {
-    return NULL;
-  }
-  CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
-    return NULL;
-  }
-  if (classID == XFA_ELEMENT_Field) {
-    CXFA_WidgetData* pFieldWidgetData = GetWidgetData();
-    if (pFieldWidgetData &&
-        pFieldWidgetData->GetChoiceListOpen() ==
-            XFA_ATTRIBUTEENUM_MultiSelect) {
-      return NULL;
-    } else {
-      CFX_WideString wsPicture;
-      if (pFieldWidgetData) {
-        pFieldWidgetData->GetPictureContent(wsPicture,
-                                            XFA_VALUEPICTURE_DataBind);
-      }
-      if (!wsPicture.IsEmpty()) {
-        return pFieldWidgetData;
-      }
-      CXFA_Node* pDataNode = GetBindData();
-      if (!pDataNode) {
-        return NULL;
-      }
-      pFieldWidgetData = NULL;
-      CXFA_NodeArray formNodes;
-      pDataNode->GetBindItems(formNodes);
-      for (int32_t i = 0; i < formNodes.GetSize(); i++) {
-        CXFA_Node* pFormNode = formNodes.GetAt(i);
-        if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
-          continue;
-        }
-        pFieldWidgetData = pFormNode->GetWidgetData();
-        if (pFieldWidgetData) {
-          pFieldWidgetData->GetPictureContent(wsPicture,
-                                              XFA_VALUEPICTURE_DataBind);
-        }
-        if (!wsPicture.IsEmpty()) {
-          break;
-        }
-        pFieldWidgetData = NULL;
-      }
-      return pFieldWidgetData;
-    }
-  }
-  CXFA_Node* pGrandNode =
-      pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
-  CXFA_Node* pValueNode =
-      (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_Value)
-          ? pParentNode
-          : NULL;
-  if (!pValueNode) {
-    pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_ELEMENT_Value)
-                     ? pGrandNode
-                     : NULL;
-  }
-  CXFA_Node* pParentOfValueNode =
-      pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
-  return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData()
-                            : NULL;
-}
-FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
-  CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode();
-  CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_ELEMENT_Subform);
-  FXSYS_assert(pTopSubform);
-  CXFA_Node* pLocaleNode = this;
-  FX_BOOL bLocale = FALSE;
-  do {
-    bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
-    if (!bLocale) {
-      pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent);
-    }
-  } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale);
-  if (bLocale) {
-    return bLocale;
-  }
-  CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config));
-  wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig);
-  if (!wsLocaleName.IsEmpty()) {
-    bLocale = TRUE;
-  }
-  if (bLocale) {
-    return bLocale;
-  }
-  if (pTopSubform) {
-    bLocale = pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
-  }
-  if (bLocale) {
-    return bLocale;
-  }
-  IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale();
-  if (pLocale) {
-    wsLocaleName = pLocale->GetName();
-    bLocale = TRUE;
-  }
-  return bLocale;
-}
-XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() {
-  XFA_ELEMENT eElement = GetClassID();
-  CXFA_Node* pKeep = GetFirstChildByClass(XFA_ELEMENT_Keep);
-  XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout);
-  if (pKeep) {
-    XFA_ATTRIBUTEENUM eIntact;
-    if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) {
-      if (eIntact == XFA_ATTRIBUTEENUM_None &&
-          eLayoutType == XFA_ATTRIBUTEENUM_Row &&
-          m_pDocument->GetCurVersionMode() < XFA_VERSION_208) {
-        CXFA_Node* pPreviewRow =
-            GetNodeItem(XFA_NODEITEM_PrevSibling, XFA_OBJECTTYPE_ContainerNode);
-        if (pPreviewRow &&
-            pPreviewRow->GetEnum(XFA_ATTRIBUTE_Layout) ==
-                XFA_ATTRIBUTEENUM_Row) {
-          XFA_ATTRIBUTEENUM eValue;
-          if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE)) {
-            if (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
-                eValue == XFA_ATTRIBUTEENUM_PageArea) {
-              return XFA_ATTRIBUTEENUM_ContentArea;
-            }
-          }
-          CXFA_Node* pKeep =
-              pPreviewRow->GetFirstChildByClass(XFA_ELEMENT_Keep);
-          if (pKeep) {
-            if (pKeep->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE)) {
-              if (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
-                  eValue == XFA_ATTRIBUTEENUM_PageArea) {
-                return XFA_ATTRIBUTEENUM_ContentArea;
-              }
-            }
-          }
-        }
-      }
-      return eIntact;
-    }
-  }
-  switch (eElement) {
-    case XFA_ELEMENT_Subform:
-      switch (eLayoutType) {
-        case XFA_ATTRIBUTEENUM_Position:
-        case XFA_ATTRIBUTEENUM_Row:
-          return XFA_ATTRIBUTEENUM_ContentArea;
-        case XFA_ATTRIBUTEENUM_Tb:
-        case XFA_ATTRIBUTEENUM_Table:
-        case XFA_ATTRIBUTEENUM_Lr_tb:
-        case XFA_ATTRIBUTEENUM_Rl_tb:
-          return XFA_ATTRIBUTEENUM_None;
-        default:
-          break;
-      }
-      break;
-    case XFA_ELEMENT_Field: {
-      CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_PageArea) {
-        return XFA_ATTRIBUTEENUM_ContentArea;
-      }
-      if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
-        XFA_ATTRIBUTEENUM eParLayout =
-            pParentNode->GetEnum(XFA_ATTRIBUTE_Layout);
-        if (eParLayout == XFA_ATTRIBUTEENUM_Position ||
-            eParLayout == XFA_ATTRIBUTEENUM_Row ||
-            eParLayout == XFA_ATTRIBUTEENUM_Table) {
-          return XFA_ATTRIBUTEENUM_None;
-        }
-        XFA_VERSION version = m_pDocument->GetCurVersionMode();
-        if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) {
-          CXFA_Measurement measureH;
-          if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE)) {
-            return XFA_ATTRIBUTEENUM_ContentArea;
-          }
-        }
-        return XFA_ATTRIBUTEENUM_None;
-      }
-      return XFA_ATTRIBUTEENUM_ContentArea;
-    }
-    case XFA_ELEMENT_Draw:
-      return XFA_ATTRIBUTEENUM_ContentArea;
-    default:
-      break;
-  }
-  return XFA_ATTRIBUTEENUM_None;
-}
-CXFA_Node* CXFA_Node::GetDataDescriptionNode() {
-  if (m_ePacket == XFA_XDPPACKET_Datasets) {
-    return m_pAuxNode;
-  }
-  return NULL;
-}
-void CXFA_Node::SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode) {
-  FXSYS_assert(m_ePacket == XFA_XDPPACKET_Datasets);
-  m_pAuxNode = pDataDescriptionNode;
-}
-void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
-    return;
-  }
-  CFX_WideString wsExpression;
-  CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-  wsExpression =
-      CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
-    refNode = ToNode(pScriptContext->GetThisObject());
-  }
-  FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
-                    XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
-                    XFA_RESOLVENODE_Siblings;
-  XFA_RESOLVENODE_RS resoveNodeRS;
-  int32_t iRet = pScriptContext->ResolveObjects(refNode, wsExpression,
-                                                resoveNodeRS, dwFlag);
-  if (iRet < 1) {
-    return FXJSE_Value_SetNull(pArguments->GetReturnValue());
-  }
-  FXJSE_HVALUE hValue = NULL;
-  if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
-    CXFA_Object* pNode = resoveNodeRS.nodes[0];
-    hValue = pScriptContext->GetJSValueFromMap(pNode);
-    FXJSE_Value_Set(pArguments->GetReturnValue(), hValue);
-  } else {
-    const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo =
-        resoveNodeRS.pScriptAttribute;
-    if (lpAttributeInfo && lpAttributeInfo->eValueType == XFA_SCRIPT_Object) {
-      hValue = FXJSE_Value_Create(pScriptContext->GetRuntime());
-      (resoveNodeRS.nodes[0]->*(lpAttributeInfo->lpfnCallback))(
-          hValue, FALSE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
-      FXJSE_Value_Set(pArguments->GetReturnValue(), hValue);
-      FXJSE_Value_Release(hValue);
-    } else {
-      FXJSE_Value_SetNull(pArguments->GetReturnValue());
-    }
-  }
-}
-void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"resolveNodes");
-    return;
-  }
-  CFX_WideString wsExpression;
-  CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-  wsExpression =
-      CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (!hValue) {
-    return;
-  }
-  FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
-                    XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
-                    XFA_RESOLVENODE_Siblings;
-  CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
-    refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject());
-  }
-  Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag, refNode);
-}
-void CXFA_Node::Script_Som_ResolveNodeList(FXJSE_HVALUE hValue,
-                                           CFX_WideString wsExpression,
-                                           FX_DWORD dwFlag,
-                                           CXFA_Node* refNode) {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  XFA_RESOLVENODE_RS resoveNodeRS;
-  if (refNode == NULL) {
-    refNode = this;
-  }
-  pScriptContext->ResolveObjects(refNode, wsExpression, resoveNodeRS, dwFlag);
-  CXFA_ArrayNodeList* pNodeList = new CXFA_ArrayNodeList(m_pDocument);
-  if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
-    for (int32_t i = 0; i < resoveNodeRS.nodes.GetSize(); i++) {
-      if (resoveNodeRS.nodes[i]->IsNode())
-        pNodeList->Append(resoveNodeRS.nodes[i]->AsNode());
-    }
-  } else {
-    CXFA_HVALUEArray hValueArray(pScriptContext->GetRuntime());
-    if (resoveNodeRS.GetAttributeResult(hValueArray) > 0) {
-      CXFA_ObjArray objectArray;
-      hValueArray.GetAttributeObject(objectArray);
-      for (int32_t i = 0; i < objectArray.GetSize(); i++) {
-        if (objectArray[i]->IsNode())
-          pNodeList->Append(objectArray[i]->AsNode());
-      }
-    }
-  }
-  FXJSE_Value_SetObject(hValue, (CXFA_Object*)pNodeList,
-                        pScriptContext->GetJseNormalClass());
-}
-void CXFA_Node::Script_TreeClass_All(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FX_DWORD dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
-    CFX_WideString wsName;
-    GetAttribute(XFA_ATTRIBUTE_Name, wsName);
-    CFX_WideString wsExpression = wsName + FX_WSTRC(L"[*]");
-    Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag);
-  }
-}
-void CXFA_Node::Script_TreeClass_Nodes(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  if (bSetting) {
-    IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
-    FXSYS_assert(pAppProvider);
-    CFX_WideString wsMessage;
-    pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage);
-    FXJSE_ThrowMessage("", FX_UTF8Encode(wsMessage, wsMessage.GetLength()));
-  } else {
-    CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this);
-    FXJSE_Value_SetObject(hValue, (CXFA_Object*)pNodeList,
-                          pScriptContext->GetJseNormalClass());
-  }
-}
-void CXFA_Node::Script_TreeClass_ClassAll(FXJSE_HVALUE hValue,
-                                          FX_BOOL bSetting,
-                                          XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FX_DWORD dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
-    CFX_WideStringC wsName;
-    GetClassName(wsName);
-    CFX_WideString wsExpression = FX_WSTRC(L"#") + wsName + FX_WSTRC(L"[*]");
-    Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag);
-  }
-}
-void CXFA_Node::Script_TreeClass_Parent(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
-    if (pParent) {
-      FXJSE_Value_Set(
-          hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent));
-    } else {
-      FXJSE_Value_SetNull(hValue);
-    }
-  }
-}
-void CXFA_Node::Script_TreeClass_Index(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FXJSE_Value_SetInteger(hValue, GetNodeSameNameIndex());
-  }
-}
-void CXFA_Node::Script_TreeClass_ClassIndex(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FXJSE_Value_SetInteger(hValue, GetNodeSameClassIndex());
-  }
-}
-void CXFA_Node::Script_TreeClass_SomExpression(FXJSE_HVALUE hValue,
-                                               FX_BOOL bSetting,
-                                               XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    CFX_WideString wsSOMExpression;
-    GetSOMExpression(wsSOMExpression);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsSOMExpression));
-  }
-}
-void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL");
-    return;
-  }
-  CFX_WideString wsExpression;
-  CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-  wsExpression =
-      CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-}
-void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode");
-    return;
-  }
-  CFX_WideString wsExpression;
-  CFX_WideString wsValue;
-  int32_t iAction = 0;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression =
-        CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsValue = pArguments->GetUTF8String(1);
-    wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-  }
-  if (iLength >= 3) {
-    iAction = pArguments->GetInt32(2);
-  }
-}
-void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone");
-    return;
-  }
-  FX_BOOL bClone = TRUE;
-  bClone = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
-  CXFA_Node* pCloneNode = Clone(bClone);
-  FXJSE_Value_Set(
-      pArguments->GetReturnValue(),
-      m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode));
-}
-void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getAttribute");
-    return;
-  }
-  CFX_WideString wsExpression;
-  CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-  wsExpression =
-      CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  CFX_WideString wsValue;
-  GetAttribute(wsExpression, wsValue);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-  }
-}
-void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement");
-    return;
-  }
-  CFX_WideString wsExpression;
-  int32_t iValue = 0;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression =
-        CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  }
-  if (iLength >= 2) {
-    iValue = pArguments->GetInt32(1);
-  }
-  const XFA_ELEMENTINFO* pElementInfo = XFA_GetElementByName(wsExpression);
-  CXFA_Node* pNode = GetProperty(iValue, pElementInfo->eName);
-  FXJSE_Value_Set(pArguments->GetReturnValue(),
-                  m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
-}
-void CXFA_Node::Script_NodeClass_IsPropertySpecified(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"isPropertySpecified");
-    return;
-  }
-  CFX_WideString wsExpression;
-  FX_BOOL bParent = TRUE;
-  int32_t iIndex = 0;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression =
-        CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  }
-  if (iLength >= 2) {
-    bParent = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
-  }
-  if (iLength >= 3) {
-    iIndex = pArguments->GetInt32(2);
-  }
-  FX_BOOL bHas = FALSE;
-  const XFA_ATTRIBUTEINFO* pAttributeInfo =
-      XFA_GetAttributeByName(wsExpression);
-  CFX_WideString wsValue;
-  if (pAttributeInfo) {
-    bHas = HasAttribute(pAttributeInfo->eName);
-  }
-  if (!bHas) {
-    const XFA_ELEMENTINFO* pElementInfo = XFA_GetElementByName(wsExpression);
-    bHas = (GetProperty(iIndex, pElementInfo->eName) != NULL);
-  }
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetBoolean(hValue, bHas);
-  }
-}
-void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML");
-    return;
-  }
-  CFX_WideString wsExpression;
-  FX_BOOL bIgnoreRoot = TRUE;
-  FX_BOOL bOverwrite = 0;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression =
-        CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-    if (wsExpression.IsEmpty()) {
-      return;
-    }
-  }
-  if (iLength >= 2) {
-    bIgnoreRoot = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
-  }
-  if (iLength >= 3) {
-    bOverwrite = pArguments->GetInt32(2) == 0 ? FALSE : TRUE;
-  }
-  IXFA_Parser* pParser = IXFA_Parser::Create(m_pDocument);
-  if (!pParser) {
-    return;
-  }
-  IFDE_XMLNode* pXMLNode = NULL;
-  int32_t iParserStatus = pParser->ParseXMLData(wsExpression, pXMLNode, NULL);
-  if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) {
-    pParser->Release();
-    pParser = NULL;
-    return;
-  }
-  if (bIgnoreRoot && (pXMLNode->GetType() != FDE_XMLNODE_Element ||
-                      XFA_RecognizeRichText((IFDE_XMLElement*)pXMLNode))) {
-    bIgnoreRoot = FALSE;
-  }
-  CXFA_Node* pFakeRoot = Clone(FALSE);
-  CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType);
-  if (!wsContentType.IsEmpty()) {
-    pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-  }
-  IFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
-  if (!pFakeXMLRoot) {
-    IFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode();
-    pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : NULL;
-  }
-  if (!pFakeXMLRoot) {
-    CFX_WideStringC wsClassName;
-    GetClassName(wsClassName);
-    pFakeXMLRoot = IFDE_XMLElement::Create(wsClassName);
-  }
-  if (bIgnoreRoot) {
-    IFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-    while (pXMLChild) {
-      IFDE_XMLNode* pXMLSibling =
-          pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling);
-      pXMLNode->RemoveChildNode(pXMLChild);
-      pFakeXMLRoot->InsertChildNode(pXMLChild);
-      pXMLChild = pXMLSibling;
-    }
-  } else {
-    IFDE_XMLNode* pXMLParent = pXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
-    if (pXMLParent) {
-      pXMLParent->RemoveChildNode(pXMLNode);
-    }
-    pFakeXMLRoot->InsertChildNode(pXMLNode);
-  }
-  pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot);
-  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 = 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) {
-        IFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
-        SetXMLMappingNode(pFakeXMLRoot);
-        SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
-        if (pTempXMLNode &&
-            pTempXMLNode->GetNodeItem(IFDE_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 = pItem;
-      }
-    }
-    if (pFakeXMLRoot) {
-      pFakeRoot->SetXMLMappingNode(pFakeXMLRoot);
-      pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
-    }
-    pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, TRUE, FALSE);
-  } else {
-    if (pFakeXMLRoot) {
-      pFakeXMLRoot->Release();
-      pFakeXMLRoot = NULL;
-    }
-  }
-  pParser->Release();
-  pParser = NULL;
-}
-void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) {
-}
-
-void CXFA_Node::Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 0 || iLength > 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"saveXML");
-    return;
-  }
-  FX_BOOL bPrettyMode = FALSE;
-  if (iLength == 1) {
-    CFX_ByteString bsPretty = pArguments->GetUTF8String(0);
-    if (!bsPretty.Equal("pretty")) {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
-      return;
-    }
-    bPrettyMode = TRUE;
-  }
-  CFX_ByteStringC bsXMLHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-  if (GetPacketID() == XFA_XDPPACKET_Form) {
-    IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
-    IFX_Stream* pStream = IFX_Stream::CreateStream(
-        (IFX_FileWrite*)pMemoryStream,
-        FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
-    if (!pStream) {
-      FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
-      pMemoryStream->Release();
-      pMemoryStream = NULL;
-      return;
-    }
-    pStream->SetCodePage(FX_CODEPAGE_UTF8);
-    pStream->WriteData(bsXMLHeader.GetPtr(), bsXMLHeader.GetLength());
-    XFA_DataExporter_RegenerateFormFile(this, pStream, NULL, TRUE);
-    FXJSE_Value_SetUTF8String(
-        pArguments->GetReturnValue(),
-        CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
-    pStream->Release();
-    pStream = NULL;
-    if (pMemoryStream) {
-      pMemoryStream->Release();
-      pMemoryStream = NULL;
-    }
-    return;
-  }
-  if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-    IFDE_XMLNode* pElement = GetXMLMappingNode();
-    if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
-      FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
-      return;
-    }
-    XFA_DataExporter_DealWithDataGroupNode(this);
-    IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
-    IFX_Stream* pStream = IFX_Stream::CreateStream(
-        (IFX_FileWrite*)pMemoryStream,
-        FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
-    if (pStream) {
-      pStream->SetCodePage(FX_CODEPAGE_UTF8);
-      pStream->WriteData(bsXMLHeader.GetPtr(), bsXMLHeader.GetLength());
-      pElement->SaveXMLNode(pStream);
-      FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(),
-                                CFX_ByteStringC(pMemoryStream->GetBuffer(),
-                                                pMemoryStream->GetSize()));
-      pStream->Release();
-      pStream = NULL;
-    }
-    if (pMemoryStream) {
-      pMemoryStream->Release();
-      pMemoryStream = NULL;
-    }
-    return;
-  }
-  FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), "");
-}
-
-void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"setAttribute");
-    return;
-  }
-  CFX_WideString wsAttribute;
-  CFX_WideString wsAttributeValue;
-  CFX_ByteString bsAttributeValue = pArguments->GetUTF8String(0);
-  CFX_ByteString bsAttribute = pArguments->GetUTF8String(1);
-  wsAttributeValue =
-      CFX_WideString::FromUTF8(bsAttributeValue, bsAttributeValue.GetLength());
-  wsAttribute = CFX_WideString::FromUTF8(bsAttribute, bsAttribute.GetLength());
-  SetAttribute(wsAttribute, wsAttributeValue, TRUE);
-}
-void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1 && iLength != 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement");
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  CFX_WideString wsName;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsName = pArguments->GetUTF8String(1);
-    wsName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
-  }
-}
-void CXFA_Node::Script_NodeClass_Ns(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    CFX_WideString wsNameSpace;
-    TryNamespace(wsNameSpace);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsNameSpace));
-  }
-}
-void CXFA_Node::Script_NodeClass_Model(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(
-                                GetModelNode()));
-  }
-}
-void CXFA_Node::Script_NodeClass_IsContainer(FXJSE_HVALUE hValue,
-                                             FX_BOOL bSetting,
-                                             XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FXJSE_Value_SetBoolean(hValue, IsContainerNode());
-  }
-}
-void CXFA_Node::Script_NodeClass_IsNull(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    if (GetClassID() == XFA_ELEMENT_Subform) {
-      FXJSE_Value_SetBoolean(hValue, FALSE);
-      return;
-    }
-    CFX_WideString strValue;
-    FXJSE_Value_SetBoolean(hValue, !TryContent(strValue) || strValue.IsEmpty());
-  }
-}
-void CXFA_Node::Script_NodeClass_OneOfChild(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    CXFA_NodeArray properts;
-    int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
-    if (iSize > 0) {
-      FXJSE_Value_Set(
-          hValue,
-          m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0]));
-    }
-  }
-}
-void CXFA_Node::Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments) {}
-void CXFA_Node::Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments) {
-  CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument);
-  FXJSE_Value_SetObject(pArguments->GetReturnValue(), (CXFA_Object*)pFormNodes,
-                        m_pDocument->GetScriptContext()->GetJseNormalClass());
-}
-void CXFA_Node::Script_ModelClass_ClearErrorList(CFXJSE_Arguments* pArguments) {
-}
-void CXFA_Node::Script_ModelClass_CreateNode(CFXJSE_Arguments* pArguments) {
-  Script_Template_CreateNode(pArguments);
-}
-void CXFA_Node::Script_ModelClass_IsCompatibleNS(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"isCompatibleNS");
-    return;
-  }
-  CFX_WideString wsNameSpace;
-  if (iLength >= 1) {
-    CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0);
-    wsNameSpace =
-        CFX_WideString::FromUTF8(bsNameSpace, bsNameSpace.GetLength());
-  }
-  CFX_WideString wsNodeNameSpace;
-  TryNamespace(wsNodeNameSpace);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetBoolean(hValue, wsNodeNameSpace.Equal(wsNameSpace));
-  }
-}
-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);
-  } 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);
-  } 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,
-    FX_BOOL bScriptModify) {
-  CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (!pLayoutPro) {
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  FX_DWORD 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));
-        } else {
-          pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                               eValue, 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);
-        } 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));
-          }
-        }
-      } 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;
-      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;
-    }
-    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);
-  }
-}
-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, szValue.GetLength());
-    SetAttribute(eAttribute, wsValue, 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((const FX_WCHAR*)wsUseVal + 1,
-                                wsUseVal.GetLength() - 1);
-        } else {
-          wsSOM =
-              CFX_WideString((const FX_WCHAR*)wsUseVal, wsUseVal.GetLength());
-        }
-      }
-      CXFA_Node* pProtoNode = NULL;
-      if (!wsSOM.IsEmpty()) {
-        FX_DWORD dwFlag = XFA_RESOLVENODE_Children |
-                          XFA_RESOLVENODE_Attributes |
-                          XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
-                          XFA_RESOLVENODE_Siblings;
-        XFA_RESOLVENODE_RS resoveNodeRS;
-        int32_t iRet = m_pDocument->GetScriptContext()->ResolveObjects(
-            pProtoRoot, wsSOM, resoveNodeRS, dwFlag);
-        if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
-          pProtoNode = resoveNodeRS.nodes[0]->AsNode();
-        }
-      } else if (!wsID.IsEmpty()) {
-        pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID);
-      }
-      if (pProtoNode) {
-        CXFA_Node* pHeadChild = GetNodeItem(XFA_NODEITEM_FirstChild);
-        while (pHeadChild) {
-          CXFA_Node* pSibling =
-              pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-          RemoveChild(pHeadChild);
-          pHeadChild = pSibling;
-        }
-        CXFA_Node* pProtoForm = pProtoNode->CloneTemplateToForm(TRUE);
-        pHeadChild = pProtoForm->GetNodeItem(XFA_NODEITEM_FirstChild);
-        while (pHeadChild) {
-          CXFA_Node* pSibling =
-              pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-          pProtoForm->RemoveChild(pHeadChild);
-          InsertChild(pHeadChild);
-          pHeadChild = pSibling;
-        }
-        m_pDocument->RemovePurgeNode(pProtoForm);
-        delete pProtoForm;
-      }
-    }
-  } else {
-    CFX_WideString wsValue;
-    GetAttribute(eAttribute, wsValue);
-    FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(wsValue, wsValue.GetLength()));
-  }
-}
-void CXFA_Node::Script_Attribute_StringRead(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    CFX_WideString wsValue;
-    GetAttribute(eAttribute, wsValue);
-    FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(wsValue, wsValue.GetLength()));
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if ((argc == 0) || (argc == 1)) {
-    FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute");
-  }
-}
-void CXFA_Node::Script_Delta_Restore(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"restore");
-  }
-}
-void CXFA_Node::Script_Delta_CurrentValue(FXJSE_HVALUE hValue,
-                                          FX_BOOL bSetting,
-                                          XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_Delta_SavedValue(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_Delta_Target(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_Som_Message(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_SOM_MESSAGETYPE iMessageType) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  FX_BOOL bNew = FALSE;
-  CXFA_Validate validate = pWidgetData->GetValidate();
-  if (!validate) {
-    validate = pWidgetData->GetValidate(TRUE);
-    bNew = TRUE;
-  }
-  if (bSetting) {
-    CFX_ByteString bsMessage;
-    FXJSE_Value_ToUTF8String(hValue, bsMessage);
-    switch (iMessageType) {
-      case XFA_SOM_ValidationMessage:
-        validate.SetScriptMessageText(
-            CFX_WideString::FromUTF8(bsMessage, bsMessage.GetLength()));
-        break;
-      case XFA_SOM_FormatMessage:
-        validate.SetFormatMessageText(
-            CFX_WideString::FromUTF8(bsMessage, bsMessage.GetLength()));
-        break;
-      case XFA_SOM_MandatoryMessage:
-        validate.SetNullMessageText(
-            CFX_WideString::FromUTF8(bsMessage, bsMessage.GetLength()));
-        break;
-      default:
-        break;
-    }
-    if (!bNew) {
-      IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-      if (!pNotify) {
-        return;
-      }
-      pNotify->AddCalcValidate(this);
-    }
-  } else {
-    CFX_WideString wsMessage;
-    switch (iMessageType) {
-      case XFA_SOM_ValidationMessage:
-        validate.GetScriptMessageText(wsMessage);
-        break;
-      case XFA_SOM_FormatMessage:
-        validate.GetFormatMessageText(wsMessage);
-        break;
-      case XFA_SOM_MandatoryMessage:
-        validate.GetNullMessageText(wsMessage);
-        break;
-      default:
-        break;
-    }
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsMessage));
-  }
-}
-void CXFA_Node::Script_Som_ValidationMessage(FXJSE_HVALUE hValue,
-                                             FX_BOOL bSetting,
-                                             XFA_ATTRIBUTE eAttribute) {
-  Script_Som_Message(hValue, bSetting, XFA_SOM_ValidationMessage);
-}
-void CXFA_Node::Script_Field_Length(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    CXFA_WidgetData* pWidgetData = GetWidgetData();
-    if (!pWidgetData) {
-      FXJSE_Value_SetInteger(hValue, 0);
-      return;
-    }
-    FXJSE_Value_SetInteger(hValue, pWidgetData->CountChoiceListItems(TRUE));
-  }
-}
-void CXFA_Node::Script_Som_DefaultValue(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute) {
-  XFA_ELEMENT classID = GetClassID();
-  if (classID == XFA_ELEMENT_Field) {
-    Script_Field_DefaultValue(hValue, bSetting, eAttribute);
-    return;
-  } else if (classID == XFA_ELEMENT_Draw) {
-    Script_Draw_DefaultValue(hValue, bSetting, eAttribute);
-    return;
-  } else if (classID == XFA_ELEMENT_Boolean) {
-    Script_Boolean_Value(hValue, bSetting, eAttribute);
-    return;
-  }
-  if (bSetting) {
-    CFX_ByteString newValue;
-    if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
-      FXJSE_Value_ToUTF8String(hValue, newValue);
-    }
-    CFX_WideString wsNewValue =
-        CFX_WideString::FromUTF8(newValue, newValue.GetLength());
-    CFX_WideString wsFormatValue(wsNewValue);
-    CXFA_WidgetData* pContainerWidgetData = NULL;
-    if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-      CXFA_NodeArray formNodes;
-      GetBindItems(formNodes);
-      CFX_WideString wsPicture;
-      for (int32_t i = 0; i < formNodes.GetSize(); i++) {
-        CXFA_Node* pFormNode = formNodes.GetAt(i);
-        if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
-          continue;
-        }
-        pContainerWidgetData = pFormNode->GetContainerWidgetData();
-        if (pContainerWidgetData) {
-          pContainerWidgetData->GetPictureContent(wsPicture,
-                                                  XFA_VALUEPICTURE_DataBind);
-        }
-        if (!wsPicture.IsEmpty()) {
-          break;
-        }
-        pContainerWidgetData = NULL;
-      }
-    } else if (GetPacketID() == XFA_XDPPACKET_Form) {
-      pContainerWidgetData = GetContainerWidgetData();
-    }
-    if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
-    }
-    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));
-    } else if (classID == XFA_ELEMENT_Float || classID == XFA_ELEMENT_Decimal) {
-      CFX_Decimal decimal(content);
-      FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
-    } else {
-      FXJSE_Value_SetUTF8String(hValue,
-                                FX_UTF8Encode(content, content.GetLength()));
-    }
-  }
-}
-void CXFA_Node::Script_Som_DefaultValue_Read(FXJSE_HVALUE hValue,
-                                             FX_BOOL bSetting,
-                                             XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CFX_WideString content = GetScriptContent(TRUE);
-  if (content.IsEmpty()) {
-    FXJSE_Value_SetNull(hValue);
-  } else {
-    FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(content, content.GetLength()));
-  }
-}
-void CXFA_Node::Script_Boolean_Value(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    CFX_ByteString newValue;
-    if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
-      FXJSE_Value_ToUTF8String(hValue, newValue);
-    }
-    int32_t iValue = FXSYS_atoi(newValue);
-    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, wsFormatValue);
-    }
-    SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
-  } else {
-    CFX_WideString wsValue = GetScriptContent(TRUE);
-    FXJSE_Value_SetBoolean(hValue, wsValue.Equal(FX_WSTRC(L"1")));
-  }
-}
-struct XFA_ExecEventParaInfo {
- public:
-  uint32_t m_uHash;
-  const FX_WCHAR* m_lpcEventName;
-  XFA_EVENTTYPE m_eventType;
-  uint32_t m_validFlags;
-};
-static const XFA_ExecEventParaInfo gs_eventParaInfos[] = {
-    {0x02a6c55a, L"postSubmit", XFA_EVENT_PostSubmit, 0},
-    {0x0ab466bb, L"preSubmit", XFA_EVENT_PreSubmit, 0},
-    {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, 5},
-    {0x17fad373, L"postPrint", XFA_EVENT_PostPrint, 0},
-    {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, 7},
-    {0x2196a452, L"initialize", XFA_EVENT_Initialize, 1},
-    {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, 5},
-    {0x33c43dec, L"docClose", XFA_EVENT_DocClose, 0},
-    {0x361fa1b6, L"preSave", XFA_EVENT_PreSave, 0},
-    {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, 6},
-    {0x4731d6ba, L"exit", XFA_EVENT_Exit, 2},
-    {0x56bf456b, L"docReady", XFA_EVENT_DocReady, 0},
-    {0x7233018a, L"validate", XFA_EVENT_Validate, 1},
-    {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, 3},
-    {0x891f4606, L"change", XFA_EVENT_Change, 4},
-    {0x9528a7b4, L"prePrint", XFA_EVENT_PrePrint, 0},
-    {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, 5},
-    {0xcdce56b3, L"full", XFA_EVENT_Full, 4},
-    {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, 5},
-    {0xd95657a6, L"click", XFA_EVENT_Click, 4},
-    {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1},
-    {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7},
-    {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2},
-    {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0},
-    {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6},
-};
-const XFA_ExecEventParaInfo* GetEventParaInfoByName(
-    const CFX_WideStringC& wsEventName) {
-  int32_t iLength = wsEventName.GetLength();
-  uint32_t uHash = FX_HashCode_String_GetW(wsEventName.GetPtr(), iLength);
-  const XFA_ExecEventParaInfo* eventParaInfo = NULL;
-  int32_t iStart = 0,
-          iEnd = (sizeof(gs_eventParaInfos) / sizeof(gs_eventParaInfos[0])) - 1;
-  int32_t iMid = (iStart + iEnd) / 2;
-  do {
-    iMid = (iStart + iEnd) / 2;
-    eventParaInfo = &gs_eventParaInfos[iMid];
-    if (uHash == eventParaInfo->m_uHash) {
-      return eventParaInfo;
-    } else if (uHash < eventParaInfo->m_uHash) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return NULL;
-}
-void XFA_STRING_TO_RGB(CFX_WideString& strRGB,
-                       int32_t& r,
-                       int32_t& g,
-                       int32_t& b) {
-  r = 0;
-  g = 0;
-  b = 0;
-  FX_WCHAR zero = '0';
-  int32_t iIndex = 0;
-  int32_t iLen = strRGB.GetLength();
-  for (int32_t i = 0; i < iLen; ++i) {
-    FX_WCHAR ch = strRGB.GetAt(i);
-    if (ch == L',') {
-      ++iIndex;
-    }
-    if (iIndex > 2) {
-      break;
-    }
-    int32_t iValue = ch - zero;
-    if (iValue >= 0 && iValue <= 9) {
-      switch (iIndex) {
-        case 0:
-          r = r * 10 + iValue;
-          break;
-        case 1:
-          g = g * 10 + iValue;
-          break;
-        default:
-          b = b * 10 + iValue;
-          break;
-      }
-    }
-  }
-}
-void CXFA_Node::Script_Som_BorderColor(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CXFA_Border border = pWidgetData->GetBorder(TRUE);
-  int32_t iSize = border.CountEdges();
-  CFX_WideString strColor;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    strColor = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    int32_t r = 0, g = 0, b = 0;
-    XFA_STRING_TO_RGB(strColor, r, g, b);
-    FX_ARGB rgb = ArgbEncode(100, r, g, b);
-    for (int32_t i = 0; i < iSize; ++i) {
-      CXFA_Edge edge = border.GetEdge(i);
-      edge.SetColor(rgb);
-    }
-  } else {
-    CXFA_Edge edge = border.GetEdge(0);
-    FX_ARGB color = edge.GetColor();
-    int32_t a, r, g, b;
-    ArgbDecode(color, a, r, g, b);
-    strColor.Format(L"%d,%d,%d", r, g, b);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(strColor));
-  }
-}
-void CXFA_Node::Script_Som_BorderWidth(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CXFA_Border border = pWidgetData->GetBorder(TRUE);
-  int32_t iSize = border.CountEdges();
-  CFX_WideString wsThickness;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsThickness = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    for (int32_t i = 0; i < iSize; ++i) {
-      CXFA_Edge edge = border.GetEdge(i);
-      CXFA_Measurement thickness(wsThickness);
-      edge.SetMSThickness(thickness);
-    }
-  } else {
-    CXFA_Edge edge = border.GetEdge(0);
-    CXFA_Measurement thickness = edge.GetMSThickness();
-    thickness.ToString(wsThickness);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsThickness));
-  }
-}
-void CXFA_Node::Script_Som_FillColor(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CXFA_Border border = pWidgetData->GetBorder(TRUE);
-  CXFA_Fill borderfill = border.GetFill(TRUE);
-  CXFA_Node* pNode = borderfill.GetNode();
-  if (!pNode) {
-    return;
-  }
-  CFX_WideString wsColor;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsColor = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    int32_t r, g, b;
-    XFA_STRING_TO_RGB(wsColor, r, g, b);
-    FX_ARGB color = ArgbEncode(0xff, r, g, b);
-    borderfill.SetColor(color);
-  } else {
-    FX_ARGB color = borderfill.GetColor();
-    int32_t a, r, g, b;
-    ArgbDecode(color, a, r, g, b);
-    wsColor.Format(L"%d,%d,%d", r, g, b);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor));
-  }
-}
-void CXFA_Node::Script_Som_DataNode(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    CXFA_Node* pDataNode = GetBindData();
-    if (pDataNode) {
-      FXJSE_Value_Set(
-          hValue,
-          m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode));
-    } else {
-      FXJSE_Value_SetNull(hValue);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-void CXFA_Node::Script_Draw_DefaultValue(FXJSE_HVALUE hValue,
-                                         FX_BOOL bSetting,
-                                         XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    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, newValue.GetLength());
-        CFX_WideString wsFormatValue(wsNewValue);
-        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,
-                                FX_UTF8Encode(content, content.GetLength()));
-    }
-  }
-}
-void CXFA_Node::Script_Field_DefaultValue(FXJSE_HVALUE hValue,
-                                          FX_BOOL bSetting,
-                                          XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  if (bSetting) {
-    if (FXJSE_Value_IsNull(hValue)) {
-      pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
-      pWidgetData->m_bIsNull = TRUE;
-    } else {
-      pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
-      pWidgetData->m_bIsNull = FALSE;
-    }
-    CFX_ByteString newValue;
-    if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
-      FXJSE_Value_ToUTF8String(hValue, newValue);
-    }
-    CFX_WideString wsNewText =
-        CFX_WideString::FromUTF8(newValue, newValue.GetLength());
-    CXFA_Node* pUIChild = pWidgetData->GetUIChild();
-    if (pUIChild->GetClassID() == XFA_ELEMENT_NumericEdit) {
-      int32_t iLeadDigits = 0;
-      int32_t iFracDigits = 0;
-      pWidgetData->GetLeadDigits(iLeadDigits);
-      pWidgetData->GetFracDigits(iFracDigits);
-      wsNewText = XFA_NumericLimit(wsNewText, iLeadDigits, iFracDigits);
-    }
-    CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
-    CFX_WideString wsFormatText(wsNewText);
-    if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText);
-    }
-    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) {
-        if (eUI == XFA_ELEMENT_NumericEdit &&
-            (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) {
-          FXJSE_Value_SetUTF8String(
-              hValue, FX_UTF8Encode(content, content.GetLength()));
-        } else {
-          CFX_Decimal decimal(content);
-          FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
-        }
-      } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Integer) {
-        FXJSE_Value_SetInteger(hValue, FXSYS_wtoi(content));
-      } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Boolean) {
-        FXJSE_Value_SetBoolean(hValue, FXSYS_wtoi(content) == 0 ? FALSE : TRUE);
-      } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Float) {
-        CFX_Decimal decimal(content);
-        FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
-      } else {
-        FXJSE_Value_SetUTF8String(hValue,
-                                  FX_UTF8Encode(content, content.GetLength()));
-      }
-    }
-  }
-}
-void CXFA_Node::Script_Field_EditValue(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CFX_WideString wsValue;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    pWidgetData->SetValue(wsValue, XFA_VALUEPICTURE_Edit);
-  } else {
-    pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-  }
-}
-void CXFA_Node::Script_Som_FontColor(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CXFA_Font font = pWidgetData->GetFont(TRUE);
-  CXFA_Node* pNode = font.GetNode();
-  if (!pNode) {
-    return;
-  }
-  CFX_WideString wsColor;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsColor = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    int32_t r, g, b;
-    XFA_STRING_TO_RGB(wsColor, r, g, b);
-    FX_ARGB color = ArgbEncode(0xff, r, g, b);
-    font.SetColor(color);
-  } else {
-    FX_ARGB color = font.GetColor();
-    int32_t a, r, g, b;
-    ArgbDecode(color, a, r, g, b);
-    wsColor.Format(L"%d,%d,%d", r, g, b);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor));
-  }
-}
-void CXFA_Node::Script_Field_FormatMessage(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {
-  Script_Som_Message(hValue, bSetting, XFA_SOM_FormatMessage);
-}
-void CXFA_Node::Script_Field_FormattedValue(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CFX_WideString wsValue;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    pWidgetData->SetValue(wsValue, XFA_VALUEPICTURE_Display);
-  } else {
-    pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-  }
-}
-void CXFA_Node::Script_Som_Mandatory(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CXFA_Validate validate = pWidgetData->GetValidate(TRUE);
-  CFX_WideString wsValue;
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-    validate.SetNullTest(wsValue);
-  } else {
-    int32_t iValue = validate.GetNullTest();
-    const XFA_ATTRIBUTEENUMINFO* pInfo =
-        XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
-    if (pInfo) {
-      wsValue = pInfo->pName;
-    }
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-  }
-}
-void CXFA_Node::Script_Som_MandatoryMessage(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  Script_Som_Message(hValue, bSetting, XFA_SOM_MandatoryMessage);
-}
-void CXFA_Node::Script_Field_ParentSubform(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
-    FXJSE_Value_SetNull(hValue);
-  }
-}
-void CXFA_Node::Script_Field_SelectedIndex(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  if (bSetting) {
-    int32_t iIndex = FXJSE_Value_ToInteger(hValue);
-    if (iIndex == -1) {
-      pWidgetData->ClearAllSelections();
-      return;
-    }
-    pWidgetData->SetItemState(iIndex, TRUE, TRUE, TRUE);
-  } else {
-    FXJSE_Value_SetInteger(hValue, pWidgetData->GetSelectedItem());
-  }
-}
-void CXFA_Node::Script_Field_ClearItems(CFXJSE_Arguments* pArguments) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  pWidgetData->DeleteItem(-1, TRUE);
-}
-void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString eventString = pArguments->GetUTF8String(0);
-    int32_t iRet = execSingleEventByName(
-        CFX_WideString::FromUTF8(eventString, eventString.GetLength()),
-        XFA_ELEMENT_Field);
-    if (eventString == "validate") {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
-                             ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
-  }
-}
-void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
-  }
-}
-void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"deleteItem");
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  FX_BOOL bValue = pWidgetData->DeleteItem(iIndex, TRUE, TRUE);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetBoolean(hValue, bValue);
-  }
-}
-void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem");
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  if (iIndex < 0) {
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-    return;
-  }
-  CFX_WideString wsValue;
-  FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE);
-  if (bHasItem) {
-    FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(),
-                              FX_UTF8Encode(wsValue, wsValue.GetLength()));
-  } else {
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-  }
-}
-void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"boundItem");
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CFX_ByteString bsValue = pArguments->GetUTF8String(0);
-  CFX_WideString wsValue =
-      CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-  CFX_WideString wsBoundValue;
-  pWidgetData->GetItemValue(wsValue, wsBoundValue);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsBoundValue));
-  }
-}
-void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getItemState");
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  FX_BOOL bValue = pWidgetData->GetItemState(iIndex);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetBoolean(hValue, bValue);
-  }
-}
-void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
-  }
-}
-void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments) {}
-void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getDisplayItem");
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  if (iIndex < 0) {
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-    return;
-  }
-  CFX_WideString wsValue;
-  FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE);
-  if (bHasItem) {
-    FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(),
-                              FX_UTF8Encode(wsValue, wsValue.GetLength()));
-  } else {
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-  }
-}
-void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"setItemState");
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  if (pArguments->GetInt32(1) != 0) {
-    pWidgetData->SetItemState(iIndex, TRUE, TRUE, TRUE);
-  } else {
-    if (pWidgetData->GetItemState(iIndex)) {
-      pWidgetData->SetItemState(iIndex, FALSE, TRUE, TRUE);
-    }
-  }
-}
-void CXFA_Node::Script_Field_AddItem(CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addItem");
-    return;
-  }
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  CFX_WideString wsLabel;
-  CFX_WideString wsValue;
-  if (iLength >= 1) {
-    CFX_ByteString bsLable = pArguments->GetUTF8String(0);
-    wsLabel = CFX_WideString::FromUTF8(bsLable, bsLable.GetLength());
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsValue = pArguments->GetUTF8String(1);
-    wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-  }
-  pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE);
-}
-void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      int32_t iRet =
-          pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE);
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
-                             ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
-  }
-}
-void CXFA_Node::Script_ExclGroup_ErrorText(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-void CXFA_Node::Script_ExclGroup_DefaultAndRawValue(FXJSE_HVALUE hValue,
-                                                    FX_BOOL bSetting,
-                                                    XFA_ATTRIBUTE eAttribute) {
-  CXFA_WidgetData* pWidgetData = GetWidgetData();
-  if (!pWidgetData) {
-    return;
-  }
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    pWidgetData->SetSelectedMemberByValue(
-        CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()), TRUE, TRUE);
-  } else {
-    CFX_WideString wsValue = GetScriptContent(TRUE);
-    XFA_VERSION curVersion = GetDocument()->GetCurVersionMode();
-    if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) {
-      FXJSE_Value_SetNull(hValue);
-    } else {
-      FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-    }
-  }
-}
-void CXFA_Node::Script_ExclGroup_Transient(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString eventString = pArguments->GetUTF8String(0);
-    execSingleEventByName(
-        CFX_WideString::FromUTF8(eventString, eventString.GetLength()),
-        XFA_ELEMENT_ExclGroup);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
-  }
-}
-void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if ((argc == 0) || (argc == 1)) {
-    CXFA_WidgetData* pWidgetData = GetWidgetData();
-    if (!pWidgetData) {
-      FXJSE_Value_SetNull(pArguments->GetReturnValue());
-    } else {
-      CXFA_Node* pReturnNode = NULL;
-      if (argc == 0) {
-        pReturnNode = pWidgetData->GetSelectedMember();
-      } else {
-        CFX_ByteString szName;
-        szName = pArguments->GetUTF8String(0);
-        pReturnNode = pWidgetData->SetSelectedMember(
-            CFX_WideString::FromUTF8(szName, szName.GetLength()));
-      }
-      if (pReturnNode) {
-        FXJSE_Value_Set(
-            pArguments->GetReturnValue(),
-            m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode));
-      } else {
-        FXJSE_Value_SetNull(pArguments->GetReturnValue());
-      }
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"selectedMember");
-  }
-}
-void CXFA_Node::Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
-  }
-}
-void CXFA_Node::Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
-  }
-}
-void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
-                             ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
-  }
-}
-static CXFA_Node* XFA_ScriptInstanceManager_GetItem(CXFA_Node* pInstMgrNode,
-                                                    int32_t iIndex) {
-  ASSERT(pInstMgrNode);
-  int32_t iCount = 0;
-  FX_DWORD dwNameHash = 0;
-  for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_ELEMENT eCurType = pNode->GetClassID();
-    if (eCurType == XFA_ELEMENT_InstanceManager) {
-      break;
-    }
-    if ((eCurType != XFA_ELEMENT_Subform) &&
-        (eCurType != XFA_ELEMENT_SubformSet)) {
-      continue;
-    }
-    if (iCount == 0) {
-      CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
-      CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
-      if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
-          wsInstName.Mid(1) != wsName) {
-        return NULL;
-      }
-      dwNameHash = pNode->GetNameHash();
-    }
-    if (dwNameHash != pNode->GetNameHash()) {
-      break;
-    }
-    iCount++;
-    if (iCount > iIndex) {
-      return pNode;
-    }
-  }
-  return NULL;
-}
-void CXFA_Node::Script_Som_InstanceIndex(FXJSE_HVALUE hValue,
-                                         FX_BOOL bSetting,
-                                         XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    int32_t iTo = FXJSE_Value_ToInteger(hValue);
-    int32_t iFrom = Subform_and_SubformSet_InstanceIndex();
-    CXFA_Node* pManagerNode = NULL;
-    for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
-         pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
-        pManagerNode = pNode;
-        break;
-      }
-    }
-    if (pManagerNode) {
-      pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
-      IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-      if (!pNotify) {
-        return;
-      }
-      CXFA_Node* pToInstance =
-          XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo);
-      if (pToInstance && pToInstance->GetClassID() == XFA_ELEMENT_Subform) {
-        pNotify->RunSubformIndexChange(pToInstance);
-      }
-      CXFA_Node* pFromInstance =
-          XFA_ScriptInstanceManager_GetItem(pManagerNode, iFrom);
-      if (pFromInstance && pFromInstance->GetClassID() == XFA_ELEMENT_Subform) {
-        pNotify->RunSubformIndexChange(pFromInstance);
-      }
-    }
-  } else {
-    FXJSE_Value_SetInteger(hValue, Subform_and_SubformSet_InstanceIndex());
-  }
-}
-void CXFA_Node::Script_Subform_InstanceManager(FXJSE_HVALUE hValue,
-                                               FX_BOOL bSetting,
-                                               XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
-    CXFA_Node* pInstanceMgr = NULL;
-    for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
-         pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
-        CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
-        if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
-            wsInstMgrName.Mid(1) == wsName) {
-          pInstanceMgr = pNode;
-        }
-        break;
-      }
-    }
-    if (pInstanceMgr) {
-      FXJSE_Value_Set(
-          hValue,
-          m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr));
-    } else {
-      FXJSE_Value_SetNull(hValue);
-    }
-  } else {
-    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, bsLocaleName.GetLength()),
-             TRUE, TRUE);
-  } else {
-    CFX_WideString wsLocaleName;
-    GetLocaleName(wsLocaleName);
-    FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(wsLocaleName, wsLocaleName.GetLength()));
-  }
-}
-void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString eventString = pArguments->GetUTF8String(0);
-    execSingleEventByName(
-        CFX_WideString::FromUTF8(eventString, eventString.GetLength()),
-        XFA_ELEMENT_Subform);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
-  }
-}
-void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
-  }
-}
-void CXFA_Node::Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
-  }
-}
-void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
-                             ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
-  }
-}
-void CXFA_Node::Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getInvalidObjects");
-  }
-}
-int32_t CXFA_Node::Subform_and_SubformSet_InstanceIndex() {
-  int32_t index = 0;
-  for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-    if ((pNode->GetClassID() == XFA_ELEMENT_Subform) ||
-        (pNode->GetClassID() == XFA_ELEMENT_SubformSet)) {
-      index++;
-    } else {
-      break;
-    }
-  }
-  return index;
-}
-void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
-  }
-}
-void CXFA_Node::Script_Template_Remerge(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    m_pDocument->DoDataRemerge(TRUE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
-  }
-}
-void CXFA_Node::Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    CXFA_WidgetData* pWidgetData = GetWidgetData();
-    if (!pWidgetData) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
-  }
-}
-void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if ((argc > 0) && (argc < 4)) {
-    CFX_WideString strTagName;
-    CFX_WideString strName;
-    CFX_WideString strNameSpace;
-    CFX_ByteString bsTagName = pArguments->GetUTF8String(0);
-    strTagName = CFX_WideString::FromUTF8(bsTagName, bsTagName.GetLength());
-    if (argc > 1) {
-      CFX_ByteString bsName = pArguments->GetUTF8String(1);
-      strName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
-      if (argc == 3) {
-        CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2);
-        strNameSpace =
-            CFX_WideString::FromUTF8(bsNameSpace, bsNameSpace.GetLength());
-      }
-    }
-    const XFA_ELEMENTINFO* pElement = XFA_GetElementByName(strTagName);
-    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, 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,
-                                  (const FX_WCHAR*)strTagName, L"name");
-        }
-      } else {
-        FXJSE_Value_Set(
-            pArguments->GetReturnValue(),
-            m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
-      }
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode");
-  }
-}
-void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments) {
-  if (pArguments->GetLength() == 1) {
-    FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
-  }
-}
-void CXFA_Node::Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    CXFA_WidgetData* pWidgetData = GetWidgetData();
-    if (!pWidgetData) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
-  }
-}
-void CXFA_Node::Script_Template_ExecValidate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    CXFA_WidgetData* pWidgetData = GetWidgetData();
-    if (!pWidgetData) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
-  }
-}
-void CXFA_Node::Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    CXFA_WidgetData* pWidgetData = GetWidgetData();
-    if (!pWidgetData) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"evaluate");
-  }
-}
-void CXFA_Node::Script_InstanceManager_Max(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CXFA_Occur nodeOccur(GetOccurNode());
-  FXJSE_Value_SetInteger(hValue, nodeOccur.GetMax());
-}
-void CXFA_Node::Script_InstanceManager_Min(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CXFA_Occur nodeOccur(GetOccurNode());
-  FXJSE_Value_SetInteger(hValue, nodeOccur.GetMin());
-}
-static int32_t XFA_ScriptInstanceManager_GetCount(CXFA_Node* pInstMgrNode) {
-  ASSERT(pInstMgrNode);
-  int32_t iCount = 0;
-  FX_DWORD dwNameHash = 0;
-  for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_ELEMENT eCurType = pNode->GetClassID();
-    if (eCurType == XFA_ELEMENT_InstanceManager) {
-      break;
-    }
-    if ((eCurType != XFA_ELEMENT_Subform) &&
-        (eCurType != XFA_ELEMENT_SubformSet)) {
-      continue;
-    }
-    if (iCount == 0) {
-      CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
-      CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
-      if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
-          wsInstName.Mid(1) != wsName) {
-        return iCount;
-      }
-      dwNameHash = pNode->GetNameHash();
-    }
-    if (dwNameHash != pNode->GetNameHash()) {
-      break;
-    }
-    iCount++;
-  }
-  return iCount;
-}
-static void
-XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(
-    const CXFA_NodeSet& rgNodeSet,
-    CXFA_NodeArray& rgNodeArray,
-    CFX_ArrayTemplate<int32_t>& rgIdxArray) {
-  int32_t iCount = rgNodeSet.GetCount();
-  rgNodeArray.SetSize(iCount);
-  rgIdxArray.SetSize(iCount);
-  if (iCount == 0) {
-    return;
-  }
-  int32_t iIndex = -1, iTotalIndex = -1;
-  CXFA_Node* pNode = NULL;
-  FX_POSITION pos = rgNodeSet.GetStartPosition();
-  rgNodeSet.GetNextAssoc(pos, pNode);
-  for (pNode = pNode->GetNodeItem(XFA_NODEITEM_Parent)
-                   ->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pNode && iIndex < iCount;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    iTotalIndex++;
-    if (rgNodeSet.Lookup(pNode)) {
-      iIndex++;
-      rgNodeArray[iIndex] = pNode;
-      rgIdxArray[iIndex] = iTotalIndex;
-    }
-  }
-}
-struct CXFA_DualNodeArray {
-  CXFA_NodeSet firstNodeList;
-  CXFA_NodeSet secondNodeList;
-};
-static void XFA_ScriptInstanceManager_ReorderDataNodes(CXFA_NodeSet& sSet1,
-                                                       CXFA_NodeSet& sSet2,
-                                                       FX_BOOL bInsertBefore) {
-  CFX_MapPtrTemplate<CXFA_Node*,
-                     CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>*>
-      rgNodeListMap;
-  FX_POSITION pos;
-  pos = sSet1.GetStartPosition();
-  while (pos) {
-    CXFA_Node* pNode = NULL;
-    sSet1.GetNextAssoc(pos, pNode);
-    CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-    FX_DWORD dwNameHash = pNode->GetNameHash();
-    if (!pParentNode || !dwNameHash) {
-      continue;
-    }
-    CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>* pNodeListChildMap =
-        rgNodeListMap[pParentNode];
-    if (!pNodeListChildMap) {
-      rgNodeListMap[pParentNode] = pNodeListChildMap =
-          new CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>;
-    }
-    CXFA_DualNodeArray* pDualNodeArray = (*pNodeListChildMap)[dwNameHash];
-    if (!pDualNodeArray) {
-      (*pNodeListChildMap)[dwNameHash] = pDualNodeArray =
-          new CXFA_DualNodeArray;
-    }
-    pDualNodeArray->firstNodeList.Add(pNode);
-  }
-  pos = sSet2.GetStartPosition();
-  while (pos) {
-    CXFA_Node* pNode = NULL;
-    sSet2.GetNextAssoc(pos, pNode);
-    CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-    FX_DWORD dwNameHash = pNode->GetNameHash();
-    if (!pParentNode || !dwNameHash) {
-      continue;
-    }
-    CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>* pNodeListChildMap =
-        rgNodeListMap[pParentNode];
-    if (!pNodeListChildMap) {
-      rgNodeListMap[pParentNode] = pNodeListChildMap =
-          new CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>;
-    }
-    CXFA_DualNodeArray* pDualNodeArray = (*pNodeListChildMap)[dwNameHash];
-    if (!pDualNodeArray) {
-      (*pNodeListChildMap)[dwNameHash] = pDualNodeArray =
-          new CXFA_DualNodeArray;
-    }
-    if (pDualNodeArray->firstNodeList.Lookup(pNode)) {
-      pDualNodeArray->firstNodeList.RemoveKey(pNode);
-    } else {
-      pDualNodeArray->secondNodeList.Add(pNode);
-    }
-  }
-  pos = rgNodeListMap.GetStartPosition();
-  while (pos) {
-    CXFA_Node* pParentNode = NULL;
-    CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>* pNodeListChildMap = NULL;
-    rgNodeListMap.GetNextAssoc(pos, pParentNode, pNodeListChildMap);
-    if (!pNodeListChildMap) {
-      continue;
-    }
-    FX_POSITION childpos = pNodeListChildMap->GetStartPosition();
-    while (childpos) {
-      FX_DWORD dwNameHash = 0;
-      CXFA_DualNodeArray* pDualNodeArray = NULL;
-      pNodeListChildMap->GetNextAssoc(childpos, dwNameHash, pDualNodeArray);
-      if (!pDualNodeArray) {
-        continue;
-      }
-      if (pDualNodeArray->firstNodeList.GetCount() != 0 &&
-          pDualNodeArray->secondNodeList.GetCount() != 0) {
-        CXFA_NodeArray rgNodeArray1, rgNodeArray2;
-        CFX_ArrayTemplate<int32_t> rgIdxArray1, rgIdxArray2;
-        XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(
-            pDualNodeArray->firstNodeList, rgNodeArray1, rgIdxArray1);
-        XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(
-            pDualNodeArray->secondNodeList, rgNodeArray2, rgIdxArray2);
-        CXFA_Node *pParentNode = NULL, *pBeforeNode = NULL;
-        if (bInsertBefore) {
-          pBeforeNode = rgNodeArray2[0];
-          pParentNode = pBeforeNode->GetNodeItem(XFA_NODEITEM_Parent);
-        } else {
-          CXFA_Node* pLastNode = rgNodeArray2[rgIdxArray2.GetSize() - 1];
-          pParentNode = pLastNode->GetNodeItem(XFA_NODEITEM_Parent);
-          pBeforeNode = pLastNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-        }
-        for (int32_t iIdx = 0, iCount = rgIdxArray1.GetSize(); iIdx < iCount;
-             iIdx++) {
-          CXFA_Node* pCurNode = rgNodeArray1[iIdx];
-          pParentNode->RemoveChild(pCurNode);
-          pParentNode->InsertChild(pCurNode, pBeforeNode);
-        }
-      }
-      delete pDualNodeArray;
-    }
-    pNodeListChildMap->RemoveAll();
-  }
-  rgNodeListMap.RemoveAll();
-}
-static void XFA_ScriptInstanceManager_InsertItem(
-    CXFA_Node* pInstMgrNode,
-    CXFA_Node* pNewInstance,
-    int32_t iPos,
-    int32_t iCount = -1,
-    FX_BOOL bMoveDataBindingNodes = TRUE) {
-  if (iCount < 0) {
-    iCount = XFA_ScriptInstanceManager_GetCount(pInstMgrNode);
-  }
-  if (iPos < 0) {
-    iPos = iCount;
-  }
-  if (iPos == iCount) {
-    CXFA_Node* pNextSibling =
-        iCount > 0
-            ? XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iCount - 1)
-                  ->GetNodeItem(XFA_NODEITEM_NextSibling)
-            : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-    pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
-        ->InsertChild(pNewInstance, pNextSibling);
-    if (bMoveDataBindingNodes) {
-      CXFA_NodeSet sNew, sAfter;
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorNew(pNewInstance);
-      for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode;
-           pNode = sIteratorNew.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sNew.Add(pDataNode);
-      }
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorAfter(pNextSibling);
-      for (CXFA_Node* pNode = sIteratorAfter.GetCurrent(); pNode;
-           pNode = sIteratorAfter.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sAfter.Add(pDataNode);
-      }
-      XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sAfter, FALSE);
-    }
-  } else {
-    CXFA_Node* pBeforeInstance =
-        XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iPos);
-    pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
-        ->InsertChild(pNewInstance, pBeforeInstance);
-    if (bMoveDataBindingNodes) {
-      CXFA_NodeSet sNew, sBefore;
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorNew(pNewInstance);
-      for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode;
-           pNode = sIteratorNew.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sNew.Add(pDataNode);
-      }
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorBefore(pBeforeInstance);
-      for (CXFA_Node* pNode = sIteratorBefore.GetCurrent(); pNode;
-           pNode = sIteratorBefore.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sBefore.Add(pDataNode);
-      }
-      XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sBefore, TRUE);
-    }
-  }
-}
-static void XFA_ScriptInstanceManager_RemoveItem(
-    CXFA_Node* pInstMgrNode,
-    CXFA_Node* pRemoveInstance,
-    FX_BOOL bRemoveDataBinding = TRUE) {
-  pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance);
-  if (!bRemoveDataBinding) {
-    return;
-  }
-  CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
-      sIterator(pRemoveInstance);
-  for (CXFA_Node* pFormNode = sIterator.GetCurrent(); pFormNode;
-       pFormNode = sIterator.MoveToNext()) {
-    CXFA_Node* pDataNode = pFormNode->GetBindData();
-    if (!pDataNode) {
-      continue;
-    }
-    if (pDataNode->RemoveBindItem(pFormNode) == 0) {
-      if (CXFA_Node* pDataParent =
-              pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) {
-        pDataParent->RemoveChild(pDataNode);
-      }
-    }
-    pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
-  }
-}
-static CXFA_Node* XFA_ScriptInstanceManager_CreateInstance(
-    CXFA_Node* pInstMgrNode,
-    FX_BOOL bDataMerge) {
-  CXFA_Document* pDocument = pInstMgrNode->GetDocument();
-  CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode();
-  CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent);
-  CXFA_Node* pDataScope = NULL;
-  for (CXFA_Node* pRootBoundNode = pFormParent;
-       pRootBoundNode &&
-       pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode;
-       pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
-    pDataScope = pRootBoundNode->GetBindData();
-    if (pDataScope) {
-      break;
-    }
-  }
-  if (!pDataScope) {
-    pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
-    ASSERT(pDataScope);
-  }
-  CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer(
-      pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge);
-  if (pInstance) {
-    pDocument->DataMerge_UpdateBindingRelations(pInstance);
-    pFormParent->RemoveChild(pInstance);
-  }
-  return pInstance;
-}
-void CXFA_Node::Script_InstanceManager_Count(FXJSE_HVALUE hValue,
-                                             FX_BOOL bSetting,
-                                             XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    int32_t iDesired = FXJSE_Value_ToInteger(hValue);
-    InstanceManager_SetInstances(iDesired);
-  } else {
-    FXJSE_Value_SetInteger(hValue, XFA_ScriptInstanceManager_GetCount(this));
-  }
-}
-void CXFA_Node::Script_InstanceManager_MoveInstance(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc != 2) {
-    FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
-    return;
-  }
-  int32_t iFrom = pArguments->GetInt32(0);
-  int32_t iTo = pArguments->GetInt32(1);
-  InstanceManager_MoveInstance(iTo, iFrom);
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo);
-  if (pToInstance && pToInstance->GetClassID() == XFA_ELEMENT_Subform) {
-    pNotify->RunSubformIndexChange(pToInstance);
-  }
-  CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
-  if (pFromInstance && pFromInstance->GetClassID() == XFA_ELEMENT_Subform) {
-    pNotify->RunSubformIndexChange(pFromInstance);
-  }
-}
-void CXFA_Node::Script_InstanceManager_RemoveInstance(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc != 1) {
-    FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
-  if (iIndex < 0 || iIndex >= iCount) {
-    ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
-    return;
-  }
-  CXFA_Occur nodeOccur(GetOccurNode());
-  int32_t iMin = nodeOccur.GetMin();
-  if (iCount - 1 < iMin) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"min");
-    return;
-  }
-  CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
-  XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (pNotify) {
-    for (int32_t i = iIndex; i < iCount - 1; i++) {
-      CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
-      if (pSubformInstance &&
-          pSubformInstance->GetClassID() == XFA_ELEMENT_Subform) {
-        pNotify->RunSubformIndexChange(pSubformInstance);
-      }
-    }
-  }
-  CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (!pLayoutPro) {
-    return;
-  }
-  pLayoutPro->AddChangedContainer(
-      ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
-}
-void CXFA_Node::Script_InstanceManager_SetInstances(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc != 1) {
-    FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
-    return;
-  }
-  int32_t iDesired = pArguments->GetInt32(0);
-  InstanceManager_SetInstances(iDesired);
-}
-void CXFA_Node::Script_InstanceManager_AddInstance(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if ((argc != 0) && (argc != 1)) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addInstance");
-    return;
-  }
-  FX_BOOL fFlags = TRUE;
-  if (argc == 1) {
-    fFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
-  }
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
-  CXFA_Occur nodeOccur(GetOccurNode());
-  int32_t iMax = nodeOccur.GetMax();
-  if (iMax >= 0 && iCount >= iMax) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
-    return;
-  }
-  CXFA_Node* pNewInstance =
-      XFA_ScriptInstanceManager_CreateInstance(this, fFlags);
-  XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
-                                       FALSE);
-  FXJSE_Value_Set(
-      pArguments->GetReturnValue(),
-      m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  pNotify->RunNodeInitialize(pNewInstance);
-  CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (!pLayoutPro) {
-    return;
-  }
-  pLayoutPro->AddChangedContainer(
-      ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
-}
-void CXFA_Node::Script_InstanceManager_InsertInstance(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if ((argc != 1) && (argc != 2)) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"insertInstance");
-    return;
-  }
-  int32_t iIndex = pArguments->GetInt32(0);
-  FX_BOOL bBind = FALSE;
-  if (argc == 2) {
-    bBind = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
-  }
-  CXFA_Occur nodeOccur(GetOccurNode());
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
-  if (iIndex < 0 || iIndex > iCount) {
-    ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
-    return;
-  }
-  int32_t iMax = nodeOccur.GetMax();
-  if (iMax >= 0 && iCount >= iMax) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
-    return;
-  }
-  CXFA_Node* pNewInstance =
-      XFA_ScriptInstanceManager_CreateInstance(this, bBind);
-  XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iIndex, iCount,
-                                       TRUE);
-  FXJSE_Value_Set(
-      pArguments->GetReturnValue(),
-      m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  pNotify->RunNodeInitialize(pNewInstance);
-  CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (!pLayoutPro) {
-    return;
-  }
-  pLayoutPro->AddChangedContainer(
-      ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
-}
-int32_t CXFA_Node::InstanceManager_SetInstances(int32_t iDesired) {
-  CXFA_Occur nodeOccur(GetOccurNode());
-  int32_t iMax = nodeOccur.GetMax();
-  int32_t iMin = nodeOccur.GetMin();
-  if (iDesired < iMin) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"min");
-    return 1;
-  }
-  if ((iMax >= 0) && (iDesired > iMax)) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
-    return 2;
-  }
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
-  if (iDesired == iCount) {
-    return 0;
-  }
-  if (iDesired < iCount) {
-    CFX_WideStringC wsInstManagerName = GetCData(XFA_ATTRIBUTE_Name);
-    CFX_WideString wsInstanceName = wsInstManagerName.IsEmpty()
-                                        ? wsInstManagerName
-                                        : wsInstManagerName.Mid(1);
-    FX_DWORD dInstanceNameHash =
-        wsInstanceName.IsEmpty() ? 0 : FX_HashCode_String_GetW(
-                                           wsInstanceName,
-                                           wsInstanceName.GetLength());
-    CXFA_Node* pPrevSibling =
-        (iDesired == 0) ? this
-                        : XFA_ScriptInstanceManager_GetItem(this, iDesired - 1);
-    while (iCount > iDesired) {
-      CXFA_Node* pRemoveInstance =
-          pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling);
-      if (pRemoveInstance->GetClassID() != XFA_ELEMENT_Subform &&
-          pRemoveInstance->GetClassID() != XFA_ELEMENT_SubformSet) {
-        continue;
-      }
-      if (pRemoveInstance->GetClassID() == XFA_ELEMENT_InstanceManager) {
-        FXSYS_assert(FALSE);
-        break;
-      }
-      if (pRemoveInstance->GetNameHash() == dInstanceNameHash) {
-        XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
-        iCount--;
-      }
-    }
-  } else if (iDesired > iCount) {
-    while (iCount < iDesired) {
-      CXFA_Node* pNewInstance =
-          XFA_ScriptInstanceManager_CreateInstance(this, TRUE);
-      XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
-                                           FALSE);
-      iCount++;
-      IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-      if (!pNotify) {
-        return 0;
-      }
-      pNotify->RunNodeInitialize(pNewInstance);
-    }
-  }
-  CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (pLayoutPro) {
-    pLayoutPro->AddChangedContainer(
-        ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
-  }
-  return 0;
-}
-int32_t CXFA_Node::InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom) {
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
-  if (iFrom > iCount || iTo > iCount - 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
-    return 1;
-  }
-  if (iFrom < 0 || iTo < 0 || iFrom == iTo) {
-    return 0;
-  }
-  CXFA_Node* pMoveInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
-  XFA_ScriptInstanceManager_RemoveItem(this, pMoveInstance, FALSE);
-  XFA_ScriptInstanceManager_InsertItem(this, pMoveInstance, iTo, iCount - 1,
-                                       TRUE);
-  CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (pLayoutPro) {
-    pLayoutPro->AddChangedContainer(
-        ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
-  }
-  return 0;
-}
-void CXFA_Node::Script_Occur_Max(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute) {
-  CXFA_Occur occur(this);
-  if (bSetting) {
-    int32_t iMax = FXJSE_Value_ToInteger(hValue);
-    occur.SetMax(iMax);
-  } else {
-    FXJSE_Value_SetInteger(hValue, occur.GetMax());
-  }
-}
-void CXFA_Node::Script_Occur_Min(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute) {
-  CXFA_Occur occur(this);
-  if (bSetting) {
-    int32_t iMin = FXJSE_Value_ToInteger(hValue);
-    occur.SetMin(iMin);
-  } else {
-    FXJSE_Value_SetInteger(hValue, occur.GetMin());
-  }
-}
-void CXFA_Node::Script_Desc_Metadata(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if ((argc == 0) || (argc == 1)) {
-    FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), "");
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"metadata");
-  }
-}
-void CXFA_Node::Script_Form_FormNodes(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CXFA_Node* pDataNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    if (pDataNode) {
-      CXFA_NodeArray formItems;
-      CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument);
-      pFormNodes->SetArrayNodeList(formItems);
-      FXJSE_Value_SetObject(
-          pArguments->GetReturnValue(), (CXFA_Object*)pFormNodes,
-          m_pDocument->GetScriptContext()->GetJseNormalClass());
-    } else {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
-  }
-}
-void CXFA_Node::Script_Form_Remerge(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    m_pDocument->DoDataRemerge(TRUE);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
-  }
-}
-void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
-  }
-}
-void CXFA_Node::Script_Form_Recalculate(CFXJSE_Arguments* pArguments) {
-  CXFA_EventParam* pEventParam =
-      m_pDocument->GetScriptContext()->GetEventParam();
-  if (pEventParam->m_eType == XFA_EVENT_Calculate ||
-      pEventParam->m_eType == XFA_EVENT_InitCalculate) {
-    return;
-  }
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    const bool bScriptFlags = pArguments->GetInt32(0) != 0;
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    if (bScriptFlags) {
-      pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
-      pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
-      pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, TRUE);
-    } else {
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
-  }
-}
-void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return;
-    }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
-  }
-}
-void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
-    } else {
-      int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
-      FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
-                             ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
-  }
-}
-void CXFA_Node::Script_Form_Checksum(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    CFX_ByteString bsChecksum;
-    FXJSE_Value_ToUTF8String(hValue, bsChecksum);
-    SetAttribute(XFA_ATTRIBUTE_Checksum,
-                 CFX_WideString::FromUTF8(bsChecksum, bsChecksum.GetLength()));
-  } else {
-    CFX_WideString wsChecksum;
-    GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
-    FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(wsChecksum, wsChecksum.GetLength()));
-  }
-}
-void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0);
-    CFX_WideString wsAttributeValue;
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      ((IFDE_XMLElement*)pXMLNode)
-          ->GetString(CFX_WideString::FromUTF8(bsAttributeName,
-                                               bsAttributeName.GetLength()),
-                      wsAttributeValue);
-    }
-    FXJSE_Value_SetUTF8String(
-        pArguments->GetReturnValue(),
-        FX_UTF8Encode(wsAttributeValue, wsAttributeValue.GetLength()));
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getAttribute");
-  }
-}
-void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 2) {
-    CFX_ByteString bsValue = pArguments->GetUTF8String(0);
-    CFX_ByteString bsName = pArguments->GetUTF8String(1);
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      ((IFDE_XMLElement*)pXMLNode)
-          ->SetString(CFX_WideString::FromUTF8(bsName, bsName.GetLength()),
-                      CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()));
-    }
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"setAttribute");
-  }
-}
-void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString bsName = pArguments->GetUTF8String(0);
-    CFX_WideString wsName =
-        CFX_WideString::FromUTF8(bsName, bsName.GetLength());
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
-      if (pXMLElement->HasAttribute(wsName)) {
-        pXMLElement->RemoveAttribute(wsName);
-      }
-    }
-    FXJSE_Value_SetNull(pArguments->GetReturnValue());
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"removeAttribute");
-  }
-}
-void CXFA_Node::Script_Packet_Content(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    CFX_ByteString bsNewContent;
-    FXJSE_Value_ToUTF8String(hValue, bsNewContent);
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
-      pXMLElement->SetTextData(
-          CFX_WideString::FromUTF8(bsNewContent, bsNewContent.GetLength()));
-    }
-  } else {
-    CFX_WideString wsTextData;
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
-      pXMLElement->GetTextData(wsTextData);
-    }
-    FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(wsTextData, wsTextData.GetLength()));
-  }
-}
-void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"next");
-  }
-}
-void CXFA_Node::Script_Source_CancelBatch(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancelBatch");
-  }
-}
-void CXFA_Node::Script_Source_First(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"first");
-  }
-}
-void CXFA_Node::Script_Source_UpdateBatch(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"updateBatch");
-  }
-}
-void CXFA_Node::Script_Source_Previous(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"previous");
-  }
-}
-void CXFA_Node::Script_Source_IsBOF(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isBOF");
-  }
-}
-void CXFA_Node::Script_Source_IsEOF(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isEOF");
-  }
-}
-void CXFA_Node::Script_Source_Cancel(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancel");
-  }
-}
-void CXFA_Node::Script_Source_Update(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"update");
-  }
-}
-void CXFA_Node::Script_Source_Open(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"open");
-  }
-}
-void CXFA_Node::Script_Source_Delete(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"delete");
-  }
-}
-void CXFA_Node::Script_Source_AddNew(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addNew");
-  }
-}
-void CXFA_Node::Script_Source_Requery(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"requery");
-  }
-}
-void CXFA_Node::Script_Source_Resync(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resync");
-  }
-}
-void CXFA_Node::Script_Source_Close(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"close");
-  }
-}
-void CXFA_Node::Script_Source_Last(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"last");
-  }
-}
-void CXFA_Node::Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 0) {
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"hasDataChanged");
-  }
-}
-void CXFA_Node::Script_Source_Db(FXJSE_HVALUE hValue,
-                                 FX_BOOL bSetting,
-                                 XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_Xfa_This(FXJSE_HVALUE hValue,
-                                FX_BOOL bSetting,
-                                XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    CXFA_Object* pThis = m_pDocument->GetScriptContext()->GetThisObject();
-    FXSYS_assert(pThis);
-    FXJSE_Value_Set(hValue,
-                    m_pDocument->GetScriptContext()->GetJSValueFromMap(pThis));
-  }
-}
-void CXFA_Node::Script_Handler_Version(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_SubmitFormat_Mode(FXJSE_HVALUE hValue,
-                                         FX_BOOL bSetting,
-                                         XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_Extras_Type(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute) {}
-void CXFA_Node::Script_Script_Stateless(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(FX_WSTRC(L"0")));
-}
-void CXFA_Node::Script_Encrypt_Format(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute) {}
-enum XFA_KEYTYPE {
-  XFA_KEYTYPE_Custom,
-  XFA_KEYTYPE_Element,
-};
-void* XFA_GetMapKey_Custom(const CFX_WideStringC& wsKey) {
-  FX_DWORD dwKey = FX_HashCode_String_GetW(wsKey.GetPtr(), wsKey.GetLength());
-  return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
-}
-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) {
-  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;
-  }
-  switch (eType) {
-    case XFA_ATTRIBUTETYPE_Enum: {
-      const XFA_ATTRIBUTEENUMINFO* pEnum = XFA_GetAttributeEnumByName(wsValue);
-      return SetEnum(pAttr->eName,
-                     pEnum ? pEnum->eName
-                           : (XFA_ATTRIBUTEENUM)(intptr_t)(pAttr->pDefValue),
-                     bNotify);
-    } break;
-    case XFA_ATTRIBUTETYPE_Cdata:
-      return SetCData(pAttr->eName, wsValue, bNotify);
-    case XFA_ATTRIBUTETYPE_Boolean:
-      return SetBoolean(pAttr->eName, wsValue != FX_WSTRC(L"0"), bNotify);
-    case XFA_ATTRIBUTETYPE_Integer:
-      return SetInteger(
-          pAttr->eName,
-          FXSYS_round(FX_wcstof(wsValue.GetPtr(), wsValue.GetLength())),
-          bNotify);
-    case XFA_ATTRIBUTETYPE_Measure:
-      return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify);
-    default:
-      break;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
-                                CFX_WideString& wsValue,
-                                FX_BOOL bUseDefault) {
-  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;
-  }
-  switch (eType) {
-    case XFA_ATTRIBUTETYPE_Enum: {
-      XFA_ATTRIBUTEENUM eValue;
-      if (!TryEnum(pAttr->eName, eValue, bUseDefault)) {
-        return FALSE;
-      }
-      wsValue = XFA_GetAttributeEnumByID(eValue)->pName;
-      return TRUE;
-    } break;
-    case XFA_ATTRIBUTETYPE_Cdata: {
-      CFX_WideStringC wsValueC;
-      if (!TryCData(pAttr->eName, wsValueC, bUseDefault)) {
-        return FALSE;
-      }
-      wsValue = wsValueC;
-      return TRUE;
-    } break;
-    case XFA_ATTRIBUTETYPE_Boolean: {
-      FX_BOOL bValue;
-      if (!TryBoolean(pAttr->eName, bValue, bUseDefault)) {
-        return FALSE;
-      }
-      wsValue = bValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0");
-      return TRUE;
-    } break;
-    case XFA_ATTRIBUTETYPE_Integer: {
-      int32_t iValue;
-      if (!TryInteger(pAttr->eName, iValue, bUseDefault)) {
-        return FALSE;
-      }
-      wsValue.Format(L"%d", iValue);
-      return TRUE;
-    } break;
-    case XFA_ATTRIBUTETYPE_Measure: {
-      CXFA_Measurement mValue;
-      if (!TryMeasure(pAttr->eName, mValue, bUseDefault)) {
-        return FALSE;
-      }
-      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) {
-  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,
-                                FX_BOOL bUseDefault) {
-  const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsAttr);
-  if (pAttributeInfo) {
-    return GetAttribute(pAttributeInfo->eName, wsValue, bUseDefault);
-  }
-  void* pKey = XFA_GetMapKey_Custom(wsAttr);
-  CFX_WideStringC wsValueC;
-  if (GetMapModuleString(pKey, wsValueC)) {
-    wsValue = wsValueC;
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) {
-  void* pKey = XFA_GetMapKey_Custom(wsAttr);
-  RemoveMapModuleKey(pKey);
-  return TRUE;
-}
-FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr,
-                              FX_BOOL& bValue,
-                              FX_BOOL bUseDefault) {
-  void* pValue = NULL;
-  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue)) {
-    return FALSE;
-  }
-  bValue = (FX_BOOL)(uintptr_t)pValue;
-  return TRUE;
-}
-FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr,
-                              int32_t& iValue,
-                              FX_BOOL bUseDefault) {
-  void* pValue = NULL;
-  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue)) {
-    return FALSE;
-  }
-  iValue = (int32_t)(uintptr_t)pValue;
-  return TRUE;
-}
-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) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  OnChanging(eAttr, &mValue, bNotify);
-  SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
-  OnChanged(eAttr, &mValue, bNotify);
-  return TRUE;
-}
-FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr,
-                              CXFA_Measurement& mValue,
-                              FX_BOOL bUseDefault) const {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  void* pValue;
-  int32_t iBytes;
-  if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) {
-    FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
-    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,
-                            FX_BOOL bScriptModify) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  OnChanging(eAttr, (void*)(const FX_WCHAR*)wsValue, bNotify);
-  if (eAttr == XFA_ATTRIBUTE_Value) {
-    CFX_WideString* pClone = new CFX_WideString(wsValue);
-    SetUserData(pKey, pClone, &deleteWideStringCallBack);
-  } else {
-    SetMapModuleString(pKey, wsValue);
-    if (eAttr == XFA_ATTRIBUTE_Name)
-      UpdateNameHash();
-  }
-  OnChanged(eAttr, (void*)(const FX_WCHAR*)wsValue, 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()) {
-            ((IFDE_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) {
-              ((IFDE_XMLElement*)m_pXMLNode)->DeleteChildren();
-            }
-            ((IFDE_XMLElement*)m_pXMLNode)->SetTextData(wsValue);
-          }
-          break;
-        case FDE_XMLNODE_Text:
-          ((IFDE_XMLText*)m_pXMLNode)->SetText(wsValue);
-          break;
-        default:
-          FXSYS_assert(0);
-      }
-      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;
-      }
-      ((IFDE_XMLElement*)m_pXMLNode)->SetString(wsAttrName, wsValue);
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
-                                     const CFX_WideString& wsXMLValue,
-                                     FX_BOOL bNotify,
-                                     FX_BOOL bScriptModify) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), XFA_ATTRIBUTE_Value);
-  OnChanging(XFA_ATTRIBUTE_Value, (void*)(const FX_WCHAR*)wsValue, bNotify);
-  CFX_WideString* pClone = new CFX_WideString(wsValue);
-  SetUserData(pKey, pClone, &deleteWideStringCallBack);
-  OnChanged(XFA_ATTRIBUTE_Value, (void*)(const FX_WCHAR*)wsValue, bNotify,
-            bScriptModify);
-  if (IsNeedSavingXMLNode()) {
-    FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
-    switch (eXMLType) {
-      case FDE_XMLNODE_Element:
-        if (IsAttributeInXML()) {
-          ((IFDE_XMLElement*)m_pXMLNode)
-              ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsXMLValue);
-        } 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) {
-            ((IFDE_XMLElement*)m_pXMLNode)->DeleteChildren();
-          }
-          ((IFDE_XMLElement*)m_pXMLNode)->SetTextData(wsXMLValue);
-        }
-        break;
-      case FDE_XMLNODE_Text:
-        ((IFDE_XMLText*)m_pXMLNode)->SetText(wsXMLValue);
-        break;
-      default:
-        FXSYS_assert(0);
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
-                            CFX_WideString& wsValue,
-                            FX_BOOL bUseDefault,
-                            FX_BOOL bProto) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  if (eAttr == XFA_ATTRIBUTE_Value) {
-    CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
-    if (pStr) {
-      wsValue = *pStr;
-      return TRUE;
-    }
-  } else {
-    CFX_WideStringC wsValueC;
-    if (GetMapModuleString(pKey, wsValueC)) {
-      wsValue = wsValueC;
-      return TRUE;
-    }
-  }
-  if (!bUseDefault) {
-    return FALSE;
-  }
-  void* pValue = NULL;
-  if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
-                                   XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
-    wsValue = (const FX_WCHAR*)pValue;
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
-                            CFX_WideStringC& wsValue,
-                            FX_BOOL bUseDefault,
-                            FX_BOOL bProto) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  if (eAttr == XFA_ATTRIBUTE_Value) {
-    CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
-    if (pStr) {
-      wsValue = *pStr;
-      return TRUE;
-    }
-  } else {
-    if (GetMapModuleString(pKey, wsValue)) {
-      return TRUE;
-    }
-  }
-  if (!bUseDefault) {
-    return FALSE;
-  }
-  void* pValue = NULL;
-  if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
-                                   XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
-    wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue;
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr,
-                             void* pData,
-                             XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  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) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  OnChanging(eAttr, pValue, bNotify);
-  SetMapModuleValue(pKey, pValue);
-  OnChanged(eAttr, pValue, bNotify);
-  if (IsNeedSavingXMLNode()) {
-    FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
-    const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
-    if (pInfo) {
-      switch (eType) {
-        case XFA_ATTRIBUTETYPE_Enum:
-          ((IFDE_XMLElement*)m_pXMLNode)
-              ->SetString(
-                  pInfo->pName,
-                  XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
-                      ->pName);
-          break;
-        case XFA_ATTRIBUTETYPE_Boolean:
-          ((IFDE_XMLElement*)m_pXMLNode)
-              ->SetString(pInfo->pName,
-                          pValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0"));
-          break;
-        case XFA_ATTRIBUTETYPE_Integer:
-          ((IFDE_XMLElement*)m_pXMLNode)
-              ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue);
-          break;
-        default:
-          FXSYS_assert(0);
-      }
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr,
-                            XFA_ATTRIBUTETYPE eType,
-                            FX_BOOL bUseDefault,
-                            void*& pValue) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
-  if (GetMapModuleValue(pKey, pValue)) {
-    return TRUE;
-  }
-  if (!bUseDefault) {
-    return FALSE;
-  }
-  return XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, eType,
-                                      m_ePacket);
-}
-static void XFA_DefaultFreeData(void* pData) {}
-static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {
-    XFA_DefaultFreeData, NULL};
-FX_BOOL CXFA_Node::SetUserData(void* pKey,
-                               void* pData,
-                               XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
-  SetMapModuleBuffer(pKey, &pData, sizeof(void*),
-                     pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData);
-  return TRUE;
-}
-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,
-                                    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);
-        pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, FX_WSTRC(L"text/xml"));
-        pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
-                                      bScriptModify, FALSE);
-        CXFA_Node* pBind = GetBindData();
-        if (bSyncData && pBind) {
-          CFX_WideStringArray wsSaveTextArray;
-          int32_t iSize = 0;
-          if (!wsContent.IsEmpty()) {
-            int32_t iStart = 0;
-            int32_t iLength = wsContent.GetLength();
-            int32_t iEnd = wsContent.Find(L'\n', iStart);
-            iEnd = (iEnd == -1) ? iLength : iEnd;
-            while (iEnd >= iStart) {
-              wsSaveTextArray.Add(wsContent.Mid(iStart, iEnd - iStart));
-              iStart = iEnd + 1;
-              if (iStart >= iLength) {
-                break;
-              }
-              iEnd = wsContent.Find(L'\n', iStart);
-              if (iEnd < 0) {
-                wsSaveTextArray.Add(wsContent.Mid(iStart, iLength - iStart));
-              }
-            }
-            iSize = wsSaveTextArray.GetSize();
-          }
-          if (iSize == 0) {
-            while (CXFA_Node* pChildNode =
-                       pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-              pBind->RemoveChild(pChildNode);
-            }
-          } else {
-            CXFA_NodeArray valueNodes;
-            int32_t iDatas = pBind->GetNodeList(
-                valueNodes, XFA_NODEFILTER_Children, XFA_ELEMENT_DataValue);
-            if (iDatas < iSize) {
-              int32_t iAddNodes = iSize - iDatas;
-              CXFA_Node* pValueNodes = NULL;
-              while (iAddNodes-- > 0) {
-                pValueNodes =
-                    pBind->CreateSamePacketNode(XFA_ELEMENT_DataValue);
-                pValueNodes->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"value"));
-                pValueNodes->CreateXMLMappingNode();
-                pBind->InsertChild(pValueNodes);
-              }
-              pValueNodes = NULL;
-            } else if (iDatas > iSize) {
-              int32_t iDelNodes = iDatas - iSize;
-              while (iDelNodes-- > 0) {
-                pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild));
-              }
-            }
-            int32_t i = 0;
-            for (CXFA_Node* pValueNode =
-                     pBind->GetNodeItem(XFA_NODEITEM_FirstChild);
-                 pValueNode; pValueNode = pValueNode->GetNodeItem(
-                                 XFA_NODEITEM_NextSibling)) {
-              pValueNode->SetAttributeValue(wsSaveTextArray[i],
-                                            wsSaveTextArray[i], FALSE);
-              i++;
-            }
-          }
-          CXFA_NodeArray nodeArray;
-          pBind->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,
-                                    bScriptModify, FALSE);
-          }
-        }
-        break;
-      } else if (GetClassID() == XFA_ELEMENT_ExclGroup) {
-        pNode = this;
-      } else {
-        CXFA_Node* pValue = GetProperty(0, XFA_ELEMENT_Value);
-        CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
-        FXSYS_assert(pChildValue);
-        pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
-                                      bScriptModify, FALSE);
-      }
-      pBindNode = GetBindData();
-      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);
-        }
-      }
-      pBindNode = NULL;
-      break;
-    }
-    case XFA_OBJECTTYPE_ContentNode: {
-      CFX_WideString wsContentType;
-      if (GetClassID() == XFA_ELEMENT_ExData) {
-        GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
-        if (wsContentType.Equal(FX_WSTRC(L"text/html"))) {
-          wsContentType = FX_WSTRC(L"");
-          SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType);
-        }
-      }
-      CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (!pContentRawDataNode) {
-        pContentRawDataNode =
-            CreateSamePacketNode((wsContentType.Equal(FX_WSTRC(L"text/xml")))
-                                     ? XFA_ELEMENT_Sharpxml
-                                     : XFA_ELEMENT_Sharptext);
-        InsertChild(pContentRawDataNode);
-      }
-      return pContentRawDataNode->SetScriptContent(
-          wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData);
-    } break;
-    case XFA_OBJECTTYPE_NodeC:
-    case XFA_OBJECTTYPE_TextNode:
-      pNode = this;
-      break;
-    case XFA_OBJECTTYPE_NodeV:
-      pNode = this;
-      if (bSyncData && GetPacketID() == XFA_XDPPACKET_Form) {
-        CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
-        if (pParent) {
-          pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
-        }
-        if (pParent && pParent->GetClassID() == XFA_ELEMENT_Value) {
-          pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
-          if (pParent && pParent->IsContainerNode()) {
-            pBindNode = pParent->GetBindData();
-            if (pBindNode) {
-              pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
-                                          bScriptModify, FALSE);
-            }
-          }
-        }
-      }
-      break;
-    default:
-      if (GetClassID() == XFA_ELEMENT_DataValue) {
-        pNode = this;
-        pBindNode = this;
-      }
-      break;
-  }
-  if (pNode) {
-    SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify);
-    if (pBindNode && bSyncData) {
-      CXFA_NodeArray nodeArray;
-      pBindNode->GetBindItems(nodeArray);
-      for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
-        CXFA_Node* pNode = nodeArray[i];
-        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,
-                              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() {
-  return GetScriptContent();
-}
-FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent,
-                              FX_BOOL bScriptModify,
-                              FX_BOOL bProto) {
-  CXFA_Node* pNode = NULL;
-  switch (GetObjectType()) {
-    case XFA_OBJECTTYPE_ContainerNode:
-      if (GetClassID() == XFA_ELEMENT_ExclGroup) {
-        pNode = this;
-      } else {
-        CXFA_Node* pValue = GetChild(0, XFA_ELEMENT_Value);
-        if (!pValue) {
-          return FALSE;
-        }
-        CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
-        if (pChildValue && XFA_FieldIsMultiListBox(this)) {
-          pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType,
-                                    FX_WSTRC(L"text/xml"));
-        }
-        return pChildValue
-                   ? pChildValue->TryContent(wsContent, bScriptModify, bProto)
-                   : FALSE;
-      }
-      break;
-    case XFA_OBJECTTYPE_ContentNode: {
-      CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (!pContentRawDataNode) {
-        XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
-        if (GetClassID() == XFA_ELEMENT_ExData) {
-          CFX_WideString wsContentType;
-          GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
-          if (wsContentType.Equal(FX_WSTRC(L"text/html"))) {
-            element = XFA_ELEMENT_SharpxHTML;
-          } else if (wsContentType.Equal(FX_WSTRC(L"text/xml"))) {
-            element = XFA_ELEMENT_Sharpxml;
-          }
-        }
-        pContentRawDataNode = CreateSamePacketNode(element);
-        InsertChild(pContentRawDataNode);
-      }
-      return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto);
-    }
-    case XFA_OBJECTTYPE_NodeC:
-    case XFA_OBJECTTYPE_NodeV:
-    case XFA_OBJECTTYPE_TextNode:
-      pNode = this;
-    default:
-      if (GetClassID() == XFA_ELEMENT_DataValue) {
-        pNode = this;
-      }
-      break;
-  }
-  if (pNode) {
-    if (bScriptModify) {
-      IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-      if (pScriptContext) {
-        m_pDocument->GetScriptContext()->AddNodesOfRunScript(this);
-      }
-    }
-    return TryCData(XFA_ATTRIBUTE_Value, wsContent, FALSE, bProto);
-  }
-  return FALSE;
-}
-CXFA_Node* CXFA_Node::GetModelNode() {
-  switch (GetPacketID()) {
-    case XFA_XDPPACKET_XDP:
-      return m_pDocument->GetRoot();
-    case XFA_XDPPACKET_Config:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config));
-    case XFA_XDPPACKET_Template:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
-    case XFA_XDPPACKET_Form:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
-    case XFA_XDPPACKET_Datasets:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets));
-    case XFA_XDPPACKET_LocaleSet:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet));
-    case XFA_XDPPACKET_ConnectionSet:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet));
-    case XFA_XDPPACKET_SourceSet:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
-    case XFA_XDPPACKET_Xdc:
-      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
-    default:
-      return this;
-  }
-}
-FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
-  wsNamespace.Empty();
-  if (GetObjectType() == XFA_OBJECTTYPE_ModelNode ||
-      GetClassID() == XFA_ELEMENT_Packet) {
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
-      return FALSE;
-    }
-    ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
-    return TRUE;
-  } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
-    if (!pXMLNode) {
-      return FALSE;
-    }
-    if (pXMLNode->GetType() != FDE_XMLNODE_Element) {
-      return TRUE;
-    }
-    if (GetClassID() == XFA_ELEMENT_DataValue &&
-        GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
-      return XFA_FDEExtension_ResolveNamespaceQualifier(
-          (IFDE_XMLElement*)pXMLNode, GetCData(XFA_ATTRIBUTE_QualifiedName),
-          wsNamespace);
-    }
-    ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
-    return TRUE;
-  } else {
-    CXFA_Node* pModelNode = GetModelNode();
-    return pModelNode->TryNamespace(wsNamespace);
-  }
-}
-CXFA_Node* CXFA_Node::GetProperty(int32_t index,
-                                  XFA_ELEMENT eProperty,
-                                  FX_BOOL bCreateProperty) {
-  XFA_ELEMENT eElement = GetClassID();
-  FX_DWORD dwPacket = GetPacketID();
-  const XFA_PROPERTY* pProperty =
-      XFA_GetPropertyOfElement(eElement, eProperty, dwPacket);
-  if (pProperty == NULL || index >= pProperty->uOccur) {
-    return NULL;
-  }
-  CXFA_Node* pNode = m_pChild;
-  int32_t iCount = 0;
-  for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eProperty) {
-      iCount++;
-      if (iCount > index) {
-        return pNode;
-      }
-    }
-  }
-  if (!bCreateProperty) {
-    return NULL;
-  }
-  if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) {
-    pNode = m_pChild;
-    for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      const XFA_PROPERTY* pExistProperty =
-          XFA_GetPropertyOfElement(eElement, pNode->GetClassID(), dwPacket);
-      if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
-        return NULL;
-      }
-    }
-  }
-  IXFA_ObjFactory* 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);
-  }
-  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(
-            GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
-        if (pProperty) {
-          continue;
-        }
-      }
-      iCount++;
-    }
-  }
-  return iCount;
-}
-CXFA_Node* CXFA_Node::GetChild(int32_t index,
-                               XFA_ELEMENT eElement,
-                               FX_BOOL bOnlyChild) {
-  FXSYS_assert(index > -1);
-  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(
-            GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
-        if (pProperty) {
-          continue;
-        }
-      }
-      iCount++;
-      if (iCount > index) {
-        return pNode;
-      }
-    }
-  }
-  return NULL;
-}
-int32_t CXFA_Node::InsertChild(int32_t index, CXFA_Node* pNode) {
-  ASSERT(!pNode->m_pNext);
-  pNode->m_pParent = this;
-  FX_BOOL bWasPurgeNode = m_pDocument->RemovePurgeNode(pNode);
-  if (!bWasPurgeNode)
-    FXSYS_assert(false);
-
-  if (m_pChild == NULL || index == 0) {
-    if (index > 0) {
-      return -1;
-    }
-    pNode->m_pNext = m_pChild;
-    m_pChild = pNode;
-    index = 0;
-  } else if (index < 0) {
-    m_pLastChild->m_pNext = pNode;
-  } else {
-    CXFA_Node* pPrev = m_pChild;
-    int32_t iCount = 0;
-    while (++iCount != index && pPrev->m_pNext) {
-      pPrev = pPrev->m_pNext;
-    }
-    if (index > 0 && index != iCount) {
-      return -1;
-    }
-    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);
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (pNotify) {
-    pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
-  }
-  if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
-    FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(IFDE_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)) {
-    FXSYS_assert(false);
-    return FALSE;
-  }
-  FX_BOOL bWasPurgeNode = m_pDocument->RemovePurgeNode(pNode);
-  if (!bWasPurgeNode)
-    FXSYS_assert(false);
-
-  int32_t nIndex = -1;
-  pNode->m_pParent = this;
-  if (m_pChild == NULL || pBeforeNode == m_pChild) {
-    pNode->m_pNext = m_pChild;
-    m_pChild = pNode;
-    nIndex = 0;
-  } else if (!pBeforeNode) {
-    pNode->m_pNext = m_pLastChild->m_pNext;
-    m_pLastChild->m_pNext = pNode;
-  } else {
-    nIndex = 1;
-    CXFA_Node* pPrev = m_pChild;
-    while (pPrev->m_pNext != pBeforeNode) {
-      pPrev = pPrev->m_pNext;
-      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);
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (pNotify) {
-    pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
-  }
-  if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
-    FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(IFDE_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) {
-  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);
-  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) {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)(pNode->m_pXMLNode);
-        CFX_WideStringC wsAttributeName =
-            pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
-        pXMLElement->RemoveAttribute(wsAttributeName.GetPtr());
-      }
-      CFX_WideString wsName;
-      pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
-      IFDE_XMLElement* pNewXMLElement = IFDE_XMLElement::Create(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);
-  }
-  return TRUE;
-}
-CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const {
-  return GetFirstChildByName(
-      wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
-                                                     wsName.GetLength()));
-}
-CXFA_Node* CXFA_Node::GetFirstChildByName(FX_DWORD dwNameHash) const {
-  for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetNameHash() == dwNameHash) {
-      return pNode;
-    }
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_ELEMENT eElement) const {
-  for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement) {
-      return pNode;
-    }
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_Node::GetNextSameNameSibling(FX_DWORD dwNameHash) const {
-  for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetNameHash() == dwNameHash) {
-      return pNode;
-    }
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_Node::GetNextSameNameSibling(
-    const CFX_WideStringC& wsNodeName) const {
-  return GetNextSameNameSibling(
-      wsNodeName.IsEmpty() ? 0
-                           : FX_HashCode_String_GetW(wsNodeName.GetPtr(),
-                                                     wsNodeName.GetLength()));
-}
-CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_ELEMENT eElement) const {
-  for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement) {
-      return pNode;
-    }
-  }
-  return NULL;
-}
-int32_t CXFA_Node::GetNodeSameNameIndex() const {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return -1;
-  }
-  return pScriptContext->GetIndexByName(const_cast<CXFA_Node*>(this));
-}
-int32_t CXFA_Node::GetNodeSameClassIndex() const {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return -1;
-  }
-  return pScriptContext->GetIndexByClassName(const_cast<CXFA_Node*>(this));
-}
-void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression) {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  pScriptContext->GetSomExpression(this, wsSOMExpression);
-}
-CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() {
-  CXFA_Node* pInstanceMgr = NULL;
-  if (m_ePacket == XFA_XDPPACKET_Form) {
-    CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-    if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_Area) {
-      return pInstanceMgr;
-    }
-    for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
-         pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      XFA_ELEMENT eType = pNode->GetClassID();
-      if ((eType == XFA_ELEMENT_Subform || eType == XFA_ELEMENT_SubformSet) &&
-          pNode->m_dwNameHash != m_dwNameHash) {
-        break;
-      }
-      if (eType == XFA_ELEMENT_InstanceManager) {
-        CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
-        CFX_WideStringC wsInstName = pNode->GetCData(XFA_ATTRIBUTE_Name);
-        if (wsInstName.GetLength() > 0 && wsInstName.GetAt(0) == '_' &&
-            wsInstName.Mid(1) == wsName) {
-          pInstanceMgr = pNode;
-        }
-        break;
-      }
-    }
-  }
-  return pInstanceMgr;
-}
-CXFA_Node* CXFA_Node::GetOccurNode() {
-  return GetFirstChildByClass(XFA_ELEMENT_Occur);
-}
-FX_BOOL CXFA_Node::HasFlag(FX_DWORD dwFlag) const {
-  if (m_uFlags & dwFlag) {
-    return TRUE;
-  }
-  switch (dwFlag) {
-    case XFA_NODEFLAG_HasRemoved:
-      return m_pParent && m_pParent->HasFlag(dwFlag);
-    default:
-      break;
-  }
-  return FALSE;
-}
-void CXFA_Node::SetFlag(FX_DWORD dwFlag, FX_BOOL bOn, FX_BOOL bNotify) {
-  if (bOn) {
-    switch (dwFlag) {
-      case XFA_NODEFLAG_Initialized:
-        if (bNotify && !HasFlag(XFA_NODEFLAG_Initialized)) {
-          IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-          if (pNotify) {
-            pNotify->OnNodeEvent(this, XFA_NODEEVENT_Ready);
-          }
-        }
-        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) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (pNotify) {
-      pNotify->OnNodeEvent(pParent, XFA_NODEEVENT_ChildRemoved, pRemoved);
-    }
-  }
-}
-void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr,
-                           void* pNewValue,
-                           FX_BOOL bNotify) {
-  if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (pNotify) {
-      pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanging,
-                           (void*)(uintptr_t)eAttr, pNewValue);
-    }
-  }
-}
-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;
-    IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-    if (!pNotify) {
-      return iRet;
-    }
-    if (validFlags == 1) {
-      iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType);
-    } else if (validFlags == 2) {
-      iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                           FALSE, FALSE);
-    } else if (validFlags == 3) {
-      if (eElementType == XFA_ELEMENT_Subform) {
-        iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                             FALSE, FALSE);
-      }
-    } else if (validFlags == 4) {
-      if (eElementType == XFA_ELEMENT_ExclGroup ||
-          eElementType == XFA_ELEMENT_Field) {
-        CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-        if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
-          iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                               FALSE, FALSE);
-        }
-        iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                             FALSE, FALSE);
-      }
-    } else if (validFlags == 5) {
-      if (eElementType == XFA_ELEMENT_Field) {
-        iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                             FALSE, FALSE);
-      }
-    } else if (validFlags == 6) {
-      CXFA_WidgetData* pWidgetData = GetWidgetData();
-      if (pWidgetData) {
-        CXFA_Node* pUINode = pWidgetData->GetUIChild();
-        if (pUINode->m_eNodeClass == XFA_ELEMENT_Signature) {
-          iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                               FALSE, FALSE);
-        }
-      }
-    } else if (validFlags == 7) {
-      CXFA_WidgetData* pWidgetData = GetWidgetData();
-      if (pWidgetData) {
-        CXFA_Node* pUINode = pWidgetData->GetUIChild();
-        if ((pUINode->m_eNodeClass == XFA_ELEMENT_ChoiceList) &&
-            (!pWidgetData->IsListBox())) {
-          iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                               FALSE, FALSE);
-        }
-      }
-    }
-  }
-  return iRet;
-}
-void CXFA_Node::UpdateNameHash() {
-  const XFA_NOTSUREATTRIBUTE* pNotsure =
-      XFA_GetNotsureAttribute(GetClassID(), XFA_ATTRIBUTE_Name);
-  if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
-    CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
-    m_dwNameHash =
-        wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
-                                                       wsName.GetLength());
-  } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
-    CFX_WideStringC wsName =
-        XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
-    m_dwNameHash =
-        wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
-                                                       wsName.GetLength());
-  }
-}
-IFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
-  if (!m_pXMLNode) {
-    CFX_WideStringC wsTag = GetCData(XFA_ATTRIBUTE_Name);
-    m_pXMLNode = IFDE_XMLElement::Create(wsTag);
-    SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, 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)
-    m_pMapModuleData = new XFA_MAPMODULEDATA;
-  return m_pMapModuleData;
-}
-
-XFA_MAPMODULEDATA* CXFA_Node::GetMapModuleData() const {
-  return m_pMapModuleData;
-}
-
-void CXFA_Node::SetMapModuleValue(void* pKey, void* pValue) {
-  XFA_MAPMODULEDATA* pModule = CreateMapModuleData();
-  pModule->m_ValueMap.SetAt(pKey, pValue);
-}
-
-FX_BOOL CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) {
-  CXFA_Node* pNode = this;
-  while (pNode) {
-    XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
-    if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) {
-      return TRUE;
-    }
-    pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets
-                ? pNode->GetTemplateNode()
-                : NULL;
-  }
-  return FALSE;
-}
-void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) {
-  SetMapModuleBuffer(pKey, (void*)wsValue.GetPtr(),
-                     wsValue.GetLength() * sizeof(FX_WCHAR));
-}
-FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
-  void* pValue;
-  int32_t iBytes;
-  if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
-    return FALSE;
-  }
-  wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR));
-  return TRUE;
-}
-void CXFA_Node::SetMapModuleBuffer(
-    void* pKey,
-    void* pValue,
-    int32_t iBytes,
-    XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
-  XFA_MAPMODULEDATA* pModule = CreateMapModuleData();
-  XFA_MAPDATABLOCK*& pBuffer = pModule->m_BufferMap[pKey];
-  if (pBuffer == NULL) {
-    pBuffer =
-        (XFA_MAPDATABLOCK*)FX_Alloc(uint8_t, sizeof(XFA_MAPDATABLOCK) + iBytes);
-  } else if (pBuffer->iBytes != iBytes) {
-    if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
-      pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-    }
-    pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc(uint8_t, pBuffer,
-                                            sizeof(XFA_MAPDATABLOCK) + iBytes);
-  } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
-    pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-  }
-  if (pBuffer == NULL) {
-    return;
-  }
-  pBuffer->pCallbackInfo = pCallbackInfo;
-  pBuffer->iBytes = iBytes;
-  FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes);
-}
-FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey,
-                                      void*& pValue,
-                                      int32_t& iBytes,
-                                      FX_BOOL bProtoAlso) const {
-  XFA_MAPDATABLOCK* pBuffer = NULL;
-  const CXFA_Node* pNode = this;
-  while (pNode) {
-    XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
-    if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) {
-      break;
-    }
-    pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
-                ? pNode->GetTemplateNode()
-                : NULL;
-  }
-  if (pBuffer == NULL) {
-    return FALSE;
-  }
-  pValue = pBuffer->GetData();
-  iBytes = pBuffer->iBytes;
-  return TRUE;
-}
-FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) {
-  CXFA_Node* pNode = this;
-  while (pNode) {
-    void* pVal;
-    XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
-    if (pModule &&
-        (pModule->m_ValueMap.Lookup(pKey, pVal) ||
-         pModule->m_BufferMap.Lookup(pKey, (XFA_MAPDATABLOCK*&)pVal))) {
-      return TRUE;
-    }
-    pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
-                ? pNode->GetTemplateNode()
-                : NULL;
-  }
-  return FALSE;
-}
-void CXFA_Node::RemoveMapModuleKey(void* pKey) {
-  XFA_MAPMODULEDATA* pModule = GetMapModuleData();
-  if (!pModule)
-    return;
-
-  if (pKey) {
-    XFA_MAPDATABLOCK* pBuffer = NULL;
-    pModule->m_BufferMap.Lookup(pKey, pBuffer);
-    if (pBuffer) {
-      if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
-        pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-      }
-      FX_Free(pBuffer);
-    }
-    pModule->m_BufferMap.RemoveKey(pKey);
-    pModule->m_ValueMap.RemoveKey(pKey);
-  } else {
-    XFA_MAPDATABLOCK* pBuffer;
-    FX_POSITION posBuffer = pModule->m_BufferMap.GetStartPosition();
-    while (posBuffer) {
-      pModule->m_BufferMap.GetNextAssoc(posBuffer, pKey, pBuffer);
-      if (pBuffer) {
-        if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
-          pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-        }
-        FX_Free(pBuffer);
-      }
-    }
-    pModule->m_BufferMap.RemoveAll();
-    pModule->m_ValueMap.RemoveAll();
-    delete pModule;
-  }
-}
-void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) {
-  XFA_MAPMODULEDATA* pDstModuleData =
-      static_cast<CXFA_Node*>(pDstModule)->CreateMapModuleData();
-  XFA_MAPMODULEDATA* pSrcModuleData = GetMapModuleData();
-  if (!pSrcModuleData) {
-    return;
-  }
-  FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition();
-  while (psValue) {
-    void* pKey;
-    void* pValue;
-    pSrcModuleData->m_ValueMap.GetNextAssoc(psValue, pKey, pValue);
-    if (bUseSrcAttr || !pDstModuleData->m_ValueMap.GetValueAt(pKey)) {
-      pDstModuleData->m_ValueMap.SetAt(pKey, pValue);
-    }
-  }
-  FX_POSITION psBuffer = pSrcModuleData->m_BufferMap.GetStartPosition();
-  while (psBuffer) {
-    void* pKey;
-    XFA_MAPDATABLOCK* pSrcBuffer;
-    pSrcModuleData->m_BufferMap.GetNextAssoc(psBuffer, pKey, pSrcBuffer);
-    XFA_MAPDATABLOCK*& pBuffer = pDstModuleData->m_BufferMap[pKey];
-    if (pBuffer && !bUseSrcAttr) {
-      continue;
-    }
-    if (pSrcBuffer->pCallbackInfo && pSrcBuffer->pCallbackInfo->pFree &&
-        !pSrcBuffer->pCallbackInfo->pCopy) {
-      if (pBuffer) {
-        pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-        pDstModuleData->m_BufferMap.RemoveKey(pKey);
-      }
-      continue;
-    }
-    if (pBuffer == NULL) {
-      pBuffer = (XFA_MAPDATABLOCK*)FX_Alloc(
-          uint8_t, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes);
-    } else if (pBuffer->iBytes != pSrcBuffer->iBytes) {
-      if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
-        pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-      }
-      pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc(
-          uint8_t, pBuffer, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes);
-    } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
-      pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
-    }
-    if (pBuffer == NULL) {
-      continue;
-    }
-    pBuffer->pCallbackInfo = pSrcBuffer->pCallbackInfo;
-    pBuffer->iBytes = pSrcBuffer->iBytes;
-    FXSYS_memcpy(pBuffer->GetData(), pSrcBuffer->GetData(), pSrcBuffer->iBytes);
-    if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pCopy) {
-      pBuffer->pCallbackInfo->pCopy(*(void**)pBuffer->GetData());
-    }
-  }
-}
-void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) {
-  if (!pDstModule) {
-    return;
-  }
-  FX_BOOL bNeedMove = TRUE;
-  if (!pKey) {
-    bNeedMove = FALSE;
-  }
-  if (pDstModule->GetClassID() != GetClassID()) {
-    bNeedMove = FALSE;
-  }
-  XFA_MAPMODULEDATA* pSrcModuleData = NULL;
-  XFA_MAPMODULEDATA* pDstModuleData = NULL;
-  if (bNeedMove) {
-    pSrcModuleData = GetMapModuleData();
-    if (!pSrcModuleData) {
-      bNeedMove = FALSE;
-    }
-    pDstModuleData = pDstModule->CreateMapModuleData();
-  }
-  if (bNeedMove) {
-    void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey);
-    if (pBufferBlockData) {
-      pSrcModuleData->m_BufferMap.RemoveKey(pKey);
-      pDstModuleData->m_BufferMap.RemoveKey(pKey);
-      pDstModuleData->m_BufferMap.SetAt(pKey,
-                                        (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, wsFormatValue);
-    }
-    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) {
-    CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild);
-    CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild);
-    for (; pSrcChild && pDstChild;
-         pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
-         pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
-    }
-  }
-  pSrcModule->MoveBufferMapData(pDstModule, pKey);
-}
-CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
-    : CXFA_Object(pDocument, XFA_OBJECTTYPE_NodeList) {
-  m_pDocument->GetScriptContext()->CacheList(this);
-}
-CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
-  int32_t iCount = GetLength();
-  FX_DWORD dwHashCode =
-      FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());
-  for (int32_t i = 0; i < iCount; i++) {
-    CXFA_Node* ret = Item(i);
-    if (dwHashCode == ret->GetNameHash()) {
-      return ret;
-    }
-  }
-  return NULL;
-}
-void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    if (pNode) {
-      Append(pNode);
-    } else {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"append");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Insert(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 2) {
-    CXFA_Node* pNewNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    CXFA_Node* pBeforeNode = static_cast<CXFA_Node*>(pArguments->GetObject(1));
-    if (pNewNode) {
-      Insert(pNewNode, pBeforeNode);
-    } else {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insert");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Remove(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    if (pNode) {
-      Remove(pNode);
-    } else {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remove");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Item(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    int32_t iIndex = pArguments->GetInt32(0);
-    if ((iIndex >= 0) && (iIndex + 1 <= GetLength())) {
-      FXJSE_Value_Set(
-          pArguments->GetReturnValue(),
-          m_pDocument->GetScriptContext()->GetJSValueFromMap(Item(iIndex)));
-    } else {
-      ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
-    }
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"item");
-  }
-}
-void CXFA_NodeList::Script_TreelistClass_NamedItem(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString szName = pArguments->GetUTF8String(0);
-    CXFA_Node* pNode =
-        NamedItem(CFX_WideString::FromUTF8(szName, szName.GetLength()));
-    if (!pNode) {
-      return;
-    }
-    FXJSE_Value_Set(pArguments->GetReturnValue(),
-                    m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"namedItem");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Length(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    FXJSE_Value_SetInteger(hValue, GetLength());
-  } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-CXFA_ArrayNodeList::CXFA_ArrayNodeList(CXFA_Document* pDocument)
-    : CXFA_NodeList(pDocument) {}
-void CXFA_ArrayNodeList::SetArrayNodeList(const CXFA_NodeArray& srcArray) {
-  if (srcArray.GetSize() > 0) {
-    m_array.Copy(srcArray);
-  }
-}
-int32_t CXFA_ArrayNodeList::GetLength() {
-  return m_array.GetSize();
-}
-FX_BOOL CXFA_ArrayNodeList::Append(CXFA_Node* pNode) {
-  m_array.Add(pNode);
-  return TRUE;
-}
-FX_BOOL CXFA_ArrayNodeList::Insert(CXFA_Node* pNewNode,
-                                   CXFA_Node* pBeforeNode) {
-  if (pBeforeNode == NULL) {
-    m_array.Add(pNewNode);
-  } else {
-    int32_t iSize = m_array.GetSize();
-    for (int32_t i = 0; i < iSize; ++i) {
-      if (m_array[i] == pBeforeNode) {
-        m_array.InsertAt(i, pNewNode);
-        break;
-      }
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_ArrayNodeList::Remove(CXFA_Node* pNode) {
-  int32_t iSize = m_array.GetSize();
-  for (int32_t i = 0; i < iSize; ++i) {
-    if (m_array[i] == pNode) {
-      m_array.RemoveAt(i);
-      break;
-    }
-  }
-  return TRUE;
-}
-CXFA_Node* CXFA_ArrayNodeList::Item(int32_t iIndex) {
-  int32_t iSize = m_array.GetSize();
-  if (iIndex >= 0 && iIndex < iSize) {
-    return m_array[iIndex];
-  }
-  return NULL;
-}
-CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument,
-                                         CXFA_Node* pAttachNode)
-    : CXFA_NodeList(pDocument) {
-  m_pAttachNode = pAttachNode;
-}
-int32_t CXFA_AttachNodeList::GetLength() {
-  return m_pAttachNode->CountChildren(
-      XFA_ELEMENT_UNKNOWN, m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
-}
-FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode) {
-  CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParent) {
-    pParent->RemoveChild(pNode);
-  }
-  return m_pAttachNode->InsertChild(pNode);
-}
-FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode,
-                                    CXFA_Node* pBeforeNode) {
-  CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParent) {
-    pParent->RemoveChild(pNewNode);
-  }
-  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);
-}
diff --git a/xfa/src/fxfa/parser/xfa_objectacc_imp.cpp b/xfa/src/fxfa/parser/xfa_objectacc_imp.cpp
deleted file mode 100644
index 9515237683..0000000000
--- a/xfa/src/fxfa/parser/xfa_objectacc_imp.cpp
+++ /dev/null
@@ -1,3760 +0,0 @@
-// 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 "core/include/fxcrt/fx_ext.h"
-#include "xfa/include/fxbarcode/BC_BarCode.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_localevalue.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-static FX_ARGB XFA_WStringToColor(const CFX_WideStringC& wsValue) {
-  uint8_t r = 0, g = 0, b = 0;
-  if (wsValue.GetLength() == 0) {
-    return 0xff000000;
-  }
-  int cc = 0;
-  const FX_WCHAR* str = wsValue.GetPtr();
-  int len = wsValue.GetLength();
-  while (XFA_IsSpace(str[cc]) && cc < len) {
-    cc++;
-  }
-  if (cc >= len) {
-    return 0xff000000;
-  }
-  while (cc < len) {
-    if (str[cc] == ',' || !XFA_IsDigit(str[cc])) {
-      break;
-    }
-    r = r * 10 + str[cc] - '0';
-    cc++;
-  }
-  if (cc < len && str[cc] == ',') {
-    cc++;
-    while (XFA_IsSpace(str[cc]) && cc < len) {
-      cc++;
-    }
-    while (cc < len) {
-      if (str[cc] == ',' || !XFA_IsDigit(str[cc])) {
-        break;
-      }
-      g = g * 10 + str[cc] - '0';
-      cc++;
-    }
-    if (cc < len && str[cc] == ',') {
-      cc++;
-      while (XFA_IsSpace(str[cc]) && cc < len) {
-        cc++;
-      }
-      while (cc < len) {
-        if (str[cc] == ',' || !XFA_IsDigit(str[cc])) {
-          break;
-        }
-        b = b * 10 + str[cc] - '0';
-        cc++;
-      }
-    }
-  }
-  return (0xff << 24) | (r << 16) | (g << 8) | b;
-}
-XFA_ELEMENT CXFA_Data::GetClassID() const {
-  return m_pNode ? m_pNode->GetClassID() : XFA_ELEMENT_UNKNOWN;
-}
-FX_BOOL CXFA_Data::TryMeasure(XFA_ATTRIBUTE eAttr,
-                              FX_FLOAT& fValue,
-                              FX_BOOL bUseDefault) const {
-  CXFA_Measurement ms;
-  if (m_pNode->TryMeasure(eAttr, ms, bUseDefault)) {
-    fValue = ms.ToUnit(XFA_UNIT_Pt);
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_Data::SetMeasure(XFA_ATTRIBUTE eAttr, FX_FLOAT fValue) {
-  CXFA_Measurement ms(fValue, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(eAttr, ms);
-}
-CXFA_Fill::CXFA_Fill(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-CXFA_Fill::~CXFA_Fill() {}
-int32_t CXFA_Fill::GetPresence() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Presence);
-}
-void CXFA_Fill::SetColor(FX_ARGB color) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Color);
-  CFX_WideString wsColor;
-  int a, r, g, b;
-  ArgbDecode(color, a, r, g, b);
-  wsColor.Format(L"%d,%d,%d", r, g, b);
-  pNode->SetCData(XFA_ATTRIBUTE_Value, wsColor);
-}
-FX_ARGB CXFA_Fill::GetColor(FX_BOOL bText) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Color)) {
-    CFX_WideStringC wsColor;
-    if (pNode->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE)) {
-      return XFA_WStringToColor(wsColor);
-    }
-  }
-  if (bText) {
-    return 0xFF000000;
-  }
-  return 0xFFFFFFFF;
-}
-int32_t CXFA_Fill::GetFillType() {
-  CXFA_Node* pChild = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  while (pChild) {
-    int32_t eType = pChild->GetClassID();
-    if (eType != XFA_ELEMENT_Color && eType != XFA_ELEMENT_Extras) {
-      return eType;
-    }
-    pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  return XFA_ELEMENT_Solid;
-}
-int32_t CXFA_Fill::GetPattern(FX_ARGB& foreColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Pattern);
-  if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {
-    CFX_WideStringC wsColor;
-    pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);
-    foreColor = XFA_WStringToColor(wsColor);
-  } else {
-    foreColor = 0xFF000000;
-  }
-  return pNode->GetEnum(XFA_ATTRIBUTE_Type);
-}
-int32_t CXFA_Fill::GetStipple(FX_ARGB& stippleColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Stipple);
-  int32_t eAttr = 50;
-  pNode->TryInteger(XFA_ATTRIBUTE_Rate, eAttr);
-  if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {
-    CFX_WideStringC wsColor;
-    pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);
-    stippleColor = XFA_WStringToColor(wsColor);
-  } else {
-    stippleColor = 0xFF000000;
-  }
-  return eAttr;
-}
-int32_t CXFA_Fill::GetLinear(FX_ARGB& endColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Linear);
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_ToRight;
-  pNode->TryEnum(XFA_ATTRIBUTE_Type, eAttr);
-  if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {
-    CFX_WideStringC wsColor;
-    pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);
-    endColor = XFA_WStringToColor(wsColor);
-  } else {
-    endColor = 0xFF000000;
-  }
-  return eAttr;
-}
-int32_t CXFA_Fill::GetRadial(FX_ARGB& endColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Radial);
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_ToEdge;
-  pNode->TryEnum(XFA_ATTRIBUTE_Type, eAttr);
-  if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {
-    CFX_WideStringC wsColor;
-    pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);
-    endColor = XFA_WStringToColor(wsColor);
-  } else {
-    endColor = 0xFF000000;
-  }
-  return eAttr;
-}
-FX_BOOL CXFA_Fill::SetPresence(int32_t iPresence) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Presence, (XFA_ATTRIBUTEENUM)iPresence);
-}
-FX_BOOL CXFA_Fill::SetFillType(int32_t iType) {
-  return FALSE;
-}
-FX_BOOL CXFA_Fill::SetPattern(int32_t iPattern, FX_ARGB foreColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Pattern);
-  CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);
-  CFX_WideString wsColor;
-  int a, r, g, b;
-  ArgbDecode(foreColor, a, r, g, b);
-  wsColor.Format(L"%d,%d,%d", r, g, b);
-  pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);
-  return pNode->SetEnum(XFA_ATTRIBUTE_Type, (XFA_ATTRIBUTEENUM)iPattern);
-}
-FX_BOOL CXFA_Fill::SetStipple(int32_t iStipple, FX_ARGB stippleColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Stipple);
-  CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);
-  CFX_WideString wsColor;
-  int a, r, g, b;
-  ArgbDecode(stippleColor, a, r, g, b);
-  wsColor.Format(L"%d,%d,%d", r, g, b);
-  pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);
-  return pNode->SetEnum(XFA_ATTRIBUTE_Rate, (XFA_ATTRIBUTEENUM)iStipple);
-}
-FX_BOOL CXFA_Fill::SetLinear(int32_t iLinear, FX_ARGB endColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Linear);
-  CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);
-  CFX_WideString wsColor;
-  int a, r, g, b;
-  ArgbDecode(endColor, a, r, g, b);
-  wsColor.Format(L"%d,%d,%d", r, g, b);
-  pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);
-  return pNode->SetEnum(XFA_ATTRIBUTE_Type, (XFA_ATTRIBUTEENUM)iLinear);
-}
-FX_BOOL CXFA_Fill::SetRadial(int32_t iRadial, FX_ARGB endColor) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Radial);
-  CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);
-  CFX_WideString wsColor;
-  int a, r, g, b;
-  ArgbDecode(endColor, a, r, g, b);
-  wsColor.Format(L"%d,%d,%d", r, g, b);
-  pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);
-  return pNode->SetEnum(XFA_ATTRIBUTE_Type, (XFA_ATTRIBUTEENUM)iRadial);
-}
-CXFA_Margin::CXFA_Margin(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-FX_BOOL CXFA_Margin::GetLeftInset(FX_FLOAT& fInset, FX_FLOAT fDefInset) const {
-  fInset = fDefInset;
-  return TryMeasure(XFA_ATTRIBUTE_LeftInset, fInset);
-}
-FX_BOOL CXFA_Margin::GetTopInset(FX_FLOAT& fInset, FX_FLOAT fDefInset) const {
-  fInset = fDefInset;
-  return TryMeasure(XFA_ATTRIBUTE_TopInset, fInset);
-}
-FX_BOOL CXFA_Margin::GetRightInset(FX_FLOAT& fInset, FX_FLOAT fDefInset) const {
-  fInset = fDefInset;
-  return TryMeasure(XFA_ATTRIBUTE_RightInset, fInset);
-}
-FX_BOOL CXFA_Margin::GetBottomInset(FX_FLOAT& fInset,
-                                    FX_FLOAT fDefInset) const {
-  fInset = fDefInset;
-  return TryMeasure(XFA_ATTRIBUTE_BottomInset, fInset);
-}
-FX_BOOL CXFA_Margin::SetLeftInset(FX_FLOAT fInset) {
-  return SetMeasure(XFA_ATTRIBUTE_LeftInset, fInset);
-}
-FX_BOOL CXFA_Margin::SetTopInset(FX_FLOAT fInset) {
-  return SetMeasure(XFA_ATTRIBUTE_TopInset, fInset);
-}
-FX_BOOL CXFA_Margin::SetRightInset(FX_FLOAT fInset) {
-  return SetMeasure(XFA_ATTRIBUTE_RightInset, fInset);
-}
-FX_BOOL CXFA_Margin::SetBottomInset(FX_FLOAT fInset) {
-  return SetMeasure(XFA_ATTRIBUTE_BottomInset, fInset);
-}
-CXFA_Font::CXFA_Font(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-FX_FLOAT CXFA_Font::GetBaselineShift() {
-  return m_pNode->GetMeasure(XFA_ATTRIBUTE_BaselineShift).ToUnit(XFA_UNIT_Pt);
-}
-FX_FLOAT CXFA_Font::GetHorizontalScale() {
-  CFX_WideString wsValue;
-  m_pNode->TryCData(XFA_ATTRIBUTE_FontHorizontalScale, wsValue);
-  int32_t iScale = FXSYS_wtoi((const FX_WCHAR*)wsValue);
-  return iScale > 0 ? (FX_FLOAT)iScale : 100.0f;
-}
-FX_FLOAT CXFA_Font::GetVerticalScale() {
-  CFX_WideString wsValue;
-  m_pNode->TryCData(XFA_ATTRIBUTE_FontVerticalScale, wsValue);
-  int32_t iScale = FXSYS_wtoi((const FX_WCHAR*)wsValue);
-  return iScale > 0 ? (FX_FLOAT)iScale : 100.0f;
-}
-FX_FLOAT CXFA_Font::GetLetterSpacing() {
-  CFX_WideStringC wsValue;
-  if (!m_pNode->TryCData(XFA_ATTRIBUTE_LetterSpacing, wsValue)) {
-    return 0;
-  }
-  CXFA_Measurement ms(wsValue);
-  if (ms.GetUnit() == XFA_UNIT_Em) {
-    return ms.GetValue() * GetFontSize();
-  }
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-int32_t CXFA_Font::GetLineThrough() {
-  int32_t iValue = 0;
-  m_pNode->TryInteger(XFA_ATTRIBUTE_LineThrough, iValue);
-  return iValue;
-}
-int32_t CXFA_Font::GetLineThroughPeriod() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_All;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_LineThroughPeriod, eAttr);
-  return eAttr;
-}
-int32_t CXFA_Font::GetOverline() {
-  int32_t iValue = 0;
-  m_pNode->TryInteger(XFA_ATTRIBUTE_Overline, iValue);
-  return iValue;
-}
-int32_t CXFA_Font::GetOverlinePeriod() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_All;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_OverlinePeriod, eAttr);
-  return eAttr;
-}
-int32_t CXFA_Font::GetUnderline() {
-  int32_t iValue = 0;
-  m_pNode->TryInteger(XFA_ATTRIBUTE_Underline, iValue);
-  return iValue;
-}
-int32_t CXFA_Font::GetUnderlinePeriod() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_All;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_UnderlinePeriod, eAttr);
-  return eAttr;
-}
-FX_FLOAT CXFA_Font::GetFontSize() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_Size, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-void CXFA_Font::GetTypeface(CFX_WideStringC& wsTypeFace) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Typeface, wsTypeFace);
-}
-FX_BOOL CXFA_Font::IsBold() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Normal;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Weight, eAttr);
-  return eAttr == XFA_ATTRIBUTEENUM_Bold;
-}
-FX_BOOL CXFA_Font::IsItalic() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Normal;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Posture, eAttr);
-  return eAttr == XFA_ATTRIBUTEENUM_Italic;
-}
-FX_BOOL CXFA_Font::IsUseKerning() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_KerningMode, eAttr);
-  return eAttr == XFA_ATTRIBUTEENUM_Pair;
-}
-void CXFA_Font::SetColor(FX_ARGB color) {
-  CXFA_Fill fill(m_pNode->GetProperty(0, XFA_ELEMENT_Fill));
-  fill.SetColor(color);
-}
-FX_ARGB CXFA_Font::GetColor() {
-  CXFA_Fill fill(m_pNode->GetChild(0, XFA_ELEMENT_Fill));
-  return fill ? fill.GetColor(TRUE) : 0xFF000000;
-}
-FX_BOOL CXFA_Font::SetBaselineShift(FX_FLOAT fBaselineShift) {
-  CXFA_Measurement ms(fBaselineShift, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_BaselineShift, ms);
-}
-FX_BOOL CXFA_Font::SetHorizontalScale(FX_FLOAT fHorizontalScale) {
-  CFX_WideString wsValue;
-  wsValue.Format(L"%d", (int32_t)fHorizontalScale);
-  return m_pNode->SetCData(XFA_ATTRIBUTE_FontHorizontalScale, wsValue);
-}
-FX_BOOL CXFA_Font::SetVerticalScale(FX_FLOAT fVerticalScale) {
-  CFX_WideString wsValue;
-  wsValue.Format(L"%d", (int32_t)fVerticalScale);
-  return m_pNode->SetCData(XFA_ATTRIBUTE_FontVerticalScale, wsValue);
-}
-FX_BOOL CXFA_Font::SetLetterSpacing(FX_FLOAT fLetterSpacing, XFA_UNIT eUnit) {
-  return FALSE;
-}
-FX_BOOL CXFA_Font::SetLineThrough(int32_t iLineThrough) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_LineThrough, iLineThrough);
-}
-FX_BOOL CXFA_Font::SetLineThroughPeriod(int32_t iLineThroughPeriod) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_LineThroughPeriod,
-                          (XFA_ATTRIBUTEENUM)iLineThroughPeriod);
-}
-FX_BOOL CXFA_Font::SetOverline(int32_t iOverline) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_Overline, iOverline);
-}
-FX_BOOL CXFA_Font::SetOverlinePeriod(int32_t iOverlinePeriod) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_OverlinePeriod,
-                          (XFA_ATTRIBUTEENUM)iOverlinePeriod);
-}
-FX_BOOL CXFA_Font::SetUnderline(int32_t iUnderline) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_Underline, iUnderline);
-}
-FX_BOOL CXFA_Font::SetUnderlinePeriod(int32_t iUnderlinePeriod) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_UnderlinePeriod,
-                          (XFA_ATTRIBUTEENUM)iUnderlinePeriod);
-}
-CXFA_Caption::CXFA_Caption(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Caption::GetPresence() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Visible;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Presence, eAttr);
-  return eAttr;
-}
-int32_t CXFA_Caption::GetPlacementType() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Left;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Placement, eAttr);
-  return eAttr;
-}
-FX_FLOAT CXFA_Caption::GetReserve() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_Reserve, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-CXFA_Margin CXFA_Caption::GetMargin() {
-  return CXFA_Margin(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Margin) : NULL);
-}
-CXFA_Font CXFA_Caption::GetFont() {
-  return CXFA_Font(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Font) : NULL);
-}
-CXFA_Value CXFA_Caption::GetValue() {
-  return CXFA_Value(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Value) : NULL);
-}
-CXFA_Para CXFA_Caption::GetPara() {
-  return CXFA_Para(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Para) : NULL);
-}
-FX_BOOL CXFA_Caption::SetPresence(int32_t iPresence) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Presence, (XFA_ATTRIBUTEENUM)iPresence);
-}
-FX_BOOL CXFA_Caption::SetPlacementType(int32_t iType) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Placement, (XFA_ATTRIBUTEENUM)iType);
-}
-FX_BOOL CXFA_Caption::SetReserve(FX_FLOAT fReserve) {
-  CXFA_Measurement ms(fReserve, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_Reserve, ms);
-}
-CXFA_Para::CXFA_Para(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Para::GetHorizontalAlign() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Left;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_HAlign, eAttr);
-  return eAttr;
-}
-int32_t CXFA_Para::GetVerticalAlign() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Top;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_VAlign, eAttr);
-  return eAttr;
-}
-FX_FLOAT CXFA_Para::GetLineHeight() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_LineHeight, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-FX_FLOAT CXFA_Para::GetMarginLeft() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_MarginLeft, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-FX_FLOAT CXFA_Para::GetMarginRight() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_MarginRight, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-int32_t CXFA_Para::GetOrphans() {
-  int32_t iValue = 0;
-  m_pNode->TryInteger(XFA_ATTRIBUTE_Orphans, iValue);
-  return iValue;
-}
-FX_FLOAT CXFA_Para::GetRadixOffset() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_RadixOffset, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-FX_FLOAT CXFA_Para::GetSpaceAbove() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_SpaceAbove, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-FX_FLOAT CXFA_Para::GetSpaceBelow() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_SpaceBelow, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-FX_FLOAT CXFA_Para::GetTextIndent() {
-  CXFA_Measurement ms;
-  m_pNode->TryMeasure(XFA_ATTRIBUTE_TextIndent, ms);
-  return ms.ToUnit(XFA_UNIT_Pt);
-}
-int32_t CXFA_Para::GetWidows() {
-  int32_t iValue = 0;
-  m_pNode->TryInteger(XFA_ATTRIBUTE_Widows, iValue);
-  return iValue;
-}
-FX_BOOL CXFA_Para::SetHorizontalAlign(int32_t iHorizontalAlign) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_HAlign,
-                          (XFA_ATTRIBUTEENUM)iHorizontalAlign);
-}
-FX_BOOL CXFA_Para::SetVerticalAlign(int32_t iVerticalAlign) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_VAlign,
-                          (XFA_ATTRIBUTEENUM)iVerticalAlign);
-}
-FX_BOOL CXFA_Para::SetLineHeight(FX_FLOAT fLineHeight) {
-  CXFA_Measurement ms;
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_LineHeight, ms);
-}
-FX_BOOL CXFA_Para::SetMarginLeft(FX_FLOAT fMarginLeft) {
-  CXFA_Measurement ms(fMarginLeft, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_MarginLeft, ms);
-}
-FX_BOOL CXFA_Para::SetMarginRight(FX_FLOAT fMarginRight) {
-  CXFA_Measurement ms(fMarginRight, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_MarginRight, ms);
-}
-FX_BOOL CXFA_Para::SetOrphans(int32_t iOrphans) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_Orphans, iOrphans);
-}
-FX_BOOL CXFA_Para::SetRadixOffset(FX_FLOAT fRadixOffset) {
-  CXFA_Measurement ms(fRadixOffset, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_RadixOffset, ms);
-}
-FX_BOOL CXFA_Para::SetSpaceAbove(FX_FLOAT fSpaceAbove) {
-  CXFA_Measurement ms(fSpaceAbove, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_SpaceAbove, ms);
-}
-FX_BOOL CXFA_Para::SetSpaceBelow(FX_FLOAT fSpaceBelow) {
-  CXFA_Measurement ms(fSpaceBelow, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_SpaceBelow, ms);
-}
-FX_BOOL CXFA_Para::SetTextIndent(FX_FLOAT fTextIndent) {
-  CXFA_Measurement ms(fTextIndent, XFA_UNIT_Pt);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_TextIndent, ms);
-}
-FX_BOOL CXFA_Para::SetWidows(int32_t iWidows) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_Widows, iWidows);
-}
-CXFA_Keep::CXFA_Keep(CXFA_Node* pNode, CXFA_Node* pParent)
-    : CXFA_Data(pNode), m_pParent(pParent) {}
-int32_t CXFA_Keep::GetIntact() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;
-  switch (m_pParent->GetClassID()) {
-    case XFA_ELEMENT_Subform: {
-      XFA_ATTRIBUTEENUM eAttrSubForm;
-      m_pParent->TryEnum(XFA_ATTRIBUTE_Layout, eAttrSubForm);
-      if (eAttrSubForm == XFA_ATTRIBUTEENUM_Position ||
-          eAttrSubForm == XFA_ATTRIBUTEENUM_Row) {
-        eAttr = XFA_ATTRIBUTEENUM_ContentArea;
-      }
-    } break;
-    case XFA_ELEMENT_Draw:
-      eAttr = XFA_ATTRIBUTEENUM_ContentArea;
-      break;
-    default:
-      break;
-  }
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Intact, eAttr, FALSE);
-  return eAttr;
-}
-int32_t CXFA_Keep::GetNext() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Next, eAttr);
-  return eAttr;
-}
-int32_t CXFA_Keep::GetPrevious() {
-  XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Previous, eAttr);
-  return eAttr;
-}
-FX_BOOL CXFA_Keep::SetIntact(int32_t iIntact) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Intact, (XFA_ATTRIBUTEENUM)iIntact);
-}
-FX_BOOL CXFA_Keep::SetNext(int32_t iNext) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Next, (XFA_ATTRIBUTEENUM)iNext);
-}
-FX_BOOL CXFA_Keep::SetPrevious(int32_t iPrevious) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Previous, (XFA_ATTRIBUTEENUM)iPrevious);
-}
-CXFA_Event::CXFA_Event(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Event::GetActivity() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Activity);
-}
-int32_t CXFA_Event::GetEventType() {
-  CXFA_Node* pChild = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  while (pChild) {
-    int32_t eType = pChild->GetClassID();
-    if (eType != XFA_ELEMENT_Extras) {
-      return eType;
-    }
-    pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  return XFA_ELEMENT_UNKNOWN;
-}
-void CXFA_Event::GetRef(CFX_WideStringC& wsRef) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Ref, wsRef);
-}
-int32_t CXFA_Event::GetExecuteRunAt() {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);
-  return pNode->GetEnum(XFA_ATTRIBUTE_RunAt);
-}
-int32_t CXFA_Event::GetExecuteType() {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);
-  return pNode->GetEnum(XFA_ATTRIBUTE_ExecuteType);
-}
-void CXFA_Event::GetExecuteConnection(CFX_WideString& wsConnection) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);
-  CFX_WideStringC cData;
-  pNode->TryCData(XFA_ATTRIBUTE_Connection, cData);
-  wsConnection = cData;
-}
-CXFA_Script CXFA_Event::GetScript() {
-  return CXFA_Script(m_pNode->GetChild(0, XFA_ELEMENT_Script));
-}
-CXFA_Submit CXFA_Event::GetSubmit() {
-  return CXFA_Submit(m_pNode->GetChild(0, XFA_ELEMENT_Submit));
-}
-int32_t CXFA_Event::GetSignDataOperation() {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData);
-  return pNode->GetEnum(XFA_ATTRIBUTE_Operation);
-}
-void CXFA_Event::GetSignDataTarget(CFX_WideString& wsTarget) {
-  if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData)) {
-    CFX_WideStringC wsCData;
-    pNode->TryCData(XFA_ATTRIBUTE_Target, wsCData);
-    wsTarget = wsCData;
-  }
-}
-FX_BOOL CXFA_Event::SetActivity(int32_t iActivity) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Activity, (XFA_ATTRIBUTEENUM)iActivity);
-}
-FX_BOOL CXFA_Event::SetEventType(int32_t iEventType) {
-  return FALSE;
-}
-FX_BOOL CXFA_Event::SetExecuteRunAt(int32_t iExecuteRunAt) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);
-  return pNode->SetEnum(XFA_ATTRIBUTE_RunAt, (XFA_ATTRIBUTEENUM)iExecuteRunAt);
-}
-FX_BOOL CXFA_Event::SetExecuteType(int32_t iExecuteType) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);
-  return pNode->SetEnum(XFA_ATTRIBUTE_ExecuteType,
-                        (XFA_ATTRIBUTEENUM)iExecuteType);
-}
-FX_BOOL CXFA_Event::SetExecuteConnection(const CFX_WideString& wsConnection) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);
-  return pNode->SetCData(XFA_ATTRIBUTE_Connection, wsConnection);
-}
-FX_BOOL CXFA_Event::SetSignDataOperation(int32_t iOperation) {
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData);
-  return pNode->SetEnum(XFA_ATTRIBUTE_Operation, (XFA_ATTRIBUTEENUM)iOperation);
-}
-FX_BOOL CXFA_Event::SetSignDataTarget(const CFX_WideString& wsTarget) {
-  if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData)) {
-    return pNode->SetCData(XFA_ATTRIBUTE_Target, wsTarget);
-  }
-  return FALSE;
-}
-CXFA_Script::CXFA_Script(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-void CXFA_Script::GetBinding(CFX_WideString& wsBinding) {
-  CFX_WideStringC cData;
-  m_pNode->TryCData(XFA_ATTRIBUTE_Binding, cData);
-  wsBinding = cData;
-}
-XFA_SCRIPTTYPE CXFA_Script::GetContentType() {
-  CFX_WideStringC cData;
-  if (m_pNode->TryCData(XFA_ATTRIBUTE_ContentType, cData, FALSE)) {
-    if (cData == FX_WSTRC(L"application/x-javascript")) {
-      return XFA_SCRIPTTYPE_Javascript;
-    } else if (cData == FX_WSTRC(L"application/x-formcalc")) {
-      return XFA_SCRIPTTYPE_Formcalc;
-    } else {
-      return XFA_SCRIPTTYPE_Unkown;
-    }
-  }
-  return XFA_SCRIPTTYPE_Formcalc;
-}
-int32_t CXFA_Script::GetRunAt() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_RunAt);
-}
-void CXFA_Script::GetExpression(CFX_WideString& wsExpression) {
-  m_pNode->TryContent(wsExpression);
-}
-FX_BOOL CXFA_Script::SetBinding(const CFX_WideString& wsBinding) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Binding, wsBinding);
-}
-FX_BOOL CXFA_Script::SetContentType(XFA_SCRIPTTYPE eType) {
-  CFX_WideString wsType;
-  switch (eType) {
-    case XFA_SCRIPTTYPE_Javascript:
-      wsType = L"application/x-javascript";
-      break;
-    case XFA_SCRIPTTYPE_Formcalc:
-      wsType = L"application/x-formcalc";
-      break;
-    default:
-      break;
-  }
-  return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsType);
-}
-FX_BOOL CXFA_Script::SetRunAt(int32_t iRunAt) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_RunAt, (XFA_ATTRIBUTEENUM)iRunAt);
-}
-FX_BOOL CXFA_Script::SetExpression(const CFX_WideString& wsExpression) {
-  return m_pNode->SetContent(wsExpression, wsExpression);
-}
-CXFA_Submit::CXFA_Submit(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-FX_BOOL CXFA_Submit::IsSubmitEmbedPDF() {
-  return m_pNode->GetBoolean(XFA_ATTRIBUTE_EmbedPDF);
-}
-int32_t CXFA_Submit::GetSubmitFormat() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Format);
-}
-void CXFA_Submit::GetSubmitTarget(CFX_WideStringC& wsTarget) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Target, wsTarget);
-}
-XFA_TEXTENCODING CXFA_Submit::GetSubmitTextEncoding() {
-  CFX_WideStringC wsCData;
-  if (!m_pNode->TryCData(XFA_ATTRIBUTE_TextEncoding, wsCData)) {
-    return XFA_TEXTENCODING_None;
-  }
-  CFX_WideString wsValue(wsCData);
-  if (wsValue == L"Big-Five") {
-    return XFA_TEXTENCODING_Big5;
-  } else if (wsValue == L"fontSpecific") {
-    return XFA_TEXTENCODING_FontSpecific;
-  } else if (wsValue == L"GBK") {
-    return XFA_TEXTENCODING_GBK;
-  } else if (wsValue == L"GB-18030") {
-    return XFA_TEXTENCODING_GB18030;
-  } else if (wsValue == L"GB-2312") {
-    return XFA_TEXTENCODING_GB2312;
-  } else if (wsValue == L"ISO-8859-NN") {
-    return XFA_TEXTENCODING_ISO8859NN;
-  } else if (wsValue == L"KSC-5601") {
-    return XFA_TEXTENCODING_KSC5601;
-  } else if (wsValue == L"Shift-JIS") {
-    return XFA_TEXTENCODING_ShiftJIS;
-  } else if (wsValue == L"UCS-2") {
-    return XFA_TEXTENCODING_UCS2;
-  } else if (wsValue == L"UTF-16") {
-    return XFA_TEXTENCODING_UTF16;
-  } else if (wsValue == L"UTF-8") {
-    return XFA_TEXTENCODING_UTF8;
-  }
-  return XFA_TEXTENCODING_None;
-}
-void CXFA_Submit::GetSubmitXDPContent(CFX_WideStringC& wsContent) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_XdpContent, wsContent);
-}
-FX_BOOL CXFA_Submit::SetSubmitFormat(int32_t iSubmitFormat) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Format,
-                          (XFA_ATTRIBUTEENUM)iSubmitFormat);
-}
-FX_BOOL CXFA_Submit::SetSubmitTarget(const CFX_WideString& wsTarget) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Target, wsTarget);
-}
-FX_BOOL CXFA_Submit::SetSubmitTextEncoding(XFA_TEXTENCODING eTextEncoding) {
-  CFX_WideString wsValue;
-  switch (eTextEncoding) {
-    case XFA_TEXTENCODING_Big5:
-      wsValue = L"Big-Five";
-      break;
-    case XFA_TEXTENCODING_FontSpecific:
-      wsValue = L"fontSpecific";
-      break;
-    case XFA_TEXTENCODING_GBK:
-      wsValue = L"GBK";
-      break;
-    case XFA_TEXTENCODING_GB18030:
-      wsValue = L"GB-18030";
-      break;
-    case XFA_TEXTENCODING_GB2312:
-      wsValue = L"GB-2312";
-      break;
-    case XFA_TEXTENCODING_ISO8859NN:
-      wsValue = L"ISO-8859-NN";
-      break;
-    case XFA_TEXTENCODING_KSC5601:
-      wsValue = L"KSC-5601";
-      break;
-    case XFA_TEXTENCODING_ShiftJIS:
-      wsValue = L"Shift-JIS";
-      break;
-    case XFA_TEXTENCODING_UCS2:
-      wsValue = L"UCS-2";
-      break;
-    case XFA_TEXTENCODING_UTF16:
-      wsValue = L"UTF-16";
-      break;
-    case XFA_TEXTENCODING_UTF8:
-      wsValue = L"UTF-8";
-      break;
-    default:
-      break;
-  }
-  return m_pNode->SetCData(XFA_ATTRIBUTE_TextEncoding, wsValue);
-}
-FX_BOOL CXFA_Submit::SetSubmitXDPContent(const CFX_WideString& wsContent) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_XdpContent, wsContent);
-}
-XFA_ELEMENT CXFA_Value::GetChildValueClassID() {
-  if (!m_pNode) {
-    return XFA_ELEMENT_UNKNOWN;
-  }
-  if (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-    return pNode->GetClassID();
-  }
-  return XFA_ELEMENT_UNKNOWN;
-}
-FX_BOOL CXFA_Value::GetChildValueContent(CFX_WideString& wsContent) {
-  if (!m_pNode) {
-    return FALSE;
-  }
-  if (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-    return pNode->TryContent(wsContent);
-  }
-  return FALSE;
-}
-CXFA_Arc CXFA_Value::GetArc() {
-  return CXFA_Arc(m_pNode ? m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)
-                          : nullptr);
-}
-CXFA_Line CXFA_Value::GetLine() {
-  return CXFA_Line(m_pNode ? m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)
-                           : nullptr);
-}
-CXFA_Rectangle CXFA_Value::GetRectangle() {
-  return CXFA_Rectangle(m_pNode ? m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)
-                                : nullptr);
-}
-CXFA_Text CXFA_Value::GetText() {
-  return CXFA_Text(m_pNode ? m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)
-                           : nullptr);
-}
-CXFA_ExData CXFA_Value::GetExData() {
-  return CXFA_ExData(m_pNode ? m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)
-                             : nullptr);
-}
-CXFA_Image CXFA_Value::GetImage() {
-  return CXFA_Image(
-      m_pNode ? (m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : nullptr,
-      TRUE);
-}
-FX_BOOL CXFA_Value::SetChildValueContent(const CFX_WideString& wsContent,
-                                         FX_BOOL bNotify,
-                                         XFA_ELEMENT iType) {
-  if (!m_pNode) {
-    return FALSE;
-  }
-  CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  if (!pNode) {
-    if (iType == XFA_ELEMENT_UNKNOWN) {
-      return FALSE;
-    }
-    pNode = m_pNode->GetProperty(0, iType);
-  }
-  CFX_WideString wsFormatContent(wsContent);
-  CXFA_WidgetData* pContainerWidgetData = pNode->GetContainerWidgetData();
-  if (pContainerWidgetData) {
-    pContainerWidgetData->GetFormatDataValue(wsContent, wsFormatContent);
-  }
-  return pNode->SetContent(wsContent, wsFormatContent, bNotify);
-}
-int32_t CXFA_Line::GetHand() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Hand);
-}
-FX_BOOL CXFA_Line::GetSlop() {
-  XFA_ATTRIBUTEENUM eSlop = m_pNode->GetEnum(XFA_ATTRIBUTE_Slope);
-  return eSlop == XFA_ATTRIBUTEENUM_Slash;
-}
-CXFA_Edge CXFA_Line::GetEdge() {
-  return CXFA_Edge(m_pNode->GetChild(0, XFA_ELEMENT_Edge));
-}
-FX_BOOL CXFA_Line::SetHand(int32_t iHand) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Hand, (XFA_ATTRIBUTEENUM)iHand);
-}
-FX_BOOL CXFA_Line::SetSlop(int32_t iSlop) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Slope, (XFA_ATTRIBUTEENUM)iSlop);
-}
-CXFA_Text::CXFA_Text(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-void CXFA_Text::GetName(CFX_WideStringC& wsName) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Name, wsName);
-}
-int32_t CXFA_Text::GetMaxChars() {
-  return m_pNode->GetInteger(XFA_ATTRIBUTE_MaxChars);
-}
-void CXFA_Text::GetRid(CFX_WideStringC& wsRid) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Rid, wsRid);
-}
-void CXFA_Text::GetContent(CFX_WideString& wsText) {
-  m_pNode->TryContent(wsText);
-}
-void CXFA_Text::SetContent(CFX_WideString wsText, FX_BOOL bNotify) {
-  CFX_WideString wsFormatValue(wsText);
-  CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();
-  if (pContainerWidgetData) {
-    pContainerWidgetData->GetFormatDataValue(wsText, wsFormatValue);
-  }
-  m_pNode->SetContent(wsText, wsFormatValue, bNotify);
-}
-FX_BOOL CXFA_Text::SetName(const CFX_WideString& wsName) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
-}
-FX_BOOL CXFA_Text::SetMaxChars(int32_t iMaxChars) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_MaxChars, iMaxChars);
-}
-FX_BOOL CXFA_Text::SetRid(const CFX_WideString& wsRid) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Rid, wsRid);
-}
-CXFA_ExData::CXFA_ExData(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-void CXFA_ExData::GetContentType(CFX_WideStringC& wsContentType) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-}
-void CXFA_ExData::GetHref(CFX_WideStringC& wsHref) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Href, wsHref);
-}
-int32_t CXFA_ExData::GetMaxLength() {
-  return m_pNode->GetInteger(XFA_ATTRIBUTE_MaxLength);
-}
-void CXFA_ExData::GetRid(CFX_WideStringC& wsRid) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Rid, wsRid);
-}
-int32_t CXFA_ExData::GetTransferEncoding() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_TransferEncoding);
-}
-void CXFA_ExData::GetContent(CFX_WideString& wsText) {
-  m_pNode->TryContent(wsText);
-}
-FX_BOOL CXFA_ExData::SetContentType(const CFX_WideString& wsContentType) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-}
-FX_BOOL CXFA_ExData::SetHref(const CFX_WideString& wsHref) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Href, wsHref);
-}
-FX_BOOL CXFA_ExData::SetMaxLength(int32_t iMaxLength) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_MaxLength, iMaxLength);
-}
-FX_BOOL CXFA_ExData::SetRid(const CFX_WideString& wsRid) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Rid, wsRid);
-}
-FX_BOOL CXFA_ExData::SetTransferEncoding(int32_t iTransferEncoding) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_TransferEncoding,
-                          (XFA_ATTRIBUTEENUM)iTransferEncoding);
-}
-FX_BOOL CXFA_ExData::SetContent(const CFX_WideString& wsText,
-                                FX_BOOL bNotify,
-                                FX_BOOL bScriptModify,
-                                FX_BOOL bSyncData) {
-  CFX_WideString wsFormatValue(wsText);
-  CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();
-  if (pContainerWidgetData) {
-    pContainerWidgetData->GetFormatDataValue(wsText, wsFormatValue);
-  }
-  return m_pNode->SetContent(wsText, wsFormatValue, bNotify, bScriptModify,
-                             bSyncData);
-}
-CXFA_Image::CXFA_Image(CXFA_Node* pNode, FX_BOOL bDefValue)
-    : CXFA_Data(pNode), m_bDefValue(bDefValue) {}
-int32_t CXFA_Image::GetAspect() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Aspect);
-}
-FX_BOOL CXFA_Image::GetContentType(CFX_WideString& wsContentType) {
-  return m_pNode->TryCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-}
-FX_BOOL CXFA_Image::GetHref(CFX_WideString& wsHref) {
-  if (m_bDefValue) {
-    return m_pNode->TryCData(XFA_ATTRIBUTE_Href, wsHref);
-  }
-  return m_pNode->GetAttribute(FX_WSTRC(L"href"), wsHref);
-}
-int32_t CXFA_Image::GetTransferEncoding() {
-  if (m_bDefValue) {
-    return m_pNode->GetEnum(XFA_ATTRIBUTE_TransferEncoding);
-  }
-  return XFA_ATTRIBUTEENUM_Base64;
-}
-FX_BOOL CXFA_Image::GetContent(CFX_WideString& wsText) {
-  return m_pNode->TryContent(wsText);
-}
-FX_BOOL CXFA_Image::SetAspect(int32_t iAspect) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Aspect, (XFA_ATTRIBUTEENUM)iAspect);
-}
-FX_BOOL CXFA_Image::SetContentType(const CFX_WideString& wsContentType) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
-}
-FX_BOOL CXFA_Image::SetHref(const CFX_WideString& wsHref) {
-  if (m_bDefValue) {
-    return m_pNode->SetCData(XFA_ATTRIBUTE_Href, wsHref);
-  }
-  return m_pNode->SetAttribute(XFA_ATTRIBUTE_Href, wsHref);
-}
-FX_BOOL CXFA_Image::SetTransferEncoding(int32_t iTransferEncoding) {
-  if (m_bDefValue) {
-    return m_pNode->SetEnum(XFA_ATTRIBUTE_TransferEncoding,
-                            (XFA_ATTRIBUTEENUM)iTransferEncoding);
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_Image::SetContent(const CFX_WideString& wsText) {
-  CFX_WideString wsFormatValue(wsText);
-  CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();
-  if (pContainerWidgetData) {
-    pContainerWidgetData->GetFormatDataValue(wsText, wsFormatValue);
-  }
-  return m_pNode->SetContent(wsText, wsFormatValue);
-}
-CXFA_Calculate::CXFA_Calculate(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Calculate::GetOverride() {
-  XFA_ATTRIBUTEENUM eAtt = XFA_ATTRIBUTEENUM_Error;
-  m_pNode->TryEnum(XFA_ATTRIBUTE_Override, eAtt, FALSE);
-  return eAtt;
-}
-CXFA_Script CXFA_Calculate::GetScript() {
-  return CXFA_Script(m_pNode->GetChild(0, XFA_ELEMENT_Script));
-}
-void CXFA_Calculate::GetMessageText(CFX_WideString& wsMessage) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Message)) {
-    CXFA_Text text(pNode->GetChild(0, XFA_ELEMENT_Text));
-    if (text) {
-      text.GetContent(wsMessage);
-    }
-  }
-}
-FX_BOOL CXFA_Calculate::SetOverride(int32_t iOverride) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Override, (XFA_ATTRIBUTEENUM)iOverride);
-}
-FX_BOOL CXFA_Calculate::SetMessageText(const CFX_WideString& wsMessage) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Message)) {
-    CXFA_Node* pChildNode = pNode->GetProperty(0, XFA_ELEMENT_Text);
-    return pChildNode->SetContent(wsMessage, wsMessage);
-  }
-  return FALSE;
-}
-CXFA_Validate::CXFA_Validate(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Validate::GetFormatTest() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_FormatTest);
-}
-FX_BOOL CXFA_Validate::SetTestValue(int32_t iType,
-                                    CFX_WideString& wsValue,
-                                    XFA_ATTRIBUTEENUM eName) {
-  const XFA_ATTRIBUTEENUMINFO* pInfo = XFA_GetAttributeEnumByName(wsValue);
-  if (pInfo) {
-    eName = pInfo->eName;
-  }
-  m_pNode->SetEnum((XFA_ATTRIBUTE)iType, eName, FALSE);
-  return TRUE;
-}
-FX_BOOL CXFA_Validate::SetFormatTest(CFX_WideString wsValue) {
-  return SetTestValue(XFA_ATTRIBUTE_FormatTest, wsValue,
-                      XFA_ATTRIBUTEENUM_Warning);
-}
-FX_BOOL CXFA_Validate::SetNullTest(CFX_WideString wsValue) {
-  return SetTestValue(XFA_ATTRIBUTE_NullTest, wsValue,
-                      XFA_ATTRIBUTEENUM_Disabled);
-}
-int32_t CXFA_Validate::GetNullTest() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_NullTest);
-}
-int32_t CXFA_Validate::GetScriptTest() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_ScriptTest);
-}
-void CXFA_Validate::GetMessageText(CFX_WideString& wsMessage,
-                                   const CFX_WideStringC& wsMessageType) {
-  if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Message, FALSE)) {
-    CXFA_Node* pItemNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    for (; pItemNode;
-         pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pItemNode->GetClassID() != XFA_ELEMENT_Text) {
-        continue;
-      }
-      CFX_WideStringC wsName;
-      pItemNode->TryCData(XFA_ATTRIBUTE_Name, wsName);
-      if (wsName.IsEmpty() || wsName == wsMessageType) {
-        pItemNode->TryContent(wsMessage);
-        return;
-      }
-    }
-  }
-}
-void CXFA_Validate::SetFormatMessageText(CFX_WideString wsMessage) {
-  SetMessageText(wsMessage, FX_WSTRC(L"formatTest"));
-}
-void CXFA_Validate::GetFormatMessageText(CFX_WideString& wsMessage) {
-  GetMessageText(wsMessage, FX_WSTRC(L"formatTest"));
-}
-void CXFA_Validate::SetNullMessageText(CFX_WideString wsMessage) {
-  SetMessageText(wsMessage, FX_WSTRC(L"nullTest"));
-}
-void CXFA_Validate::GetNullMessageText(CFX_WideString& wsMessage) {
-  GetMessageText(wsMessage, FX_WSTRC(L"nullTest"));
-}
-void CXFA_Validate::SetMessageText(CFX_WideString& wsMessage,
-                                   const CFX_WideStringC& wsMessageType) {
-  if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Message, TRUE)) {
-    CXFA_Node* pItemNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    for (; pItemNode;
-         pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pItemNode->GetClassID() != XFA_ELEMENT_Text) {
-        continue;
-      }
-      CFX_WideStringC wsName;
-      pItemNode->TryCData(XFA_ATTRIBUTE_Name, wsName);
-      if (wsName.IsEmpty() || wsName == wsMessageType) {
-        pItemNode->SetContent(wsMessage, wsMessage, FALSE);
-        return;
-      }
-    }
-    CXFA_Node* pTextNode = pNode->CreateSamePacketNode(XFA_ELEMENT_Text);
-    pNode->InsertChild(pTextNode);
-    pTextNode->SetCData(XFA_ATTRIBUTE_Name, wsMessageType, FALSE);
-    pTextNode->SetContent(wsMessage, wsMessage, FALSE);
-  }
-}
-void CXFA_Validate::GetScriptMessageText(CFX_WideString& wsMessage) {
-  GetMessageText(wsMessage, FX_WSTRC(L"scriptTest"));
-}
-void CXFA_Validate::SetScriptMessageText(CFX_WideString wsMessage) {
-  SetMessageText(wsMessage, FX_WSTRC(L"scriptTest"));
-}
-void CXFA_Validate::GetPicture(CFX_WideString& wsPicture) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Picture)) {
-    pNode->TryContent(wsPicture);
-  }
-}
-CXFA_Script CXFA_Validate::GetScript() {
-  return CXFA_Script(m_pNode->GetChild(0, XFA_ELEMENT_Script));
-}
-CXFA_Variables::CXFA_Variables(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Variables::CountScripts() {
-  return m_pNode->CountChildren(XFA_ELEMENT_Script);
-}
-CXFA_Script CXFA_Variables::GetScript(int32_t nIndex) {
-  return CXFA_Script(m_pNode->GetChild(nIndex, XFA_ELEMENT_Script));
-}
-CXFA_Bind::CXFA_Bind(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Bind::GetMatch() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Match);
-}
-void CXFA_Bind::GetRef(CFX_WideStringC& wsRef) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Ref, wsRef);
-}
-void CXFA_Bind::GetPicture(CFX_WideString& wsPicture) {
-  if (CXFA_Node* pPicture = m_pNode->GetChild(0, XFA_ELEMENT_Picture)) {
-    pPicture->TryContent(wsPicture);
-  }
-}
-FX_BOOL CXFA_Bind::SetMatch(int32_t iMatch) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Match, (XFA_ATTRIBUTEENUM)iMatch);
-}
-FX_BOOL CXFA_Bind::SetRef(const CFX_WideString& wsRef) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Ref, wsRef);
-}
-FX_BOOL CXFA_Bind::SetPicture(const CFX_WideString& wsPicture) {
-  if (CXFA_Node* pPicture = m_pNode->GetChild(0, XFA_ELEMENT_Picture)) {
-    return pPicture->SetContent(wsPicture, wsPicture);
-  }
-  return FALSE;
-}
-CXFA_Assist::CXFA_Assist(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-CXFA_ToolTip CXFA_Assist::GetToolTip() {
-  return CXFA_ToolTip(m_pNode->GetChild(0, XFA_ELEMENT_ToolTip));
-}
-CXFA_ToolTip::CXFA_ToolTip(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-FX_BOOL CXFA_ToolTip::GetTip(CFX_WideString& wsTip) {
-  return m_pNode->TryContent(wsTip);
-}
-FX_BOOL CXFA_ToolTip::SetTip(const CFX_WideString& wsTip) {
-  return m_pNode->SetContent(wsTip, wsTip);
-}
-CXFA_BindItems::CXFA_BindItems(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-void CXFA_BindItems::GetConnection(CFX_WideStringC& wsConnection) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Connection, wsConnection);
-}
-void CXFA_BindItems::GetLabelRef(CFX_WideStringC& wsLabelRef) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_LabelRef, wsLabelRef);
-}
-void CXFA_BindItems::GetValueRef(CFX_WideStringC& wsValueRef) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_ValueRef, wsValueRef);
-}
-void CXFA_BindItems::GetRef(CFX_WideStringC& wsRef) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Ref, wsRef);
-}
-FX_BOOL CXFA_BindItems::SetConnection(const CFX_WideString& wsConnection) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Connection, wsConnection);
-}
-FX_BOOL CXFA_BindItems::SetLabelRef(const CFX_WideString& wsLabelRef) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_LabelRef, wsLabelRef);
-}
-FX_BOOL CXFA_BindItems::SetValueRef(const CFX_WideString& wsValueRef) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_ValueRef, wsValueRef);
-}
-FX_BOOL CXFA_BindItems::SetRef(const CFX_WideString& wsRef) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Ref, wsRef);
-}
-int32_t CXFA_Box::GetBreak() const {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Close;
-  }
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Break);
-}
-int32_t CXFA_Box::GetHand() const {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Even;
-  }
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Hand);
-}
-int32_t CXFA_Box::GetPresence() const {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Hidden;
-  }
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Presence);
-}
-int32_t CXFA_Box::CountCorners() const {
-  if (!m_pNode) {
-    return 0;
-  }
-  return m_pNode->CountChildren(XFA_ELEMENT_Corner);
-}
-CXFA_Corner CXFA_Box::GetCorner(int32_t nIndex) const {
-  return CXFA_Corner(
-      m_pNode ? m_pNode->GetProperty(nIndex, XFA_ELEMENT_Corner, nIndex == 0)
-              : nullptr);
-}
-int32_t CXFA_Box::CountEdges() const {
-  if (!m_pNode) {
-    return 0;
-  }
-  return m_pNode->CountChildren(XFA_ELEMENT_Edge);
-}
-CXFA_Edge CXFA_Box::GetEdge(int32_t nIndex) const {
-  return CXFA_Edge(
-      m_pNode ? m_pNode->GetProperty(nIndex, XFA_ELEMENT_Edge, nIndex == 0)
-              : nullptr);
-}
-static void XFA_BOX_GetStrokes(CXFA_Node* pNode,
-                               CXFA_StrokeArray& strokes,
-                               FX_BOOL bNULL) {
-  strokes.RemoveAll();
-  if (!pNode) {
-    return;
-  }
-  strokes.SetSize(8);
-  int32_t i, j;
-  for (i = 0, j = 0; i < 4; i++) {
-    CXFA_Corner corner =
-        CXFA_Corner(pNode->GetProperty(i, XFA_ELEMENT_Corner, i == 0));
-    if (corner || i == 0) {
-      strokes.SetAt(j, corner);
-    } else if (bNULL) {
-      strokes.SetAt(j, CXFA_Stroke(nullptr));
-    } else if (i == 1) {
-      strokes.SetAt(j, strokes[0]);
-    } else if (i == 2) {
-      strokes.SetAt(j, strokes[0]);
-    } else {
-      strokes.SetAt(j, strokes[2]);
-    }
-    j++;
-    CXFA_Edge edge = CXFA_Edge(pNode->GetProperty(i, XFA_ELEMENT_Edge, i == 0));
-    if (edge || i == 0) {
-      strokes.SetAt(j, edge);
-    } else if (bNULL) {
-      strokes.SetAt(j, CXFA_Stroke(nullptr));
-    } else if (i == 1) {
-      strokes.SetAt(j, strokes[1]);
-    } else if (i == 2) {
-      strokes.SetAt(j, strokes[1]);
-    } else {
-      strokes.SetAt(j, strokes[3]);
-    }
-    j++;
-  }
-}
-void CXFA_Box::GetStrokes(CXFA_StrokeArray& strokes) const {
-  XFA_BOX_GetStrokes(m_pNode, strokes, FALSE);
-}
-FX_BOOL CXFA_Box::IsCircular() const {
-  if (!m_pNode) {
-    return FALSE;
-  }
-  return m_pNode->GetBoolean(XFA_ATTRIBUTE_Circular);
-}
-FX_BOOL CXFA_Box::GetStartAngle(FX_FLOAT& fStartAngle) const {
-  fStartAngle = 0;
-  if (!m_pNode) {
-    return FALSE;
-  }
-  CXFA_Measurement ms;
-  FX_BOOL bRet = m_pNode->TryMeasure(XFA_ATTRIBUTE_StartAngle, ms, FALSE);
-  if (bRet) {
-    fStartAngle = ms.GetValue();
-  }
-  return bRet;
-}
-FX_BOOL CXFA_Box::GetSweepAngle(FX_FLOAT& fSweepAngle) const {
-  fSweepAngle = 360;
-  if (!m_pNode) {
-    return FALSE;
-  }
-  CXFA_Measurement ms;
-  FX_BOOL bRet = m_pNode->TryMeasure(XFA_ATTRIBUTE_SweepAngle, ms, FALSE);
-  if (bRet) {
-    fSweepAngle = ms.GetValue();
-  }
-  return bRet;
-}
-CXFA_Fill CXFA_Box::GetFill(FX_BOOL bModified) const {
-  if (!m_pNode) {
-    return CXFA_Fill(nullptr);
-  }
-  CXFA_Node* pFillNode = m_pNode->GetProperty(0, XFA_ELEMENT_Fill, bModified);
-  return CXFA_Fill(pFillNode);
-}
-CXFA_Margin CXFA_Box::GetMargin() const {
-  return CXFA_Margin(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Margin)
-                             : nullptr);
-}
-static FX_BOOL XFA_BOX_SameStyles(const CXFA_StrokeArray& strokes) {
-  int32_t iCount = strokes.GetSize();
-  if (iCount < 1) {
-    return TRUE;
-  }
-  CXFA_Stroke stroke1 = strokes[0];
-  for (int32_t i = 1; i < iCount; i++) {
-    CXFA_Stroke stroke2 = strokes[i];
-    if (!stroke2) {
-      continue;
-    }
-    if (!stroke1) {
-      stroke1 = stroke2;
-    } else if (!stroke1.SameStyles(stroke2)) {
-      return FALSE;
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_Box::SameStyles() const {
-  if (IsArc()) {
-    return TRUE;
-  }
-  CXFA_StrokeArray strokes;
-  XFA_BOX_GetStrokes(m_pNode, strokes, TRUE);
-  return XFA_BOX_SameStyles(strokes);
-}
-static int32_t XFA_BOX_3DStyle(const CXFA_StrokeArray& strokes,
-                               CXFA_Stroke& stroke) {
-  int32_t iCount = strokes.GetSize();
-  if (iCount < 1) {
-    return 0;
-  }
-  stroke = strokes[0];
-  for (int32_t i = 1; i < iCount; i++) {
-    CXFA_Stroke find = strokes[i];
-    if (!find) {
-      continue;
-    }
-    if (!stroke) {
-      stroke = find;
-    } else if (stroke.GetStrokeType() != find.GetStrokeType()) {
-      stroke = find;
-      break;
-    }
-  }
-  int32_t iType = stroke.GetStrokeType();
-  if (iType == XFA_ATTRIBUTEENUM_Lowered || iType == XFA_ATTRIBUTEENUM_Raised ||
-      iType == XFA_ATTRIBUTEENUM_Etched ||
-      iType == XFA_ATTRIBUTEENUM_Embossed) {
-    return iType;
-  }
-  return 0;
-}
-int32_t CXFA_Box::Get3DStyle(FX_BOOL& bVisible, FX_FLOAT& fThickness) const {
-  if (IsArc()) {
-    return 0;
-  }
-  CXFA_StrokeArray strokes;
-  XFA_BOX_GetStrokes(m_pNode, strokes, TRUE);
-  CXFA_Stroke stroke(NULL);
-  int32_t iType = XFA_BOX_3DStyle(strokes, stroke);
-  if (iType) {
-    bVisible = stroke.IsVisible();
-    fThickness = stroke.GetThickness();
-  }
-  return iType;
-}
-int32_t CXFA_Stroke::GetPresence() const {
-  return m_pNode ? m_pNode->GetEnum(XFA_ATTRIBUTE_Presence)
-                 : XFA_ATTRIBUTEENUM_Invisible;
-}
-int32_t CXFA_Stroke::GetCapType() const {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Square;
-  }
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Cap);
-}
-int32_t CXFA_Stroke::GetStrokeType() const {
-  return m_pNode ? m_pNode->GetEnum(XFA_ATTRIBUTE_Stroke)
-                 : XFA_ATTRIBUTEENUM_Solid;
-}
-FX_FLOAT CXFA_Stroke::GetThickness() const {
-  return GetMSThickness().ToUnit(XFA_UNIT_Pt);
-}
-CXFA_Measurement CXFA_Stroke::GetMSThickness() const {
-  return m_pNode ? m_pNode->GetMeasure(XFA_ATTRIBUTE_Thickness)
-                 : XFA_GetAttributeDefaultValue_Measure(XFA_ELEMENT_Edge,
-                                                        XFA_ATTRIBUTE_Thickness,
-                                                        XFA_XDPPACKET_Form);
-}
-void CXFA_Stroke::SetThickness(FX_FLOAT fThickness) {
-  if (!m_pNode) {
-    return;
-  }
-  CXFA_Measurement thickness(fThickness, XFA_UNIT_Pt);
-  m_pNode->SetMeasure(XFA_ATTRIBUTE_Thickness, thickness);
-}
-void CXFA_Stroke::SetMSThickness(CXFA_Measurement msThinkness) {
-  if (!m_pNode) {
-    return;
-  }
-  m_pNode->SetMeasure(XFA_ATTRIBUTE_Thickness, msThinkness);
-}
-FX_ARGB CXFA_Stroke::GetColor() const {
-  if (!m_pNode) {
-    return 0xFF000000;
-  }
-  CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Color);
-  if (!pNode) {
-    return 0xFF000000;
-  }
-  CFX_WideStringC wsColor;
-  pNode->TryCData(XFA_ATTRIBUTE_Value, wsColor);
-  return XFA_WStringToColor(wsColor);
-}
-void CXFA_Stroke::SetColor(FX_ARGB argb) {
-  if (!m_pNode) {
-    return;
-  }
-  CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Color);
-  CFX_WideString wsColor;
-  int a, r, g, b;
-  ArgbDecode(argb, a, r, g, b);
-  wsColor.Format(L"%d,%d,%d", r, g, b);
-  pNode->SetCData(XFA_ATTRIBUTE_Value, wsColor);
-}
-int32_t CXFA_Stroke::GetJoinType() const {
-  return m_pNode ? m_pNode->GetEnum(XFA_ATTRIBUTE_Join)
-                 : XFA_ATTRIBUTEENUM_Square;
-}
-FX_BOOL CXFA_Stroke::IsInverted() const {
-  return m_pNode ? m_pNode->GetBoolean(XFA_ATTRIBUTE_Inverted) : FALSE;
-}
-FX_FLOAT CXFA_Stroke::GetRadius() const {
-  return m_pNode ? m_pNode->GetMeasure(XFA_ATTRIBUTE_Radius).ToUnit(XFA_UNIT_Pt)
-                 : 0;
-}
-FX_BOOL CXFA_Stroke::SameStyles(CXFA_Stroke stroke, FX_DWORD dwFlags) const {
-  if (m_pNode == stroke.GetNode()) {
-    return TRUE;
-  }
-  if (FXSYS_fabs(GetThickness() - stroke.GetThickness()) >= 0.01f) {
-    return FALSE;
-  }
-  if ((dwFlags & XFA_STROKE_SAMESTYLE_NoPresence) == 0 &&
-      IsVisible() != stroke.IsVisible()) {
-    return FALSE;
-  }
-  if (GetStrokeType() != stroke.GetStrokeType()) {
-    return FALSE;
-  }
-  if (GetColor() != stroke.GetColor()) {
-    return FALSE;
-  }
-  if ((dwFlags & XFA_STROKE_SAMESTYLE_Corner) != 0 &&
-      FXSYS_fabs(GetRadius() - stroke.GetRadius()) >= 0.01f) {
-    return FALSE;
-  }
-  return TRUE;
-}
-FX_FLOAT XFA_GetEdgeThickness(const CXFA_StrokeArray& strokes,
-                              FX_BOOL b3DStyle,
-                              int32_t nIndex) {
-  FX_FLOAT fThickness = 0;
-  {
-    if (strokes[nIndex * 2 + 1].GetPresence() == XFA_ATTRIBUTEENUM_Visible) {
-      if (nIndex == 0) {
-        fThickness += 2.5f;
-      }
-      fThickness += strokes[nIndex * 2 + 1].GetThickness() * (b3DStyle ? 4 : 2);
-    }
-  }
-  return fThickness;
-}
-CXFA_WidgetData::CXFA_WidgetData(CXFA_Node* pNode)
-    : CXFA_Data(pNode),
-      m_bIsNull(TRUE),
-      m_bPreNull(TRUE),
-      m_pUiChildNode(NULL),
-      m_eUIType(XFA_ELEMENT_UNKNOWN) {}
-CXFA_Node* CXFA_WidgetData::GetUIChild() {
-  if (m_eUIType == XFA_ELEMENT_UNKNOWN) {
-    m_pUiChildNode = XFA_CreateUIChild(m_pNode, m_eUIType);
-  }
-  return m_pUiChildNode;
-}
-XFA_ELEMENT CXFA_WidgetData::GetUIType() {
-  GetUIChild();
-  return m_eUIType;
-}
-CFX_WideString CXFA_WidgetData::GetRawValue() {
-  return m_pNode->GetContent();
-}
-int32_t CXFA_WidgetData::GetAccess(FX_BOOL bTemplate) {
-  if (bTemplate) {
-    CXFA_Node* pNode = m_pNode->GetTemplateNode();
-    if (pNode) {
-      return pNode->GetEnum(XFA_ATTRIBUTE_Access);
-    }
-    return XFA_ATTRIBUTEENUM_Open;
-  }
-  CXFA_Node* pNode = m_pNode;
-  while (pNode) {
-    int32_t iAcc = pNode->GetEnum(XFA_ATTRIBUTE_Access);
-    if (iAcc != XFA_ATTRIBUTEENUM_Open) {
-      return iAcc;
-    }
-    pNode =
-        pNode->GetNodeItem(XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
-  }
-  return XFA_ATTRIBUTEENUM_Open;
-}
-FX_BOOL CXFA_WidgetData::GetAccessKey(CFX_WideStringC& wsAccessKey) {
-  return m_pNode->TryCData(XFA_ATTRIBUTE_AccessKey, wsAccessKey);
-}
-int32_t CXFA_WidgetData::GetAnchorType() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_AnchorType);
-}
-int32_t CXFA_WidgetData::GetColSpan() {
-  return m_pNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
-}
-int32_t CXFA_WidgetData::GetPresence() {
-  return m_pNode->GetEnum(XFA_ATTRIBUTE_Presence);
-  CXFA_Node* pNode = m_pNode;
-  while (pNode && pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) {
-    int32_t iAcc = pNode->GetEnum(XFA_ATTRIBUTE_Presence);
-    if (iAcc != XFA_ATTRIBUTEENUM_Visible) {
-      return iAcc;
-    }
-    pNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-  return XFA_ATTRIBUTEENUM_Visible;
-}
-int32_t CXFA_WidgetData::GetRotate() {
-  CXFA_Measurement ms;
-  if (!m_pNode->TryMeasure(XFA_ATTRIBUTE_Rotate, ms, FALSE)) {
-    return 0;
-  }
-  int32_t iRotate = FXSYS_round(ms.GetValue());
-  iRotate = XFA_MapRotation(iRotate);
-  return iRotate / 90 * 90;
-}
-CXFA_Border CXFA_WidgetData::GetBorder(FX_BOOL bModified) {
-  return CXFA_Border(m_pNode->GetProperty(0, XFA_ELEMENT_Border, bModified));
-}
-CXFA_Caption CXFA_WidgetData::GetCaption(FX_BOOL bModified) {
-  return CXFA_Caption(m_pNode->GetProperty(0, XFA_ELEMENT_Caption, bModified));
-}
-CXFA_Font CXFA_WidgetData::GetFont(FX_BOOL bModified) {
-  return CXFA_Font(m_pNode->GetProperty(0, XFA_ELEMENT_Font, bModified));
-}
-CXFA_Margin CXFA_WidgetData::GetMargin(FX_BOOL bModified) {
-  return CXFA_Margin(m_pNode->GetProperty(0, XFA_ELEMENT_Margin, bModified));
-}
-CXFA_Para CXFA_WidgetData::GetPara(FX_BOOL bModified) {
-  return CXFA_Para(m_pNode->GetProperty(0, XFA_ELEMENT_Para, bModified));
-}
-CXFA_Keep CXFA_WidgetData::GetKeep(FX_BOOL bModified) {
-  return CXFA_Keep(m_pNode->GetProperty(0, XFA_ELEMENT_Keep, bModified),
-                   m_pNode);
-}
-void CXFA_WidgetData::GetEventList(CXFA_NodeArray& events) {
-  m_pNode->GetNodeList(events, 0, XFA_ELEMENT_Event);
-}
-int32_t CXFA_WidgetData::GetEventByActivity(int32_t iActivity,
-                                            CXFA_NodeArray& events,
-                                            FX_BOOL bIsFormReady) {
-  CXFA_NodeArray allEvents;
-  GetEventList(allEvents);
-  int32_t iCount = allEvents.GetSize();
-  for (int32_t i = 0; i < iCount; i++) {
-    CXFA_Event event(allEvents[i]);
-    if (event.GetActivity() == iActivity) {
-      if (iActivity == XFA_ATTRIBUTEENUM_Ready) {
-        CFX_WideStringC wsRef;
-        event.GetRef(wsRef);
-        if (bIsFormReady) {
-          if (wsRef == CFX_WideStringC(L"$form")) {
-            events.Add(allEvents[i]);
-          }
-        } else {
-          if (wsRef == CFX_WideStringC(L"$layout")) {
-            events.Add(allEvents[i]);
-          }
-        }
-      } else {
-        events.Add(allEvents[i]);
-      }
-    }
-  }
-  return events.GetSize();
-}
-CXFA_Value CXFA_WidgetData::GetDefaultValue(FX_BOOL bModified) {
-  CXFA_Node* pTemNode = m_pNode->GetTemplateNode();
-  return CXFA_Value(pTemNode
-                        ? pTemNode->GetProperty(0, XFA_ELEMENT_Value, bModified)
-                        : nullptr);
-}
-CXFA_Value CXFA_WidgetData::GetFormValue(FX_BOOL bModified) {
-  return CXFA_Value(m_pNode->GetProperty(0, XFA_ELEMENT_Value, bModified));
-}
-CXFA_Calculate CXFA_WidgetData::GetCalculate(FX_BOOL bModified) {
-  return CXFA_Calculate(
-      m_pNode->GetProperty(0, XFA_ELEMENT_Calculate, bModified));
-}
-CXFA_Validate CXFA_WidgetData::GetValidate(FX_BOOL bModified) {
-  return CXFA_Validate(
-      m_pNode->GetProperty(0, XFA_ELEMENT_Validate, bModified));
-}
-CXFA_Variables CXFA_WidgetData::GetVariables(FX_BOOL bModified) {
-  return CXFA_Variables(
-      m_pNode->GetProperty(0, XFA_ELEMENT_Variables, bModified));
-}
-CXFA_Bind CXFA_WidgetData::GetBind(FX_BOOL bModified) {
-  return CXFA_Bind(m_pNode->GetProperty(0, XFA_ELEMENT_Bind, bModified));
-}
-CXFA_Assist CXFA_WidgetData::GetAssist(FX_BOOL bModified) {
-  return CXFA_Assist(m_pNode->GetProperty(0, XFA_ELEMENT_Assist, bModified));
-}
-void CXFA_WidgetData::GetRelevant(CFX_WideStringC& wsRelevant) {
-  m_pNode->TryCData(XFA_ATTRIBUTE_Relevant, wsRelevant);
-}
-FX_BOOL CXFA_WidgetData::GetWidth(FX_FLOAT& fWidth) {
-  return TryMeasure(XFA_ATTRIBUTE_W, fWidth);
-}
-FX_BOOL CXFA_WidgetData::GetHeight(FX_FLOAT& fHeight) {
-  return TryMeasure(XFA_ATTRIBUTE_H, fHeight);
-}
-FX_BOOL CXFA_WidgetData::GetMinWidth(FX_FLOAT& fMinWidth) {
-  return TryMeasure(XFA_ATTRIBUTE_MinW, fMinWidth);
-}
-FX_BOOL CXFA_WidgetData::GetMinHeight(FX_FLOAT& fMinHeight) {
-  return TryMeasure(XFA_ATTRIBUTE_MinH, fMinHeight);
-}
-FX_BOOL CXFA_WidgetData::GetMaxWidth(FX_FLOAT& fMaxWidth) {
-  return TryMeasure(XFA_ATTRIBUTE_MaxW, fMaxWidth);
-}
-FX_BOOL CXFA_WidgetData::GetMaxHeight(FX_FLOAT& fMaxHeight) {
-  return TryMeasure(XFA_ATTRIBUTE_MaxH, fMaxHeight);
-}
-CXFA_BindItems CXFA_WidgetData::GetBindItems() {
-  return CXFA_BindItems(m_pNode->GetChild(0, XFA_ELEMENT_BindItems));
-}
-FX_BOOL CXFA_WidgetData::SetAccess(int32_t iAccess, FX_BOOL bNotify) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Access, (XFA_ATTRIBUTEENUM)iAccess,
-                          bNotify);
-}
-FX_BOOL CXFA_WidgetData::SetAccessKey(const CFX_WideString& wsAccessKey) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_AccessKey, wsAccessKey);
-}
-FX_BOOL CXFA_WidgetData::SetAnchorType(int32_t iType) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_AnchorType, (XFA_ATTRIBUTEENUM)iType);
-}
-FX_BOOL CXFA_WidgetData::SetColSpan(int32_t iColSpan) {
-  return m_pNode->SetInteger(XFA_ATTRIBUTE_ColSpan,
-                             (XFA_ATTRIBUTEENUM)iColSpan);
-}
-FX_BOOL CXFA_WidgetData::SetPresence(int32_t iPresence) {
-  return m_pNode->SetEnum(XFA_ATTRIBUTE_Presence, (XFA_ATTRIBUTEENUM)iPresence);
-}
-FX_BOOL CXFA_WidgetData::SetRotate(int32_t iRotate) {
-  iRotate = XFA_MapRotation(iRotate);
-  CXFA_Measurement ms((FX_FLOAT)iRotate, XFA_UNIT_Angle);
-  return m_pNode->SetMeasure(XFA_ATTRIBUTE_Rotate, ms);
-}
-FX_BOOL CXFA_WidgetData::SetRelevant(const CFX_WideString& wsRelevant) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Relevant, wsRelevant);
-}
-FX_BOOL CXFA_WidgetData::SetStatus(FX_DWORD dwStatus) {
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::SetWidth(FX_FLOAT fWidth) {
-  return SetMeasure(XFA_ATTRIBUTE_W, fWidth);
-}
-FX_BOOL CXFA_WidgetData::SetHeight(FX_FLOAT fHeight) {
-  return SetMeasure(XFA_ATTRIBUTE_H, fHeight);
-}
-FX_BOOL CXFA_WidgetData::SetMinWidth(FX_FLOAT fMinWidth) {
-  return SetMeasure(XFA_ATTRIBUTE_MinW, fMinWidth);
-}
-FX_BOOL CXFA_WidgetData::SetMinHeight(FX_FLOAT fMinHeight) {
-  return SetMeasure(XFA_ATTRIBUTE_MinH, fMinHeight);
-}
-FX_BOOL CXFA_WidgetData::SetMaxWidth(FX_FLOAT fMaxWidth) {
-  return SetMeasure(XFA_ATTRIBUTE_MaxW, fMaxWidth);
-}
-FX_BOOL CXFA_WidgetData::SetMaxHeight(FX_FLOAT fMaxHeight) {
-  return SetMeasure(XFA_ATTRIBUTE_MaxH, fMaxHeight);
-}
-FX_BOOL CXFA_WidgetData::SetPos(FX_FLOAT x, FX_FLOAT y) {
-  return SetMeasure(XFA_ATTRIBUTE_X, x) && SetMeasure(XFA_ATTRIBUTE_Y, y);
-}
-FX_BOOL CXFA_WidgetData::SetName(const CFX_WideString& wsName) {
-  return m_pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
-}
-FX_BOOL CXFA_WidgetData::SetButtonHighlight(int32_t iButtonHighlight) {
-  CXFA_Node* pUiChildNode = GetUIChild();
-  return pUiChildNode->SetEnum(XFA_ATTRIBUTE_Highlight,
-                               (XFA_ATTRIBUTEENUM)iButtonHighlight);
-}
-FX_BOOL CXFA_WidgetData::SetButtonRollover(const CFX_WideString& wsRollover,
-                                           FX_BOOL bRichText) {
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::SetButtonDown(const CFX_WideString& wsDown,
-                                       FX_BOOL bRichText) {
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::SetCheckButtonShape(int32_t iCheckButtonShape) {
-  CXFA_Node* pUiChildNode = GetUIChild();
-  return pUiChildNode->SetEnum(XFA_ATTRIBUTE_Shape,
-                               (XFA_ATTRIBUTEENUM)iCheckButtonShape);
-}
-FX_BOOL CXFA_WidgetData::SetCheckButtonMark(int32_t iCheckButtonMark) {
-  CXFA_Node* pUiChildNode = GetUIChild();
-  return pUiChildNode->SetEnum(XFA_ATTRIBUTE_Mark,
-                               (XFA_ATTRIBUTEENUM)iCheckButtonMark);
-}
-FX_BOOL CXFA_WidgetData::SetCheckButtonSize(FX_FLOAT fCheckButtonMark) {
-  CXFA_Node* pUiChildNode = GetUIChild();
-  if (pUiChildNode) {
-    CXFA_Measurement ms(fCheckButtonMark, XFA_UNIT_Pt);
-    return pUiChildNode->SetMeasure(XFA_ATTRIBUTE_Size, ms);
-  }
-  return FALSE;
-}
-CXFA_Border CXFA_WidgetData::GetUIBorder(FX_BOOL bModified) {
-  CXFA_Node* pUIChild = GetUIChild();
-  return CXFA_Border(
-      pUIChild ? pUIChild->GetProperty(0, XFA_ELEMENT_Border, bModified)
-               : nullptr);
-}
-CXFA_Margin CXFA_WidgetData::GetUIMargin(FX_BOOL bModified) {
-  CXFA_Node* pUIChild = GetUIChild();
-  return CXFA_Margin(
-      pUIChild ? pUIChild->GetProperty(0, XFA_ELEMENT_Margin, bModified)
-               : nullptr);
-}
-void CXFA_WidgetData::GetUIMargin(CFX_RectF& rtUIMargin) {
-  rtUIMargin.Reset();
-  CXFA_Margin mgUI = GetUIMargin();
-  if (!mgUI) {
-    return;
-  }
-  CXFA_Border border = GetUIBorder();
-  if (border && border.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {
-    return;
-  }
-  FX_FLOAT fLeftInset, fTopInset, fRightInset, fBottomInset;
-  FX_BOOL bLeft = mgUI.GetLeftInset(fLeftInset);
-  FX_BOOL bTop = mgUI.GetTopInset(fTopInset);
-  FX_BOOL bRight = mgUI.GetRightInset(fRightInset);
-  FX_BOOL bBottom = mgUI.GetBottomInset(fBottomInset);
-  if (border) {
-    FX_BOOL bVisible = FALSE;
-    FX_FLOAT fThickness = 0;
-    border.Get3DStyle(bVisible, fThickness);
-    if (!bLeft || !bTop || !bRight || !bBottom) {
-      CXFA_StrokeArray strokes;
-      border.GetStrokes(strokes);
-      if (!bTop) {
-        fTopInset = XFA_GetEdgeThickness(strokes, bVisible, 0);
-      }
-      if (!bRight) {
-        fRightInset = XFA_GetEdgeThickness(strokes, bVisible, 1);
-      }
-      if (!bBottom) {
-        fBottomInset = XFA_GetEdgeThickness(strokes, bVisible, 2);
-      }
-      if (!bLeft) {
-        fLeftInset = XFA_GetEdgeThickness(strokes, bVisible, 3);
-      }
-    }
-  }
-  rtUIMargin.Set(fLeftInset, fTopInset, fRightInset, fBottomInset);
-}
-int32_t CXFA_WidgetData::GetButtonHighlight() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_Highlight);
-  }
-  return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_Button, XFA_ATTRIBUTE_Highlight, XFA_XDPPACKET_Form);
-}
-FX_BOOL CXFA_WidgetData::GetButtonRollover(CFX_WideString& wsRollover,
-                                           FX_BOOL& bRichText) {
-  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
-    CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-    while (pText) {
-      CFX_WideStringC wsName;
-      pText->TryCData(XFA_ATTRIBUTE_Name, wsName);
-      if (wsName == FX_WSTRC(L"rollover")) {
-        pText->TryContent(wsRollover);
-        bRichText = pText->GetClassID() == XFA_ELEMENT_ExData;
-        return !wsRollover.IsEmpty();
-      }
-      pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetButtonDown(CFX_WideString& wsDown,
-                                       FX_BOOL& bRichText) {
-  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
-    CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-    while (pText) {
-      CFX_WideStringC wsName;
-      pText->TryCData(XFA_ATTRIBUTE_Name, wsName);
-      if (wsName == FX_WSTRC(L"down")) {
-        pText->TryContent(wsDown);
-        bRichText = pText->GetClassID() == XFA_ELEMENT_ExData;
-        return !wsDown.IsEmpty();
-      }
-      pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-  }
-  return FALSE;
-}
-int32_t CXFA_WidgetData::GetCheckButtonShape() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_Shape);
-  }
-  return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Shape, XFA_XDPPACKET_Form);
-}
-int32_t CXFA_WidgetData::GetCheckButtonMark() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_Mark);
-  }
-  return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Mark, XFA_XDPPACKET_Form);
-}
-FX_BOOL CXFA_WidgetData::IsRadioButton() {
-  if (CXFA_Node* pParent = m_pNode->GetNodeItem(XFA_NODEITEM_Parent)) {
-    return pParent->GetClassID() == XFA_ELEMENT_ExclGroup;
-  }
-  return FALSE;
-}
-FX_FLOAT CXFA_WidgetData::GetCheckButtonSize() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetMeasure(XFA_ATTRIBUTE_Size).ToUnit(XFA_UNIT_Pt);
-  }
-  return XFA_GetAttributeDefaultValue_Measure(
-             XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Size, XFA_XDPPACKET_Form)
-      .ToUnit(XFA_UNIT_Pt);
-}
-FX_BOOL CXFA_WidgetData::IsAllowNeutral() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetBoolean(XFA_ATTRIBUTE_AllowNeutral);
-  }
-  return XFA_GetAttributeDefaultValue_Boolean(
-      XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_AllowNeutral, XFA_XDPPACKET_Form);
-}
-XFA_CHECKSTATE CXFA_WidgetData::GetCheckState() {
-  CFX_WideString wsValue = GetRawValue();
-  if (wsValue.IsEmpty()) {
-    return XFA_CHECKSTATE_Off;
-  }
-  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
-    CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-    int32_t i = 0;
-    while (pText) {
-      CFX_WideString wsContent;
-      if (pText->TryContent(wsContent) && (wsContent == wsValue)) {
-        return (XFA_CHECKSTATE)i;
-      }
-      i++;
-      pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-  }
-  return XFA_CHECKSTATE_Off;
-}
-void CXFA_WidgetData::SetCheckState(XFA_CHECKSTATE eCheckState,
-                                    FX_BOOL bNotify) {
-  CXFA_WidgetData exclGroup(GetExclGroupNode());
-  if (exclGroup) {
-    CFX_WideString wsValue;
-    if (eCheckState != XFA_CHECKSTATE_Off) {
-      if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
-        CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-        if (pText) {
-          pText->TryContent(wsValue);
-        }
-      }
-    }
-    CXFA_Node* pChild =
-        exclGroup.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
-    for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pChild->GetClassID() != XFA_ELEMENT_Field) {
-        continue;
-      }
-      CXFA_Node* pItem = pChild->GetChild(0, XFA_ELEMENT_Items);
-      if (!pItem) {
-        continue;
-      }
-      CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (!pItemchild) {
-        continue;
-      }
-      CFX_WideString text = pItemchild->GetContent();
-      CFX_WideString wsChildValue = text;
-      if (wsValue != text) {
-        pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);
-        if (pItemchild) {
-          wsChildValue = pItemchild->GetContent();
-        } else {
-          wsChildValue.Empty();
-        }
-      }
-      CXFA_WidgetData ch(pChild);
-      ch.SyncValue(wsChildValue, bNotify);
-    }
-    exclGroup.SyncValue(wsValue, bNotify);
-  } else {
-    CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items);
-    if (!pItems) {
-      return;
-    }
-    int32_t i = -1;
-    CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-    CFX_WideString wsContent;
-    while (pText) {
-      i++;
-      if (i == eCheckState) {
-        pText->TryContent(wsContent);
-        break;
-      }
-      pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-    SyncValue(wsContent, bNotify);
-  }
-}
-CXFA_Node* CXFA_WidgetData::GetExclGroupNode() {
-  CXFA_Node* pExcl = ToNode(m_pNode->GetNodeItem(XFA_NODEITEM_Parent));
-  if (!pExcl || pExcl->GetClassID() != XFA_ELEMENT_ExclGroup) {
-    return NULL;
-  }
-  return pExcl;
-}
-CXFA_Node* CXFA_WidgetData::GetSelectedMember() {
-  CXFA_Node* pSelectedMember = NULL;
-  CFX_WideString wsState = GetRawValue();
-  if (wsState.IsEmpty()) {
-    return pSelectedMember;
-  }
-  for (CXFA_Node* pNode = ToNode(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild));
-       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    CXFA_WidgetData widgetData(pNode);
-    if (widgetData.GetCheckState() == XFA_CHECKSTATE_On) {
-      pSelectedMember = pNode;
-      break;
-    }
-  }
-  return pSelectedMember;
-}
-CXFA_Node* CXFA_WidgetData::SetSelectedMember(const CFX_WideStringC& wsName,
-                                              FX_BOOL bNotify) {
-  CXFA_Node* pSelectedMember = NULL;
-  FX_DWORD nameHash =
-      FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());
-  for (CXFA_Node* pNode = ToNode(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild));
-       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetNameHash() == nameHash) {
-      CXFA_WidgetData widgetData(pNode);
-      widgetData.SetCheckState(XFA_CHECKSTATE_On, bNotify);
-      pSelectedMember = pNode;
-      break;
-    }
-  }
-  return pSelectedMember;
-}
-void CXFA_WidgetData::SetSelectedMemberByValue(const CFX_WideStringC& wsValue,
-                                               FX_BOOL bNotify,
-                                               FX_BOOL bScriptModify,
-                                               FX_BOOL bSyncData) {
-  CFX_WideString wsExclGroup;
-  for (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Field) {
-      continue;
-    }
-    CXFA_Node* pItem = pNode->GetChild(0, XFA_ELEMENT_Items);
-    if (!pItem) {
-      continue;
-    }
-    CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
-    if (!pItemchild) {
-      continue;
-    }
-    CFX_WideString wsChildValue = pItemchild->GetContent();
-    if (wsValue != wsChildValue) {
-      pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);
-      if (pItemchild) {
-        wsChildValue = pItemchild->GetContent();
-      } else {
-        wsChildValue.Empty();
-      }
-    } else {
-      wsExclGroup = wsValue;
-    }
-    pNode->SetContent(wsChildValue, wsChildValue, bNotify, bScriptModify,
-                      FALSE);
-  }
-  if (m_pNode) {
-    m_pNode->SetContent(wsExclGroup, wsExclGroup, bNotify, bScriptModify,
-                        bSyncData);
-  }
-}
-CXFA_Node* CXFA_WidgetData::GetExclGroupFirstMember() {
-  CXFA_Node* pExcl = GetNode();
-  if (!pExcl) {
-    return NULL;
-  }
-  CXFA_Node* pNode = pExcl->GetNodeItem(XFA_NODEITEM_FirstChild);
-  while (pNode) {
-    if (pNode->GetClassID() == XFA_ELEMENT_Field) {
-      return pNode;
-    }
-    pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_WidgetData::GetExclGroupNextMember(CXFA_Node* pNode) {
-  if (!pNode) {
-    return NULL;
-  }
-  CXFA_Node* pNodeField = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-  while (pNodeField) {
-    if (pNodeField->GetClassID() == XFA_ELEMENT_Field) {
-      return pNodeField;
-    }
-    pNodeField = pNodeField->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  return NULL;
-}
-int32_t CXFA_WidgetData::GetChoiceListCommitOn() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_CommitOn);
-  }
-  return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_CommitOn, XFA_XDPPACKET_Form);
-}
-FX_BOOL CXFA_WidgetData::IsChoiceListAllowTextEntry() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetBoolean(XFA_ATTRIBUTE_TextEntry);
-  }
-  return XFA_GetAttributeDefaultValue_Boolean(
-      XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_TextEntry, XFA_XDPPACKET_Form);
-}
-int32_t CXFA_WidgetData::GetChoiceListOpen() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_Open);
-  }
-  return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_Open, XFA_XDPPACKET_Form);
-}
-FX_BOOL CXFA_WidgetData::IsListBox() {
-  int32_t iOpenMode = GetChoiceListOpen();
-  return (iOpenMode == XFA_ATTRIBUTEENUM_Always ||
-          iOpenMode == XFA_ATTRIBUTEENUM_MultiSelect);
-}
-int32_t CXFA_WidgetData::CountChoiceListItems(FX_BOOL bSaveValue) {
-  CXFA_NodeArray pItems;
-  CXFA_Node* pItem = NULL;
-  int32_t iCount = 0;
-  CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    iCount++;
-    pItems.Add(pNode);
-    if (iCount == 2) {
-      break;
-    }
-  }
-  if (iCount == 0) {
-    return 0;
-  }
-  pItem = pItems[0];
-  if (iCount > 1) {
-    FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
-    FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
-    if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave) {
-      pItem = pItems[1];
-    }
-  }
-  pItems.RemoveAll();
-  return pItem->CountChildren(XFA_ELEMENT_UNKNOWN);
-}
-FX_BOOL CXFA_WidgetData::GetChoiceListItem(CFX_WideString& wsText,
-                                           int32_t nIndex,
-                                           FX_BOOL bSaveValue) {
-  wsText.Empty();
-  CXFA_NodeArray pItemsArray;
-  CXFA_Node* pItems = NULL;
-  int32_t iCount = 0;
-  CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    iCount++;
-    pItemsArray.Add(pNode);
-    if (iCount == 2) {
-      break;
-    }
-  }
-  if (iCount == 0) {
-    return FALSE;
-  }
-  pItems = pItemsArray[0];
-  if (iCount > 1) {
-    FX_BOOL bItemOneHasSave = pItemsArray[0]->GetBoolean(XFA_ATTRIBUTE_Save);
-    FX_BOOL bItemTwoHasSave = pItemsArray[1]->GetBoolean(XFA_ATTRIBUTE_Save);
-    if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave) {
-      pItems = pItemsArray[1];
-    }
-  }
-  if (pItems) {
-    CXFA_Node* pItem = pItems->GetChild(nIndex, XFA_ELEMENT_UNKNOWN);
-    if (pItem) {
-      pItem->TryContent(wsText);
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-void CXFA_WidgetData::GetChoiceListItems(CFX_WideStringArray& wsTextArray,
-                                         FX_BOOL bSaveValue) {
-  CXFA_NodeArray pItems;
-  CXFA_Node* pItem = NULL;
-  int32_t iCount = 0;
-  CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    iCount++;
-    pItems.Add(pNode);
-    if (iCount == 2) {
-      break;
-    }
-  }
-  if (iCount == 0) {
-    return;
-  }
-  pItem = pItems[0];
-  if (iCount > 1) {
-    FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
-    FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
-    if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave) {
-      pItem = pItems[1];
-    }
-  }
-  pItems.RemoveAll();
-  pNode = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    pNode->TryContent(wsTextArray.Add());
-  }
-}
-int32_t CXFA_WidgetData::CountSelectedItems() {
-  CFX_WideStringArray wsValueArray;
-  GetSelectedItemsValue(wsValueArray);
-  if (IsListBox() || !IsChoiceListAllowTextEntry()) {
-    return wsValueArray.GetSize();
-  }
-  int32_t iSelected = 0;
-  CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
-  int32_t iValues = wsValueArray.GetSize();
-  for (int32_t i = 0; i < iValues; i++) {
-    int32_t iSaves = wsSaveTextArray.GetSize();
-    for (int32_t j = 0; j < iSaves; j++) {
-      if (wsValueArray[i] == wsSaveTextArray[j]) {
-        iSelected++;
-        break;
-      }
-    }
-  }
-  return iSelected;
-}
-int32_t CXFA_WidgetData::GetSelectedItem(int32_t nIndex) {
-  CFX_WideStringArray wsValueArray;
-  GetSelectedItemsValue(wsValueArray);
-  CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
-  int32_t iSaves = wsSaveTextArray.GetSize();
-  for (int32_t j = 0; j < iSaves; j++) {
-    if (wsValueArray[nIndex] == wsSaveTextArray[j]) {
-      return j;
-    }
-  }
-  return -1;
-}
-void CXFA_WidgetData::GetSelectedItems(CFX_Int32Array& iSelArray) {
-  CFX_WideStringArray wsValueArray;
-  GetSelectedItemsValue(wsValueArray);
-  int32_t iValues = wsValueArray.GetSize();
-  if (iValues < 1) {
-    return;
-  }
-  CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
-  int32_t iSaves = wsSaveTextArray.GetSize();
-  for (int32_t i = 0; i < iValues; i++) {
-    for (int32_t j = 0; j < iSaves; j++) {
-      if (wsValueArray[i] == wsSaveTextArray[j]) {
-        iSelArray.Add(j);
-        break;
-      }
-    }
-  }
-}
-void CXFA_WidgetData::GetSelectedItemsValue(
-    CFX_WideStringArray& wsSelTextArray) {
-  CFX_WideString wsValue = GetRawValue();
-  if (GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
-    if (!wsValue.IsEmpty()) {
-      int32_t iStart = 0;
-      int32_t iLength = wsValue.GetLength();
-      int32_t iEnd = wsValue.Find(L'\n', iStart);
-      iEnd = (iEnd == -1) ? iLength : iEnd;
-      while (iEnd >= iStart) {
-        wsSelTextArray.Add(wsValue.Mid(iStart, iEnd - iStart));
-        iStart = iEnd + 1;
-        if (iStart >= iLength) {
-          break;
-        }
-        iEnd = wsValue.Find(L'\n', iStart);
-        if (iEnd < 0) {
-          wsSelTextArray.Add(wsValue.Mid(iStart, iLength - iStart));
-        }
-      }
-    }
-  } else {
-    wsSelTextArray.Add(wsValue);
-  }
-}
-FX_BOOL CXFA_WidgetData::GetItemState(int32_t nIndex) {
-  if (nIndex < 0) {
-    return FALSE;
-  }
-  CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
-  if (wsSaveTextArray.GetSize() <= nIndex) {
-    return FALSE;
-  }
-  CFX_WideStringArray wsValueArray;
-  GetSelectedItemsValue(wsValueArray);
-  int32_t iValues = wsValueArray.GetSize();
-  for (int32_t j = 0; j < iValues; j++) {
-    if (wsValueArray[j] == wsSaveTextArray[nIndex]) {
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-void CXFA_WidgetData::SetItemState(int32_t nIndex,
-                                   FX_BOOL bSelected,
-                                   FX_BOOL bNotify,
-                                   FX_BOOL bScriptModify,
-                                   FX_BOOL bSyncData) {
-  if (nIndex < 0) {
-    return;
-  }
-  CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
-  if (wsSaveTextArray.GetSize() <= nIndex) {
-    return;
-  }
-  int32_t iSel = -1;
-  CFX_WideStringArray wsValueArray;
-  GetSelectedItemsValue(wsValueArray);
-  int32_t iValues = wsValueArray.GetSize();
-  for (int32_t j = 0; j < iValues; j++) {
-    if (wsValueArray[j] == wsSaveTextArray[nIndex]) {
-      iSel = j;
-      break;
-    }
-  }
-  if (GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
-    if (bSelected) {
-      if (iSel < 0) {
-        CFX_WideString wsValue = GetRawValue();
-        if (!wsValue.IsEmpty()) {
-          wsValue += L"\n";
-        }
-        wsValue += wsSaveTextArray[nIndex];
-        m_pNode->SetContent(wsValue, wsValue, bNotify, bScriptModify,
-                            bSyncData);
-      }
-    } else if (iSel >= 0) {
-      CFX_Int32Array iSelArray;
-      GetSelectedItems(iSelArray);
-      for (int32_t i = 0; i < iSelArray.GetSize(); i++) {
-        if (iSelArray[i] == nIndex) {
-          iSelArray.RemoveAt(i);
-          break;
-        }
-      }
-      SetSelectdItems(iSelArray, bNotify, bScriptModify, bSyncData);
-    }
-  } else {
-    if (bSelected) {
-      if (iSel < 0) {
-        CFX_WideString wsSaveText = wsSaveTextArray[nIndex];
-        CFX_WideString wsFormatText(wsSaveText);
-        GetFormatDataValue(wsSaveText, wsFormatText);
-        m_pNode->SetContent(wsSaveText, wsFormatText, bNotify, bScriptModify,
-                            bSyncData);
-      }
-    } else if (iSel >= 0) {
-      m_pNode->SetContent(CFX_WideString(), CFX_WideString(), bNotify,
-                          bScriptModify, bSyncData);
-    }
-  }
-}
-void CXFA_WidgetData::SetSelectdItems(CFX_Int32Array& iSelArray,
-                                      FX_BOOL bNotify,
-                                      FX_BOOL bScriptModify,
-                                      FX_BOOL bSyncData) {
-  CFX_WideString wsValue;
-  int32_t iSize = iSelArray.GetSize();
-  if (iSize >= 1) {
-    CFX_WideStringArray wsSaveTextArray;
-    GetChoiceListItems(wsSaveTextArray, TRUE);
-    CFX_WideString wsItemValue;
-    for (int32_t i = 0; i < iSize; i++) {
-      wsItemValue = (iSize == 1)
-                        ? wsSaveTextArray[iSelArray[i]]
-                        : wsSaveTextArray[iSelArray[i]] + FX_WSTRC(L"\n");
-      wsValue += wsItemValue;
-    }
-  }
-  CFX_WideString wsFormat(wsValue);
-  if (GetChoiceListOpen() != XFA_ATTRIBUTEENUM_MultiSelect) {
-    GetFormatDataValue(wsValue, wsFormat);
-  }
-  m_pNode->SetContent(wsValue, wsFormat, bNotify, bScriptModify, bSyncData);
-}
-void CXFA_WidgetData::ClearAllSelections() {
-  CXFA_Node* pBind = m_pNode->GetBindData();
-  if (pBind && GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
-    while (CXFA_Node* pChildNode =
-               pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-      pBind->RemoveChild(pChildNode);
-    }
-  } else {
-    SyncValue(CFX_WideString(), FALSE);
-  }
-}
-void CXFA_WidgetData::InsertItem(const CFX_WideString& wsLabel,
-                                 const CFX_WideString& wsValue,
-                                 int32_t nIndex,
-                                 FX_BOOL bNotify) {
-  CFX_WideString wsNewValue(wsValue);
-  if (wsNewValue.IsEmpty()) {
-    wsNewValue = wsLabel;
-  }
-  CXFA_NodeArray listitems;
-  int32_t iCount = 0;
-  CXFA_Node* pItemNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pItemNode;
-       pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItemNode->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    listitems.Add(pItemNode);
-    iCount++;
-  }
-  if (iCount < 1) {
-    CXFA_Node* pItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
-    m_pNode->InsertChild(-1, pItems);
-    InsertListTextItem(pItems, wsLabel, nIndex);
-    CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
-    m_pNode->InsertChild(-1, pSaveItems);
-    pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
-    InsertListTextItem(pSaveItems, wsNewValue, nIndex);
-  } else if (iCount > 1) {
-    for (int32_t i = 0; i < 2; i++) {
-      CXFA_Node* pNode = listitems[i];
-      FX_BOOL bHasSave = pNode->GetBoolean(XFA_ATTRIBUTE_Save);
-      if (bHasSave) {
-        InsertListTextItem(pNode, wsNewValue, nIndex);
-      } else {
-        InsertListTextItem(pNode, wsLabel, nIndex);
-      }
-    }
-  } else {
-    CXFA_Node* pNode = listitems[0];
-    pNode->SetBoolean(XFA_ATTRIBUTE_Save, FALSE);
-    pNode->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Visible);
-    CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
-    m_pNode->InsertChild(-1, pSaveItems);
-    pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
-    pSaveItems->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Hidden);
-    listitems.RemoveAll();
-    CXFA_Node* pListNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    int32_t i = 0;
-    while (pListNode) {
-      CFX_WideString wsOldValue;
-      pListNode->TryContent(wsOldValue);
-      InsertListTextItem(pSaveItems, wsOldValue, i);
-      i++;
-      pListNode = pListNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-    InsertListTextItem(pNode, wsLabel, nIndex);
-    InsertListTextItem(pSaveItems, wsNewValue, nIndex);
-  }
-  if (!bNotify) {
-    return;
-  }
-  m_pNode->GetDocument()->GetNotify()->OnWidgetDataEvent(
-      this, XFA_WIDGETEVENT_ListItemAdded, (void*)(const FX_WCHAR*)wsLabel,
-      (void*)(const FX_WCHAR*)wsValue, (void*)(uintptr_t)nIndex);
-}
-void CXFA_WidgetData::GetItemLabel(const CFX_WideStringC& wsValue,
-                                   CFX_WideString& wsLabel) {
-  int32_t iCount = 0;
-  CXFA_NodeArray listitems;
-  CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItems->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    iCount++;
-    listitems.Add(pItems);
-  }
-  if (iCount <= 1) {
-    wsLabel = wsValue;
-  } else {
-    CXFA_Node* pLabelItems = listitems[0];
-    FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
-    CXFA_Node* pSaveItems = NULL;
-    if (bSave) {
-      pSaveItems = pLabelItems;
-      pLabelItems = listitems[1];
-    } else {
-      pSaveItems = listitems[1];
-    }
-    iCount = 0;
-    int32_t iSearch = -1;
-    CFX_WideString wsContent;
-    CXFA_Node* pChildItem = pSaveItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-    for (; pChildItem;
-         pChildItem = pChildItem->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      pChildItem->TryContent(wsContent);
-      if (wsContent == wsValue) {
-        iSearch = iCount;
-        break;
-      }
-      iCount++;
-    }
-    if (iSearch < 0) {
-      return;
-    }
-    if (CXFA_Node* pText =
-            pLabelItems->GetChild(iSearch, XFA_ELEMENT_UNKNOWN)) {
-      pText->TryContent(wsLabel);
-    }
-  }
-}
-void CXFA_WidgetData::GetItemValue(const CFX_WideStringC& wsLabel,
-                                   CFX_WideString& wsValue) {
-  int32_t iCount = 0;
-  CXFA_NodeArray listitems;
-  CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItems->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    iCount++;
-    listitems.Add(pItems);
-  }
-  if (iCount <= 1) {
-    wsValue = wsLabel;
-  } else {
-    CXFA_Node* pLabelItems = listitems[0];
-    FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
-    CXFA_Node* pSaveItems = NULL;
-    if (bSave) {
-      pSaveItems = pLabelItems;
-      pLabelItems = listitems[1];
-    } else {
-      pSaveItems = listitems[1];
-    }
-    iCount = 0;
-    int32_t iSearch = -1;
-    CFX_WideString wsContent;
-    CXFA_Node* pChildItem = pLabelItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-    for (; pChildItem;
-         pChildItem = pChildItem->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      pChildItem->TryContent(wsContent);
-      if (wsContent == wsLabel) {
-        iSearch = iCount;
-        break;
-      }
-      iCount++;
-    }
-    if (iSearch < 0) {
-      return;
-    }
-    if (CXFA_Node* pText = pSaveItems->GetChild(iSearch, XFA_ELEMENT_UNKNOWN)) {
-      pText->TryContent(wsValue);
-    }
-  }
-}
-FX_BOOL CXFA_WidgetData::DeleteItem(int32_t nIndex,
-                                    FX_BOOL bNotify,
-                                    FX_BOOL bScriptModify,
-                                    FX_BOOL bSyncData) {
-  FX_BOOL bSetValue = FALSE;
-  CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItems->GetClassID() != XFA_ELEMENT_Items) {
-      continue;
-    }
-    if (nIndex < 0) {
-      while (CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-        pItems->RemoveChild(pNode);
-      }
-    } else {
-      if (!bSetValue && pItems->GetBoolean(XFA_ATTRIBUTE_Save)) {
-        SetItemState(nIndex, FALSE, TRUE, bScriptModify, bSyncData);
-        bSetValue = TRUE;
-      }
-      int32_t i = 0;
-      CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
-      while (pNode) {
-        if (i == nIndex) {
-          pItems->RemoveChild(pNode);
-          break;
-        }
-        i++;
-        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-      }
-    }
-  }
-  if (!bNotify) {
-    return TRUE;
-  }
-  m_pNode->GetDocument()->GetNotify()->OnWidgetDataEvent(
-      this, XFA_WIDGETEVENT_ListItemRemoved, (void*)(uintptr_t)nIndex);
-  return TRUE;
-}
-int32_t CXFA_WidgetData::GetHorizontalScrollPolicy() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_HScrollPolicy);
-  }
-  return XFA_ATTRIBUTEENUM_Auto;
-}
-int32_t CXFA_WidgetData::GetNumberOfCells() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (!pUIChild) {
-    return -1;
-  }
-  if (CXFA_Node* pNode = pUIChild->GetChild(0, XFA_ELEMENT_Comb)) {
-    return pNode->GetInteger(XFA_ATTRIBUTE_NumberOfCells);
-  }
-  return -1;
-}
-FX_BOOL CXFA_WidgetData::IsDateTimeEditUsePicker() {
-  return TRUE;
-}
-CFX_WideString CXFA_WidgetData::GetBarcodeType() {
-  CXFA_Node* pUIChild = GetUIChild();
-  return pUIChild ? pUIChild->GetCData(XFA_ATTRIBUTE_Type) : NULL;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_CharEncoding(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CFX_WideString wsCharEncoding;
-  if (pUIChild->TryCData(XFA_ATTRIBUTE_CharEncoding, wsCharEncoding)) {
-    if (wsCharEncoding.CompareNoCase(L"UTF-16")) {
-      val = CHAR_ENCODING_UNICODE;
-      return TRUE;
-    } else if (wsCharEncoding.CompareNoCase(L"UTF-8")) {
-      val = CHAR_ENCODING_UTF8;
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_Checksum(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  XFA_ATTRIBUTEENUM eChecksum;
-  if (pUIChild->TryEnum(XFA_ATTRIBUTE_Checksum, eChecksum)) {
-    switch (eChecksum) {
-      case XFA_ATTRIBUTEENUM_None:
-        val = 0;
-        return TRUE;
-      case XFA_ATTRIBUTEENUM_Auto:
-        val = 1;
-        return TRUE;
-      case XFA_ATTRIBUTEENUM_1mod10:
-        break;
-      case XFA_ATTRIBUTEENUM_1mod10_1mod11:
-        break;
-      case XFA_ATTRIBUTEENUM_2mod10:
-        break;
-      default:
-        break;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_DataLength(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CFX_WideString wsDataLength;
-  if (pUIChild->TryCData(XFA_ATTRIBUTE_DataLength, wsDataLength)) {
-    val = FXSYS_wtoi(wsDataLength);
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_StartChar(FX_CHAR& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CFX_WideStringC wsStartEndChar;
-  if (pUIChild->TryCData(XFA_ATTRIBUTE_StartChar, wsStartEndChar)) {
-    if (wsStartEndChar.GetLength()) {
-      val = (FX_CHAR)wsStartEndChar.GetAt(0);
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_EndChar(FX_CHAR& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CFX_WideStringC wsStartEndChar;
-  if (pUIChild->TryCData(XFA_ATTRIBUTE_EndChar, wsStartEndChar)) {
-    if (wsStartEndChar.GetLength()) {
-      val = (FX_CHAR)wsStartEndChar.GetAt(0);
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ECLevel(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CFX_WideString wsECLevel;
-  if (pUIChild->TryCData(XFA_ATTRIBUTE_ErrorCorrectionLevel, wsECLevel)) {
-    val = FXSYS_wtoi(wsECLevel);
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ModuleWidth(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CXFA_Measurement mModuleWidthHeight;
-  if (pUIChild->TryMeasure(XFA_ATTRIBUTE_ModuleWidth, mModuleWidthHeight)) {
-    val = (int32_t)mModuleWidthHeight.ToUnit(XFA_UNIT_Pt);
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ModuleHeight(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CXFA_Measurement mModuleWidthHeight;
-  if (pUIChild->TryMeasure(XFA_ATTRIBUTE_ModuleHeight, mModuleWidthHeight)) {
-    val = (int32_t)mModuleWidthHeight.ToUnit(XFA_UNIT_Pt);
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_PrintChecksum(FX_BOOL& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  FX_BOOL bPrintCheckDigit;
-  if (pUIChild->TryBoolean(XFA_ATTRIBUTE_PrintCheckDigit, bPrintCheckDigit)) {
-    val = bPrintCheckDigit;
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_TextLocation(int32_t& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  XFA_ATTRIBUTEENUM eTextLocation;
-  if (pUIChild->TryEnum(XFA_ATTRIBUTE_TextLocation, eTextLocation)) {
-    switch (eTextLocation) {
-      case XFA_ATTRIBUTEENUM_None:
-        val = BC_TEXT_LOC_NONE;
-        return TRUE;
-      case XFA_ATTRIBUTEENUM_Above:
-        val = BC_TEXT_LOC_ABOVE;
-        return TRUE;
-      case XFA_ATTRIBUTEENUM_Below:
-        val = BC_TEXT_LOC_BELOW;
-        return TRUE;
-      case XFA_ATTRIBUTEENUM_AboveEmbedded:
-        val = BC_TEXT_LOC_ABOVEEMBED;
-        return TRUE;
-      case XFA_ATTRIBUTEENUM_BelowEmbedded:
-        val = BC_TEXT_LOC_BELOWEMBED;
-        return TRUE;
-      default:
-        break;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_Truncate(FX_BOOL& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  FX_BOOL bTruncate;
-  if (pUIChild->TryBoolean(XFA_ATTRIBUTE_Truncate, bTruncate)) {
-    val = bTruncate;
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_WideNarrowRatio(FX_FLOAT& val) {
-  CXFA_Node* pUIChild = GetUIChild();
-  CFX_WideString wsWideNarrowRatio;
-  if (pUIChild->TryCData(XFA_ATTRIBUTE_WideNarrowRatio, wsWideNarrowRatio)) {
-    FX_STRSIZE ptPos = wsWideNarrowRatio.Find(':');
-    FX_FLOAT fRatio = 0;
-    if (ptPos >= 0) {
-      fRatio = (FX_FLOAT)FXSYS_wtoi(wsWideNarrowRatio);
-    } else {
-      int32_t fA, fB;
-      fA = FXSYS_wtoi(wsWideNarrowRatio.Left(ptPos));
-      fB = FXSYS_wtoi(wsWideNarrowRatio.Mid(ptPos + 1));
-      if (fB) {
-        fRatio = (FX_FLOAT)fA / fB;
-      }
-    }
-    val = fRatio;
-    return TRUE;
-  }
-  return FALSE;
-}
-void CXFA_WidgetData::GetPasswordChar(CFX_WideString& wsPassWord) {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    pUIChild->TryCData(XFA_ATTRIBUTE_PasswordChar, wsPassWord);
-  } else {
-    wsPassWord = XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT_PasswordEdit,
-                                                    XFA_ATTRIBUTE_PasswordChar,
-                                                    XFA_XDPPACKET_Form);
-  }
-}
-FX_BOOL CXFA_WidgetData::IsAllowRichText() {
-  CXFA_Node* pUIChild = GetUIChild();
-  FX_BOOL bValue = FALSE;
-  if (pUIChild &&
-      pUIChild->TryBoolean(XFA_ATTRIBUTE_AllowRichText, bValue, FALSE)) {
-    return bValue;
-  }
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
-    if (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-      return pChild->GetClassID() == XFA_ELEMENT_ExData;
-    }
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::IsMultiLine() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetBoolean(XFA_ATTRIBUTE_MultiLine);
-  }
-  return XFA_GetAttributeDefaultValue_Boolean(
-      XFA_ELEMENT_TextEdit, XFA_ATTRIBUTE_MultiLine, XFA_XDPPACKET_Form);
-}
-int32_t CXFA_WidgetData::GetVerticalScrollPolicy() {
-  CXFA_Node* pUIChild = GetUIChild();
-  if (pUIChild) {
-    return pUIChild->GetEnum(XFA_ATTRIBUTE_VScrollPolicy);
-  }
-  return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_TextEdit, XFA_ATTRIBUTE_VScrollPolicy, XFA_XDPPACKET_Form);
-}
-int32_t CXFA_WidgetData::GetMaxChars(XFA_ELEMENT& eType) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
-    if (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {
-      switch (pChild->GetClassID()) {
-        case XFA_ELEMENT_Text:
-          eType = XFA_ELEMENT_Text;
-          return pChild->GetInteger(XFA_ATTRIBUTE_MaxChars);
-        case XFA_ELEMENT_ExData: {
-          eType = XFA_ELEMENT_ExData;
-          int32_t iMax = pChild->GetInteger(XFA_ATTRIBUTE_MaxLength);
-          return iMax < 0 ? 0 : iMax;
-        }
-        default:
-          break;
-      }
-    }
-  }
-  return 0;
-}
-FX_BOOL CXFA_WidgetData::GetFracDigits(int32_t& iFracDigits) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
-    if (CXFA_Node* pChild = pNode->GetChild(0, XFA_ELEMENT_Decimal)) {
-      return pChild->TryInteger(XFA_ATTRIBUTE_FracDigits, iFracDigits);
-    }
-  }
-  iFracDigits = -1;
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetLeadDigits(int32_t& iLeadDigits) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
-    if (CXFA_Node* pChild = pNode->GetChild(0, XFA_ELEMENT_Decimal)) {
-      return pChild->TryInteger(XFA_ATTRIBUTE_LeadDigits, iLeadDigits);
-    }
-  }
-  iLeadDigits = -1;
-  return FALSE;
-}
-CFX_WideString XFA_NumericLimit(const CFX_WideString& wsValue,
-                                int32_t iLead,
-                                int32_t iTread) {
-  if ((iLead == -1) && (iTread == -1)) {
-    return wsValue;
-  }
-  CFX_WideString wsRet;
-  int32_t iLead_ = 0, iTread_ = -1;
-  int32_t iCount = wsValue.GetLength();
-  if (iCount == 0) {
-    return wsValue;
-  }
-  int32_t i = 0;
-  if (wsValue[i] == L'-') {
-    wsRet += L'-';
-    i++;
-  }
-  for (; i < iCount; i++) {
-    FX_WCHAR wc = wsValue[i];
-    if (XFA_IsDigit(wc)) {
-      if (iLead >= 0) {
-        iLead_++;
-        if (iLead_ > iLead) {
-          return L"0";
-        }
-      } else if (iTread_ >= 0) {
-        iTread_++;
-        if (iTread_ > iTread) {
-          if (iTread != -1) {
-            CFX_Decimal wsDeci = CFX_Decimal(wsValue);
-            wsDeci.SetScale(iTread);
-            wsRet = wsDeci;
-          }
-          return wsRet;
-        }
-      }
-    } else if (wc == L'.') {
-      iTread_ = 0;
-      iLead = -1;
-    }
-    wsRet += wc;
-  }
-  return wsRet;
-}
-FX_BOOL CXFA_WidgetData::SetValue(const CFX_WideString& wsValue,
-                                  XFA_VALUEPICTURE eValueType) {
-  if (wsValue.IsEmpty()) {
-    SyncValue(wsValue, TRUE);
-    return TRUE;
-  }
-  m_bPreNull = m_bIsNull;
-  m_bIsNull = FALSE;
-  CFX_WideString wsNewText(wsValue);
-  CFX_WideString wsPicture;
-  GetPictureContent(wsPicture, eValueType);
-  FX_BOOL bValidate = TRUE;
-  FX_BOOL bSyncData = FALSE;
-  CXFA_Node* pNode = GetUIChild();
-  if (!pNode) {
-    return TRUE;
-  }
-  XFA_ELEMENT uiType = pNode->GetClassID();
-  if (!wsPicture.IsEmpty()) {
-    CXFA_LocaleMgr* pLocalMgr = m_pNode->GetDocument()->GetLocalMgr();
-    IFX_Locale* pLocale = GetLocal();
-    CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
-    bValidate =
-        widgetValue.ValidateValue(wsValue, wsPicture, pLocale, &wsPicture);
-    if (bValidate) {
-      widgetValue = CXFA_LocaleValue(widgetValue.GetType(), wsNewText,
-                                     wsPicture, pLocale, pLocalMgr);
-      wsNewText = widgetValue.GetValue();
-      if (uiType == XFA_ELEMENT_NumericEdit) {
-        int32_t iLeadDigits = 0;
-        int32_t iFracDigits = 0;
-        GetLeadDigits(iLeadDigits);
-        GetFracDigits(iFracDigits);
-        wsNewText = XFA_NumericLimit(wsNewText, iLeadDigits, iFracDigits);
-      }
-      bSyncData = TRUE;
-    }
-  } else {
-    if (uiType == XFA_ELEMENT_NumericEdit) {
-      if (wsNewText != FX_WSTRC(L"0")) {
-        int32_t iLeadDigits = 0;
-        int32_t iFracDigits = 0;
-        GetLeadDigits(iLeadDigits);
-        GetFracDigits(iFracDigits);
-        wsNewText = XFA_NumericLimit(wsNewText, iLeadDigits, iFracDigits);
-      }
-      bSyncData = TRUE;
-    }
-  }
-  if (uiType != XFA_ELEMENT_NumericEdit || bSyncData) {
-    SyncValue(wsNewText, TRUE);
-  }
-  return bValidate;
-}
-FX_BOOL CXFA_WidgetData::GetPictureContent(CFX_WideString& wsPicture,
-                                           XFA_VALUEPICTURE ePicture) {
-  if (ePicture == XFA_VALUEPICTURE_Raw) {
-    return FALSE;
-  }
-  CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
-  switch (ePicture) {
-    case XFA_VALUEPICTURE_Display: {
-      if (CXFA_Node* pFormat = m_pNode->GetChild(0, XFA_ELEMENT_Format)) {
-        if (CXFA_Node* pPicture = pFormat->GetChild(0, XFA_ELEMENT_Picture)) {
-          if (pPicture->TryContent(wsPicture)) {
-            return TRUE;
-          }
-        }
-      }
-      CFX_WideString wsDataPicture, wsTimePicture;
-      IFX_Locale* pLocale = GetLocal();
-      if (!pLocale) {
-        return FALSE;
-      }
-      FX_DWORD dwType = widgetValue.GetType();
-      switch (dwType) {
-        case XFA_VT_DATE:
-          pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
-                                  wsPicture);
-          break;
-        case XFA_VT_TIME:
-          pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
-                                  wsPicture);
-          break;
-        case XFA_VT_DATETIME:
-          pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
-                                  wsDataPicture);
-          pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
-                                  wsTimePicture);
-          wsPicture = wsDataPicture + FX_WSTRC(L"T") + wsTimePicture;
-          break;
-        case XFA_VT_DECIMAL:
-        case XFA_VT_FLOAT:
-          break;
-        default:
-          break;
-      }
-    }
-      return TRUE;
-    case XFA_VALUEPICTURE_Edit: {
-      CXFA_Node* pUI = m_pNode->GetChild(0, XFA_ELEMENT_Ui);
-      if (pUI) {
-        if (CXFA_Node* pPicture = pUI->GetChild(0, XFA_ELEMENT_Picture)) {
-          if (pPicture->TryContent(wsPicture)) {
-            return TRUE;
-          }
-        }
-      }
-      {
-        CFX_WideString wsDataPicture, wsTimePicture;
-        IFX_Locale* pLocale = GetLocal();
-        if (!pLocale) {
-          return FALSE;
-        }
-        FX_DWORD dwType = widgetValue.GetType();
-        switch (dwType) {
-          case XFA_VT_DATE:
-            pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
-                                    wsPicture);
-            break;
-          case XFA_VT_TIME:
-            pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
-                                    wsPicture);
-            break;
-          case XFA_VT_DATETIME:
-            pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
-                                    wsDataPicture);
-            pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
-                                    wsTimePicture);
-            wsPicture = wsDataPicture + L"T" + wsTimePicture;
-            break;
-          default:
-            break;
-        }
-      }
-    }
-      return TRUE;
-    case XFA_VALUEPICTURE_DataBind: {
-      if (CXFA_Bind bind = GetBind()) {
-        bind.GetPicture(wsPicture);
-        return TRUE;
-      }
-    } break;
-    default:
-      break;
-  }
-  return FALSE;
-}
-IFX_Locale* CXFA_WidgetData::GetLocal() {
-  IFX_Locale* pLocale = NULL;
-  if (!m_pNode) {
-    return pLocale;
-  }
-  FX_BOOL bLocale = FALSE;
-  CFX_WideString wsLocaleName;
-  bLocale = m_pNode->GetLocaleName(wsLocaleName);
-  if (bLocale) {
-    if (wsLocaleName.Equal(FX_WSTRC(L"ambient"))) {
-      pLocale = m_pNode->GetDocument()->GetLocalMgr()->GetDefLocale();
-    } else {
-      pLocale =
-          m_pNode->GetDocument()->GetLocalMgr()->GetLocaleByName(wsLocaleName);
-    }
-  }
-  return pLocale;
-}
-static FX_BOOL XFA_SplitDateTime(const CFX_WideString& wsDateTime,
-                                 CFX_WideString& wsDate,
-                                 CFX_WideString& wsTime) {
-  wsDate = L"";
-  wsTime = L"";
-  if (wsDateTime.IsEmpty()) {
-    return FALSE;
-  }
-  int nSplitIndex = -1;
-  nSplitIndex = wsDateTime.Find('T');
-  if (nSplitIndex < 0) {
-    nSplitIndex = wsDateTime.Find(' ');
-  }
-  if (nSplitIndex < 0) {
-    return FALSE;
-  }
-  wsDate = wsDateTime.Left(nSplitIndex);
-  if (!wsDate.IsEmpty()) {
-    int32_t iCount = wsDate.GetLength();
-    int32_t i = 0;
-    for (i = 0; i < iCount; i++) {
-      if (wsDate[i] >= '0' && wsDate[i] <= '9') {
-        break;
-      }
-    }
-    if (i == iCount) {
-      return FALSE;
-    }
-  }
-  wsTime = wsDateTime.Right(wsDateTime.GetLength() - nSplitIndex - 1);
-  if (!wsTime.IsEmpty()) {
-    int32_t iCount = wsTime.GetLength();
-    int32_t i = 0;
-    for (i = 0; i < iCount; i++) {
-      if (wsTime[i] >= '0' && wsTime[i] <= '9') {
-        break;
-      }
-    }
-    if (i == iCount) {
-      return FALSE;
-    }
-  }
-  return TRUE;
-}
-
-FX_BOOL CXFA_WidgetData::GetValue(CFX_WideString& wsValue,
-                                  XFA_VALUEPICTURE eValueType) {
-  wsValue = m_pNode->GetContent();
-
-  if (eValueType == XFA_VALUEPICTURE_Display)
-    GetItemLabel(wsValue, wsValue);
-
-  CFX_WideString wsPicture;
-  GetPictureContent(wsPicture, eValueType);
-  CXFA_Node* pNode = GetUIChild();
-  if (!pNode)
-    return TRUE;
-
-  XFA_ELEMENT uiType = GetUIChild()->GetClassID();
-  switch (uiType) {
-    case XFA_ELEMENT_ChoiceList: {
-      if (eValueType == XFA_VALUEPICTURE_Display) {
-        int32_t iSelItemIndex = GetSelectedItem(0);
-        if (iSelItemIndex >= 0) {
-          GetChoiceListItem(wsValue, iSelItemIndex);
-          wsPicture.Empty();
-        }
-      }
-    } break;
-    case XFA_ELEMENT_NumericEdit:
-      if (eValueType != XFA_VALUEPICTURE_Raw && wsPicture.IsEmpty()) {
-        IFX_Locale* pLocale = GetLocal();
-        if (eValueType == XFA_VALUEPICTURE_Display && pLocale) {
-          CFX_WideString wsOutput;
-          NormalizeNumStr(wsValue, wsOutput);
-          FormatNumStr(wsOutput, pLocale, wsOutput);
-          wsValue = wsOutput;
-        }
-      }
-      break;
-    default:
-      break;
-  }
-  if (wsPicture.IsEmpty())
-    return TRUE;
-
-  if (IFX_Locale* pLocale = GetLocal()) {
-    CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
-    CXFA_LocaleMgr* pLocalMgr = m_pNode->GetDocument()->GetLocalMgr();
-    switch (widgetValue.GetType()) {
-      case XFA_VT_DATE: {
-        CFX_WideString wsDate, wsTime;
-        if (XFA_SplitDateTime(wsValue, wsDate, wsTime)) {
-          CXFA_LocaleValue date(XFA_VT_DATE, wsDate, pLocalMgr);
-          if (date.FormatPatterns(wsValue, wsPicture, pLocale, eValueType))
-            return TRUE;
-        }
-        break;
-      }
-      case XFA_VT_TIME: {
-        CFX_WideString wsDate, wsTime;
-        if (XFA_SplitDateTime(wsValue, wsDate, wsTime)) {
-          CXFA_LocaleValue time(XFA_VT_TIME, wsTime, pLocalMgr);
-          if (time.FormatPatterns(wsValue, wsPicture, pLocale, eValueType))
-            return TRUE;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    widgetValue.FormatPatterns(wsValue, wsPicture, pLocale, eValueType);
-  }
-  return TRUE;
-}
-
-FX_BOOL CXFA_WidgetData::GetNormalizeDataValue(
-    const CFX_WideStringC& wsValue,
-    CFX_WideString& wsNormalizeValue) {
-  wsNormalizeValue = wsValue;
-  if (wsValue.IsEmpty()) {
-    return TRUE;
-  }
-  CFX_WideString wsPicture;
-  GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
-  if (wsPicture.IsEmpty()) {
-    return TRUE;
-  }
-  FXSYS_assert(GetNode());
-  CXFA_LocaleMgr* pLocalMgr = GetNode()->GetDocument()->GetLocalMgr();
-  IFX_Locale* pLocale = GetLocal();
-  CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
-  if (widgetValue.ValidateValue(wsValue, wsPicture, pLocale, &wsPicture)) {
-    widgetValue = CXFA_LocaleValue(widgetValue.GetType(), wsNormalizeValue,
-                                   wsPicture, pLocale, pLocalMgr);
-    wsNormalizeValue = widgetValue.GetValue();
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_WidgetData::GetFormatDataValue(const CFX_WideStringC& wsValue,
-                                            CFX_WideString& wsFormatedValue) {
-  wsFormatedValue = wsValue;
-  if (wsValue.IsEmpty()) {
-    return TRUE;
-  }
-  CFX_WideString wsPicture;
-  GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
-  if (wsPicture.IsEmpty()) {
-    return TRUE;
-  }
-  if (IFX_Locale* pLocale = GetLocal()) {
-    FXSYS_assert(GetNode());
-    CXFA_Node* pNodeValue = GetNode()->GetChild(0, XFA_ELEMENT_Value);
-    if (!pNodeValue) {
-      return FALSE;
-    }
-    CXFA_Node* pValueChild = pNodeValue->GetNodeItem(XFA_NODEITEM_FirstChild);
-    if (!pValueChild) {
-      return FALSE;
-    }
-    int32_t iVTType = XFA_VT_NULL;
-    XFA_ELEMENT eType = pValueChild->GetClassID();
-    switch (eType) {
-      case XFA_ELEMENT_Decimal:
-        iVTType = XFA_VT_DECIMAL;
-        break;
-      case XFA_ELEMENT_Float:
-        iVTType = XFA_VT_FLOAT;
-        break;
-      case XFA_ELEMENT_Date:
-        iVTType = XFA_VT_DATE;
-        break;
-      case XFA_ELEMENT_Time:
-        iVTType = XFA_VT_TIME;
-        break;
-      case XFA_ELEMENT_DateTime:
-        iVTType = XFA_VT_DATETIME;
-        break;
-      case XFA_ELEMENT_Boolean:
-        iVTType = XFA_VT_BOOLEAN;
-        break;
-      case XFA_ELEMENT_Integer:
-        iVTType = XFA_VT_INTEGER;
-        break;
-      case XFA_ELEMENT_Text:
-        iVTType = XFA_VT_TEXT;
-        break;
-      default:
-        iVTType = XFA_VT_NULL;
-        break;
-    }
-    CXFA_LocaleMgr* pLocalMgr = GetNode()->GetDocument()->GetLocalMgr();
-    CXFA_LocaleValue widgetValue(iVTType, wsValue, pLocalMgr);
-    switch (widgetValue.GetType()) {
-      case XFA_VT_DATE: {
-        CFX_WideString wsDate, wsTime;
-        if (XFA_SplitDateTime(wsValue, wsDate, wsTime)) {
-          CXFA_LocaleValue date(XFA_VT_DATE, wsDate, pLocalMgr);
-          if (date.FormatPatterns(wsFormatedValue, wsPicture, pLocale,
-                                  XFA_VALUEPICTURE_DataBind)) {
-            return TRUE;
-          }
-        }
-        break;
-      }
-      case XFA_VT_TIME: {
-        CFX_WideString wsDate, wsTime;
-        if (XFA_SplitDateTime(wsValue, wsDate, wsTime)) {
-          CXFA_LocaleValue time(XFA_VT_TIME, wsTime, pLocalMgr);
-          if (time.FormatPatterns(wsFormatedValue, wsPicture, pLocale,
-                                  XFA_VALUEPICTURE_DataBind)) {
-            return TRUE;
-          }
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    widgetValue.FormatPatterns(wsFormatedValue, wsPicture, pLocale,
-                               XFA_VALUEPICTURE_DataBind);
-  }
-  return FALSE;
-}
-void CXFA_WidgetData::NormalizeNumStr(const CFX_WideString& wsValue,
-                                      CFX_WideString& wsOutput) {
-  if (wsValue.IsEmpty()) {
-    return;
-  }
-  wsOutput = wsValue;
-  wsOutput.TrimLeft('0');
-  int32_t dot_index = wsOutput.Find('.');
-  int32_t iFracDigits = 0;
-  if (!wsOutput.IsEmpty() && dot_index >= 0 &&
-      (!GetFracDigits(iFracDigits) || iFracDigits != -1)) {
-    wsOutput.TrimRight(L"0");
-    wsOutput.TrimRight(L".");
-  }
-  if (wsOutput.IsEmpty() || wsOutput[0] == '.') {
-    wsOutput.Insert(0, '0');
-  }
-}
-void CXFA_WidgetData::FormatNumStr(const CFX_WideString& wsValue,
-                                   IFX_Locale* pLocale,
-                                   CFX_WideString& wsOutput) {
-  if (wsValue.IsEmpty()) {
-    return;
-  }
-  CFX_WideString wsSrcNum = wsValue;
-  CFX_WideString wsGroupSymbol;
-  pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Grouping, wsGroupSymbol);
-  FX_BOOL bNeg = FALSE;
-  if (wsSrcNum[0] == '-') {
-    bNeg = TRUE;
-    wsSrcNum.Delete(0, 1);
-  }
-  int32_t len = wsSrcNum.GetLength();
-  int32_t dot_index = wsSrcNum.Find('.');
-  if (dot_index == -1) {
-    dot_index = len;
-  }
-  int32_t cc = dot_index - 1;
-  if (cc >= 0) {
-    int nPos = dot_index % 3;
-    wsOutput.Empty();
-    for (int32_t i = 0; i < dot_index; i++) {
-      if (i % 3 == nPos && i != 0) {
-        wsOutput += wsGroupSymbol;
-      }
-      wsOutput += wsSrcNum[i];
-    }
-    if (dot_index < len) {
-      CFX_WideString wsSymbol;
-      pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Decimal, wsSymbol);
-      wsOutput += wsSymbol;
-      wsOutput += wsSrcNum.Right(len - dot_index - 1);
-    }
-    if (bNeg) {
-      CFX_WideString wsMinusymbol;
-      pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinusymbol);
-      wsOutput = wsMinusymbol + wsOutput;
-    }
-  }
-}
-void CXFA_WidgetData::SyncValue(const CFX_WideString& wsValue,
-                                FX_BOOL bNotify) {
-  if (!m_pNode) {
-    return;
-  }
-  CFX_WideString wsFormatValue(wsValue);
-  CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();
-  if (pContainerWidgetData) {
-    pContainerWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
-  }
-  m_pNode->SetContent(wsValue, wsFormatValue, bNotify);
-}
-void CXFA_WidgetData::InsertListTextItem(CXFA_Node* pItems,
-                                         const CFX_WideStringC& wsText,
-                                         int32_t nIndex) {
-  CXFA_Node* pText = pItems->CreateSamePacketNode(XFA_ELEMENT_Text);
-  pItems->InsertChild(nIndex, pText);
-  pText->SetContent(wsText, wsText, FALSE, FALSE, FALSE);
-}
-CXFA_Filter CXFA_WidgetData::GetFilter(FX_BOOL bModified) {
-  if (!m_pUiChildNode) {
-    return CXFA_Filter(nullptr);
-  }
-  return CXFA_Filter(
-      m_pUiChildNode->GetProperty(0, XFA_ELEMENT_Filter, bModified));
-}
-CXFA_Manifest CXFA_WidgetData::GetManifest(FX_BOOL bModified) {
-  if (!m_pUiChildNode) {
-    return CXFA_Manifest(nullptr);
-  }
-  return CXFA_Manifest(
-      m_pUiChildNode->GetProperty(0, XFA_ELEMENT_Manifest, bModified));
-}
-CXFA_Occur::CXFA_Occur(CXFA_Node* pNode) : CXFA_Data(pNode) {}
-int32_t CXFA_Occur::GetMax() {
-  int32_t iMax = 1;
-  if (m_pNode) {
-    if (!m_pNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, TRUE)) {
-      iMax = GetMin();
-    }
-  }
-  return iMax;
-}
-int32_t CXFA_Occur::GetMin() {
-  int32_t iMin = 1;
-  if (m_pNode) {
-    if (!m_pNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, TRUE) || iMin < 0) {
-      iMin = 1;
-    }
-  }
-  return iMin;
-}
-int32_t CXFA_Occur::GetInitial() {
-  int32_t iInit = 1;
-  if (m_pNode) {
-    int32_t iMin = GetMin();
-    if (!m_pNode->TryInteger(XFA_ATTRIBUTE_Initial, iInit, TRUE) ||
-        iInit < iMin) {
-      iInit = iMin;
-    }
-  }
-  return iInit;
-}
-FX_BOOL CXFA_Occur::GetOccurInfo(int32_t& iMin, int32_t& iMax, int32_t& iInit) {
-  if (!m_pNode) {
-    return FALSE;
-  }
-  if (!m_pNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE) || iMin < 0) {
-    iMin = 1;
-  }
-  if (!m_pNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) {
-    if (iMin == 0) {
-      iMax = 1;
-    } else {
-      iMax = iMin;
-    }
-  }
-  if (!m_pNode->TryInteger(XFA_ATTRIBUTE_Initial, iInit, FALSE) ||
-      iInit < iMin) {
-    iInit = iMin;
-  }
-  return TRUE;
-}
-void CXFA_Occur::SetMax(int32_t iMax) {
-  iMax = (iMax != -1 && iMax < 1) ? 1 : iMax;
-  m_pNode->SetInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
-  int32_t iMin = GetMin();
-  if (iMax != -1 && iMax < iMin) {
-    iMin = iMax;
-    m_pNode->SetInteger(XFA_ATTRIBUTE_Min, iMin, FALSE);
-  }
-}
-void CXFA_Occur::SetMin(int32_t iMin) {
-  iMin = (iMin < 0) ? 1 : iMin;
-  m_pNode->SetInteger(XFA_ATTRIBUTE_Min, iMin, FALSE);
-  int32_t iMax = GetMax();
-  if (iMax > 0 && iMax < iMin) {
-    iMax = iMin;
-    m_pNode->SetInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
-  }
-}
-XFA_ATTRIBUTEENUM XFA_GetEnumTypeAttribute(
-    CXFA_Node* pNode,
-    XFA_ATTRIBUTE attributeValue = XFA_ATTRIBUTE_Type,
-    XFA_ATTRIBUTEENUM eDefaultValue = XFA_ATTRIBUTEENUM_Optional) {
-  XFA_ATTRIBUTEENUM eType = eDefaultValue;
-  if (pNode) {
-    if (!pNode->TryEnum(attributeValue, eType, TRUE)) {
-      eType = eDefaultValue;
-    }
-  }
-  return eType;
-}
-CFX_WideString CXFA_Filter::GetFilterString(XFA_ATTRIBUTE eAttribute) {
-  CFX_WideString wsStringValue;
-  if (m_pNode) {
-    m_pNode->GetAttribute(eAttribute, wsStringValue, FALSE);
-  }
-  return wsStringValue;
-}
-XFA_ATTRIBUTEENUM CXFA_Filter::GetAppearanceFilterType() {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Optional;
-  }
-  CXFA_Node* pAppearanceFilterNode =
-      m_pNode->GetProperty(0, XFA_ELEMENT_AppearanceFilter);
-  return XFA_GetEnumTypeAttribute(pAppearanceFilterNode);
-}
-CFX_WideString CXFA_Filter::GetAppearanceFilterContent() {
-  CFX_WideString wsContent;
-  if (m_pNode) {
-    CXFA_Node* pAppearanceFilterNode =
-        m_pNode->GetProperty(0, XFA_ELEMENT_AppearanceFilter);
-    pAppearanceFilterNode->TryContent(wsContent);
-  }
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_Filter::GetCertificatesCredentialServerPolicy() {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Optional;
-  }
-  CXFA_Node* pCertsNode = m_pNode->GetProperty(0, XFA_ELEMENT_Certificates);
-  return XFA_GetEnumTypeAttribute(pCertsNode,
-                                  XFA_ATTRIBUTE_CredentialServerPolicy);
-}
-CFX_WideString CXFA_Filter::GetCertificatesURL() {
-  CFX_WideString wsURL;
-  if (m_pNode) {
-    CXFA_Node* pCertsNode = m_pNode->GetProperty(0, XFA_ELEMENT_Certificates);
-    pCertsNode->GetAttribute(XFA_ATTRIBUTE_Url, wsURL, FALSE);
-  }
-  return wsURL;
-}
-CFX_WideString CXFA_Filter::GetCertificatesURLPolicy() {
-  CFX_WideString wsURLPolicy;
-  if (m_pNode) {
-    CXFA_Node* pCertsNode = m_pNode->GetProperty(0, XFA_ELEMENT_Certificates);
-    pCertsNode->GetAttribute(XFA_ATTRIBUTE_UrlPolicy, wsURLPolicy, FALSE);
-  }
-  return wsURLPolicy;
-}
-CXFA_WrapCertificate CXFA_Filter::GetCertificatesEncryption(FX_BOOL bModified) {
-  if (!m_pNode) {
-    return CXFA_WrapCertificate(NULL);
-  }
-  CXFA_Node* pCertsNode =
-      m_pNode->GetProperty(0, XFA_ELEMENT_Certificates, bModified);
-  return CXFA_WrapCertificate(
-      pCertsNode ? pCertsNode->GetProperty(0, XFA_ELEMENT_Encryption, bModified)
-                 : NULL);
-}
-CXFA_WrapCertificate CXFA_Filter::GetCertificatesIssuers(FX_BOOL bModified) {
-  if (!m_pNode) {
-    return CXFA_WrapCertificate(NULL);
-  }
-  CXFA_Node* pCertsNode =
-      m_pNode->GetProperty(0, XFA_ELEMENT_Certificates, bModified);
-  return CXFA_WrapCertificate(
-      pCertsNode ? pCertsNode->GetProperty(0, XFA_ELEMENT_Issuers, bModified)
-                 : NULL);
-}
-CFX_WideString CXFA_Filter::GetCertificatesKeyUsageString(
-    XFA_ATTRIBUTE eAttribute) {
-  if (!m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pCertsNode = m_pNode->GetProperty(0, XFA_ELEMENT_Certificates);
-  CXFA_Node* pKeyUsageNode = pCertsNode->GetProperty(0, XFA_ELEMENT_KeyUsage);
-  CFX_WideString wsAttributeValue;
-  pKeyUsageNode->GetAttribute(eAttribute, wsAttributeValue, FALSE);
-  return wsAttributeValue;
-}
-CXFA_Oids CXFA_Filter::GetCertificatesOids() {
-  if (!m_pNode) {
-    return CXFA_Oids(NULL);
-  }
-  CXFA_Node* pCertsNode = m_pNode->GetProperty(0, XFA_ELEMENT_Certificates);
-  return CXFA_Oids(pCertsNode ? pCertsNode->GetProperty(0, XFA_ELEMENT_Oids)
-                              : NULL);
-}
-CXFA_WrapCertificate CXFA_Filter::GetCertificatesSigning(FX_BOOL bModified) {
-  if (!m_pNode) {
-    return CXFA_WrapCertificate(NULL);
-  }
-  CXFA_Node* pCertsNode =
-      m_pNode->GetProperty(0, XFA_ELEMENT_Certificates, bModified);
-  return CXFA_WrapCertificate(
-      pCertsNode ? pCertsNode->GetProperty(0, XFA_ELEMENT_Signing, bModified)
-                 : NULL);
-}
-CXFA_DigestMethods CXFA_Filter::GetDigestMethods(FX_BOOL bModified) {
-  return CXFA_DigestMethods(
-      m_pNode ? m_pNode->GetProperty(0, XFA_ELEMENT_DigestMethods, bModified)
-              : NULL);
-}
-CXFA_Encodings CXFA_Filter::GetEncodings(FX_BOOL bModified) {
-  return CXFA_Encodings(
-      m_pNode ? m_pNode->GetProperty(0, XFA_ELEMENT_Encodings, bModified)
-              : NULL);
-}
-CXFA_EncryptionMethods CXFA_Filter::GetEncryptionMethods(FX_BOOL bModified) {
-  return CXFA_EncryptionMethods(
-      m_pNode
-          ? m_pNode->GetProperty(0, XFA_ELEMENT_EncryptionMethods, bModified)
-          : NULL);
-}
-XFA_ATTRIBUTEENUM CXFA_Filter::GetHandlerType() {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Optional;
-  }
-  CXFA_Node* pHandlerNode = m_pNode->GetProperty(0, XFA_ELEMENT_Handler);
-  return XFA_GetEnumTypeAttribute(pHandlerNode);
-}
-CFX_WideString CXFA_Filter::GetHandlerContent() {
-  CFX_WideString wsContent;
-  if (m_pNode) {
-    CXFA_Node* pHandlerNode = m_pNode->GetProperty(0, XFA_ELEMENT_Handler);
-    pHandlerNode->TryContent(wsContent);
-  }
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_Filter::GetlockDocumentType() {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Optional;
-  }
-  CXFA_Node* pLockDocNode = m_pNode->GetProperty(0, XFA_ELEMENT_LockDocument);
-  return XFA_GetEnumTypeAttribute(pLockDocNode);
-}
-CFX_WideString CXFA_Filter::GetlockDocumentContent() {
-  CFX_WideString wsContent = FX_WSTRC(L"auto");
-  if (m_pNode) {
-    CXFA_Node* pLockDocNode = m_pNode->GetProperty(0, XFA_ELEMENT_LockDocument);
-    pLockDocNode->TryContent(wsContent);
-  }
-  return wsContent;
-}
-int32_t CXFA_Filter::GetMDPPermissions() {
-  int32_t iPermissions = 2;
-  if (m_pNode) {
-    CXFA_Node* pMDPNode = m_pNode->GetProperty(0, XFA_ELEMENT_Mdp);
-    if (!pMDPNode->TryInteger(XFA_ATTRIBUTE_Permissions, iPermissions, TRUE)) {
-      iPermissions = 2;
-    }
-  }
-  return iPermissions;
-}
-XFA_ATTRIBUTEENUM CXFA_Filter::GetMDPSignatureType() {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Filter;
-  }
-  CXFA_Node* pMDPNode = m_pNode->GetProperty(0, XFA_ELEMENT_Mdp);
-  return XFA_GetEnumTypeAttribute(pMDPNode, XFA_ATTRIBUTE_SignatureType,
-                                  XFA_ATTRIBUTEENUM_Filter);
-}
-CXFA_Reasons CXFA_Filter::GetReasons(FX_BOOL bModified) {
-  return CXFA_Reasons(m_pNode ? m_pNode->GetProperty(0, XFA_ELEMENT_Reasons)
-                              : NULL);
-}
-CFX_WideString CXFA_Filter::GetTimeStampServer() {
-  CFX_WideString wsServerURI;
-  if (m_pNode) {
-    CXFA_Node* pTimeStampNode = m_pNode->GetProperty(0, XFA_ELEMENT_TimeStamp);
-    pTimeStampNode->GetAttribute(XFA_ATTRIBUTE_Server, wsServerURI, FALSE);
-  }
-  return wsServerURI;
-}
-XFA_ATTRIBUTEENUM CXFA_Filter::GetTimeStampType() {
-  if (!m_pNode) {
-    return XFA_ATTRIBUTEENUM_Optional;
-  }
-  CXFA_Node* pTimeStampNode = m_pNode->GetProperty(0, XFA_ELEMENT_TimeStamp);
-  return XFA_GetEnumTypeAttribute(pTimeStampNode);
-}
-CFX_WideString CXFA_Certificate::GetCertificateName() {
-  CFX_WideString wsName;
-  if (m_pNode) {
-    m_pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
-  }
-  return wsName;
-}
-CFX_WideString CXFA_Certificate::GetCertificateContent() {
-  CFX_WideString wsContent;
-  if (m_pNode) {
-    m_pNode->TryContent(wsContent);
-  }
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_WrapCertificate::GetType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_WrapCertificate::CountCertificates() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_Certificate) : 0;
-}
-CXFA_Certificate CXFA_WrapCertificate::GetCertificate(int32_t nIndex) {
-  return CXFA_Certificate(
-      (nIndex > -1 && m_pNode)
-          ? m_pNode->GetChild(nIndex, XFA_ELEMENT_Certificate)
-          : NULL);
-}
-XFA_ATTRIBUTEENUM CXFA_Oids::GetOidsType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_Oids::CountOids() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_Oid) : 0;
-}
-CFX_WideString CXFA_Oids::GetOidContent(int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pOidNode = m_pNode->GetChild(nIndex, XFA_ELEMENT_Oid);
-  if (!pOidNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pOidNode->TryContent(wsContent);
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_SubjectDNs::GetSubjectDNsType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_SubjectDNs::CountSubjectDNs() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_SubjectDN) : 0;
-}
-CFX_WideString CXFA_SubjectDNs::GetSubjectDNString(int32_t nIndex,
-                                                   XFA_ATTRIBUTE eAttribute) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pSubjectDNNode = m_pNode->GetChild(nIndex, XFA_ELEMENT_SubjectDN);
-  if (!pSubjectDNNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsAttributeValue;
-  pSubjectDNNode->GetAttribute(eAttribute, wsAttributeValue, FALSE);
-  return wsAttributeValue;
-}
-CFX_WideString CXFA_SubjectDNs::GetSubjectDNContent(int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pSubjectDNNode = m_pNode->GetChild(nIndex, XFA_ELEMENT_SubjectDN);
-  if (!pSubjectDNNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pSubjectDNNode->TryContent(wsContent);
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_DigestMethods::GetDigestMethodsType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_DigestMethods::CountDigestMethods() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_DigestMethod) : 0;
-}
-CFX_WideString CXFA_DigestMethods::GetDigestMethodContent(int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pDigestMethodNode =
-      m_pNode->GetChild(nIndex, XFA_ELEMENT_DigestMethod);
-  if (!pDigestMethodNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pDigestMethodNode->TryContent(wsContent);
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_Encodings::GetEncodingsType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_Encodings::CountEncodings() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_Encoding) : 0;
-}
-CFX_WideString CXFA_Encodings::GetEncodingContent(int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pEncodingNode = m_pNode->GetChild(nIndex, XFA_ELEMENT_Encoding);
-  if (!pEncodingNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pEncodingNode->TryContent(wsContent);
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_EncryptionMethods::GetEncryptionMethodsType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_EncryptionMethods::CountEncryptionMethods() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_EncryptionMethod) : 0;
-}
-CFX_WideString CXFA_EncryptionMethods::GetEncryptionMethodContent(
-    int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pEncryMethodNode =
-      m_pNode->GetChild(nIndex, XFA_ELEMENT_EncryptionMethod);
-  if (!pEncryMethodNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pEncryMethodNode->TryContent(wsContent);
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_Reasons::GetReasonsType() {
-  return XFA_GetEnumTypeAttribute(m_pNode);
-}
-int32_t CXFA_Reasons::CountReasons() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_Reason) : 0;
-}
-CFX_WideString CXFA_Reasons::GetReasonContent(int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pReasonNode = m_pNode->GetChild(nIndex, XFA_ELEMENT_Reason);
-  if (!pReasonNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pReasonNode->TryContent(wsContent);
-  return wsContent;
-}
-XFA_ATTRIBUTEENUM CXFA_Manifest::GetAction() {
-  return XFA_GetEnumTypeAttribute(m_pNode, XFA_ATTRIBUTE_Action,
-                                  XFA_ATTRIBUTEENUM_Include);
-}
-int32_t CXFA_Manifest::CountReives() {
-  return m_pNode ? m_pNode->CountChildren(XFA_ELEMENT_Ref) : 0;
-}
-CFX_WideString CXFA_Manifest::GetRefContent(int32_t nIndex) {
-  if (nIndex <= -1 || !m_pNode) {
-    return FX_WSTRC(L"");
-  }
-  CXFA_Node* pRefNode = m_pNode->GetChild(nIndex, XFA_ELEMENT_Ref);
-  if (!pRefNode) {
-    return FX_WSTRC(L"");
-  }
-  CFX_WideString wsContent;
-  pRefNode->TryContent(wsContent);
-  return wsContent;
-}
diff --git a/xfa/src/fxfa/parser/xfa_parser.h b/xfa/src/fxfa/parser/xfa_parser.h
deleted file mode 100644
index 814228177c..0000000000
--- a/xfa/src/fxfa/parser/xfa_parser.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_PARSER_H_
-#define XFA_SRC_FXFA_PARSER_XFA_PARSER_H_
-
-#include "xfa/src/fxfa/parser/xfa_document.h"
-
-class IXFA_Parser {
- public:
-  static IXFA_Parser* Create(IXFA_ObjFactory* pFactory,
-                             FX_BOOL bDocumentParser = FALSE);
-  virtual ~IXFA_Parser() {}
-  virtual void Release() = 0;
-  virtual int32_t StartParse(IFX_FileRead* pStream,
-                             XFA_XDPPACKET ePacketID = XFA_XDPPACKET_XDP) = 0;
-  virtual int32_t DoParse(IFX_Pause* pPause = NULL) = 0;
-  virtual int32_t ParseXMLData(const CFX_WideString& wsXML,
-                               IFDE_XMLNode*& pXMLNode,
-                               IFX_Pause* pPause = NULL) = 0;
-  virtual void ConstructXFANode(CXFA_Node* pXFANode,
-                                IFDE_XMLNode* pXMLNode) = 0;
-  virtual IXFA_ObjFactory* GetFactory() const = 0;
-  virtual CXFA_Node* GetRootNode() const = 0;
-  virtual IFDE_XMLDoc* GetXMLDoc() const = 0;
-  virtual void CloseParser() = 0;
-};
-class IXFA_DocParser : public IXFA_Parser {
- public:
-  static IXFA_DocParser* Create(IXFA_Notify* pNotify);
-  virtual CXFA_Document* GetDocument() const = 0;
-  virtual IXFA_Notify* GetNotify() const = 0;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_PARSER_H_
diff --git a/xfa/src/fxfa/parser/xfa_parser_imp.cpp b/xfa/src/fxfa/parser/xfa_parser_imp.cpp
deleted file mode 100644
index a3d4f94089..0000000000
--- a/xfa/src/fxfa/parser/xfa_parser_imp.cpp
+++ /dev/null
@@ -1,1568 +0,0 @@
-// 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/src/fxfa/parser/xfa_parser_imp.h"
-
-#include "xfa/src/fgas/crt/fgas_codepage.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-IXFA_Parser* IXFA_Parser::Create(IXFA_ObjFactory* pFactory,
-                                 FX_BOOL bDocumentParser) {
-  return new CXFA_SimpleParser(pFactory, bDocumentParser);
-}
-CXFA_SimpleParser::CXFA_SimpleParser(IXFA_ObjFactory* pFactory,
-                                     FX_BOOL bDocumentParser)
-    : m_pXMLParser(nullptr),
-      m_pXMLDoc(nullptr),
-      m_pStream(nullptr),
-      m_pFileRead(nullptr),
-      m_pFactory(pFactory),
-      m_pRootNode(nullptr),
-      m_ePacketID(XFA_XDPPACKET_UNKNOWN),
-      m_bDocumentParser(bDocumentParser) {}
-CXFA_SimpleParser::~CXFA_SimpleParser() {
-  CloseParser();
-}
-void CXFA_SimpleParser::SetFactory(IXFA_ObjFactory* pFactory) {
-  m_pFactory = pFactory;
-}
-static IFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(
-    IFDE_XMLDoc* pXMLDoc,
-    FX_BOOL bVerifyWellFormness = FALSE) {
-  if (!pXMLDoc) {
-    return NULL;
-  }
-  IFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot();
-  for (IFDE_XMLNode* pXMLNode =
-           pXMLFakeRoot->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLNode; pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      if (bVerifyWellFormness) {
-        for (IFDE_XMLNode* pNextNode =
-                 pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling);
-             pNextNode;
-             pNextNode = pNextNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-          if (pNextNode->GetType() == FDE_XMLNODE_Element) {
-            return FALSE;
-          }
-        }
-      }
-      return pXMLNode;
-    }
-  }
-  return NULL;
-}
-int32_t CXFA_SimpleParser::StartParse(IFX_FileRead* pStream,
-                                      XFA_XDPPACKET ePacketID) {
-  CloseParser();
-  m_pFileRead = pStream;
-  m_pStream = IFX_Stream::CreateStream(
-      pStream, FX_STREAMACCESS_Read | FX_STREAMACCESS_Text);
-  if (m_pStream == NULL) {
-    return XFA_PARSESTATUS_StreamErr;
-  }
-  FX_WORD wCodePage = m_pStream->GetCodePage();
-  if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
-      wCodePage != FX_CODEPAGE_UTF8) {
-    m_pStream->SetCodePage(FX_CODEPAGE_UTF8);
-  }
-  m_pXMLDoc = IFDE_XMLDoc::Create();
-  if (m_pXMLDoc == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  m_pXMLParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
-  if (m_pXMLParser == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  if (!m_pXMLDoc->LoadXML(m_pXMLParser)) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  m_ePacketID = ePacketID;
-  return XFA_PARSESTATUS_Ready;
-}
-int32_t CXFA_SimpleParser::DoParse(IFX_Pause* pPause) {
-  if (m_pXMLDoc == NULL || m_ePacketID == XFA_XDPPACKET_UNKNOWN) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  int32_t iRet = m_pXMLDoc->DoLoad(pPause);
-  if (iRet < 0) {
-    return XFA_PARSESTATUS_SyntaxErr;
-  }
-  if (iRet < 100) {
-    return iRet / 2;
-  }
-  m_pRootNode = ParseAsXDPPacket(XFA_FDEExtension_GetDocumentNode(m_pXMLDoc),
-                                 m_ePacketID);
-  m_pXMLDoc->CloseXML();
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = NULL;
-  }
-  if (!m_pRootNode) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  return XFA_PARSESTATUS_Done;
-}
-int32_t CXFA_SimpleParser::ParseXMLData(const CFX_WideString& wsXML,
-                                        IFDE_XMLNode*& pXMLNode,
-                                        IFX_Pause* pPause) {
-  CloseParser();
-  pXMLNode = NULL;
-  IFX_Stream* pStream = XFA_CreateWideTextRead(wsXML);
-  if (!pStream) {
-    return XFA_PARSESTATUS_StreamErr;
-  }
-  m_pStream = pStream;
-  m_pXMLDoc = IFDE_XMLDoc::Create();
-  if (m_pXMLDoc == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  CXFA_XMLParser* pParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
-  if (pParser == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-
-  pParser->m_dwCheckStatus = 0x03;
-  if (!m_pXMLDoc->LoadXML(pParser)) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-  int32_t iRet = m_pXMLDoc->DoLoad(pPause);
-  if (iRet < 0 || iRet >= 100) {
-    m_pXMLDoc->CloseXML();
-  }
-  if (iRet < 0) {
-    return XFA_PARSESTATUS_SyntaxErr;
-  }
-  if (iRet < 100) {
-    return iRet / 2;
-  }
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = NULL;
-  }
-  pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc);
-  return XFA_PARSESTATUS_Done;
-}
-
-void CXFA_SimpleParser::ConstructXFANode(CXFA_Node* pXFANode,
-                                         IFDE_XMLNode* pXMLNode) {
-  XFA_XDPPACKET ePacketID = (XFA_XDPPACKET)pXFANode->GetPacketID();
-  if (ePacketID == XFA_XDPPACKET_Datasets) {
-    if (pXFANode->GetClassID() == XFA_ELEMENT_DataValue) {
-      for (IFDE_XMLNode* pXMLChild =
-               pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-           pXMLChild;
-           pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-        FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
-        if (eNodeType == FDE_XMLNODE_Instruction)
-          continue;
-
-        if (eNodeType == FDE_XMLNODE_Element) {
-          CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
-                                                        XFA_ELEMENT_DataValue);
-          if (!pXFAChild)
-            return;
-
-          CFX_WideString wsNodeStr;
-          ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr);
-          pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
-          CFX_WideString wsChildValue;
-          XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild,
-                                       wsChildValue);
-          if (!wsChildValue.IsEmpty())
-            pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsChildValue);
-
-          pXFANode->InsertChild(pXFAChild);
-          pXFAChild->SetXMLMappingNode(pXMLChild);
-          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-          break;
-        }
-      }
-      m_pRootNode = pXFANode;
-    } else {
-      m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
-    }
-  } else if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
-    ParseContentNode(pXFANode, pXMLNode, ePacketID);
-    m_pRootNode = pXFANode;
-  } else {
-    m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID);
-  }
-}
-
-FX_BOOL XFA_FDEExtension_ResolveNamespaceQualifier(
-    IFDE_XMLElement* pNode,
-    const CFX_WideStringC& wsQualifier,
-    CFX_WideString& wsNamespaceURI) {
-  if (!pNode) {
-    return FALSE;
-  }
-  IFDE_XMLNode* pFakeRoot = pNode->GetNodeItem(IFDE_XMLNode::Root);
-  CFX_WideString wsNSAttribute;
-  FX_BOOL bRet = FALSE;
-  if (wsQualifier.IsEmpty()) {
-    wsNSAttribute = FX_WSTRC(L"xmlns");
-    bRet = TRUE;
-  } else {
-    wsNSAttribute = FX_WSTRC(L"xmlns:") + wsQualifier;
-  }
-  for (; pNode != pFakeRoot;
-       pNode = (IFDE_XMLElement*)pNode->GetNodeItem(IFDE_XMLNode::Parent)) {
-    if (pNode->GetType() != FDE_XMLNODE_Element) {
-      continue;
-    }
-    if (pNode->HasAttribute(wsNSAttribute)) {
-      pNode->GetString(wsNSAttribute, wsNamespaceURI);
-      return TRUE;
-    }
-  }
-  wsNamespaceURI.Empty();
-  return bRet;
-}
-static inline void XFA_FDEExtension_GetElementTagNamespaceURI(
-    IFDE_XMLElement* pElement,
-    CFX_WideString& wsNamespaceURI) {
-  CFX_WideString wsNodeStr;
-  pElement->GetNamespacePrefix(wsNodeStr);
-  if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNodeStr,
-                                                  wsNamespaceURI)) {
-    wsNamespaceURI.Empty();
-  }
-}
-static FX_BOOL XFA_FDEExtension_MatchNodeName(
-    IFDE_XMLNode* pNode,
-    const CFX_WideStringC& wsLocalTagName,
-    const CFX_WideStringC& wsNamespaceURIPrefix,
-    FX_DWORD eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH) {
-  if (!pNode || pNode->GetType() != FDE_XMLNODE_Element) {
-    return FALSE;
-  }
-  IFDE_XMLElement* pElement = reinterpret_cast<IFDE_XMLElement*>(pNode);
-  CFX_WideString wsNodeStr;
-  pElement->GetLocalTagName(wsNodeStr);
-  if (wsNodeStr != wsLocalTagName) {
-    return FALSE;
-  }
-  XFA_FDEExtension_GetElementTagNamespaceURI(pElement, wsNodeStr);
-  if (eMatchFlags & XFA_XDPPACKET_FLAGS_NOMATCH) {
-    return TRUE;
-  }
-  if (eMatchFlags & XFA_XDPPACKET_FLAGS_PREFIXMATCH) {
-    return wsNodeStr.Left(wsNamespaceURIPrefix.GetLength()) ==
-           wsNamespaceURIPrefix;
-  }
-  return wsNodeStr == wsNamespaceURIPrefix;
-}
-static FX_BOOL XFA_FDEExtension_GetAttributeLocalName(
-    const CFX_WideStringC& wsAttributeName,
-    CFX_WideString& wsLocalAttrName) {
-  CFX_WideString wsAttrName(wsAttributeName);
-  FX_STRSIZE iFind = wsAttrName.Find(L':', 0);
-  if (iFind < 0) {
-    wsLocalAttrName = wsAttrName;
-    return FALSE;
-  } else {
-    wsLocalAttrName = wsAttrName.Right(wsAttrName.GetLength() - iFind - 1);
-    return TRUE;
-  }
-}
-static FX_BOOL XFA_FDEExtension_ResolveAttribute(
-    IFDE_XMLElement* pElement,
-    const CFX_WideStringC& wsAttributeName,
-    CFX_WideString& wsLocalAttrName,
-    CFX_WideString& wsNamespaceURI) {
-  CFX_WideString wsAttrName(wsAttributeName);
-  CFX_WideString wsNSPrefix;
-  if (XFA_FDEExtension_GetAttributeLocalName(wsAttributeName,
-                                             wsLocalAttrName)) {
-    wsNSPrefix = wsAttrName.Left(wsAttributeName.GetLength() -
-                                 wsLocalAttrName.GetLength() - 1);
-  }
-  if (wsLocalAttrName == FX_WSTRC(L"xmlns") ||
-      wsNSPrefix == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xml")) {
-    return FALSE;
-  }
-  if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix,
-                                                  wsNamespaceURI)) {
-    wsNamespaceURI.Empty();
-    return FALSE;
-  }
-  return TRUE;
-}
-static FX_BOOL XFA_FDEExtension_FindAttributeWithNS(
-    IFDE_XMLElement* pElement,
-    const CFX_WideStringC& wsLocalAttributeName,
-    const CFX_WideStringC& wsNamespaceURIPrefix,
-    CFX_WideString& wsValue,
-    FX_BOOL bMatchNSAsPrefix = FALSE) {
-  if (!pElement) {
-    return FALSE;
-  }
-  CFX_WideString wsAttrName;
-  CFX_WideString wsAttrValue;
-  CFX_WideString wsAttrNS;
-  for (int32_t iAttrCount = pElement->CountAttributes(), i = 0; i < iAttrCount;
-       i++) {
-    pElement->GetAttribute(i, wsAttrName, wsAttrValue);
-    FX_STRSIZE iFind = wsAttrName.Find(L':', 0);
-    CFX_WideString wsNSPrefix;
-    if (iFind < 0) {
-      if (wsLocalAttributeName != wsAttrName) {
-        continue;
-      }
-    } else {
-      if (wsLocalAttributeName !=
-          wsAttrName.Right(wsAttrName.GetLength() - iFind - 1)) {
-        continue;
-      }
-      wsNSPrefix = wsAttrName.Left(iFind);
-    }
-    if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix,
-                                                    wsAttrNS)) {
-      continue;
-    }
-    if (bMatchNSAsPrefix) {
-      if (wsAttrNS.Left(wsNamespaceURIPrefix.GetLength()) !=
-          wsNamespaceURIPrefix) {
-        continue;
-      }
-    } else {
-      if (wsAttrNS != wsNamespaceURIPrefix) {
-        continue;
-      }
-    }
-    wsValue = wsAttrValue;
-    return TRUE;
-  }
-  return FALSE;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(IFDE_XMLNode* pXMLDocumentNode,
-                                               XFA_XDPPACKET ePacketID) {
-  switch (ePacketID) {
-    case XFA_XDPPACKET_UNKNOWN:
-      return NULL;
-    case XFA_XDPPACKET_XDP:
-      return ParseAsXDPPacket_XDP(pXMLDocumentNode, ePacketID);
-    case XFA_XDPPACKET_Config:
-      return ParseAsXDPPacket_Config(pXMLDocumentNode, ePacketID);
-    case XFA_XDPPACKET_Template:
-    case XFA_XDPPACKET_Form:
-      return ParseAsXDPPacket_TemplateForm(pXMLDocumentNode, ePacketID);
-    case XFA_XDPPACKET_Datasets:
-      return ParseAsXDPPacket_Data(pXMLDocumentNode, ePacketID);
-    case XFA_XDPPACKET_Xdc:
-      return ParseAsXDPPacket_Xdc(pXMLDocumentNode, ePacketID);
-    case XFA_XDPPACKET_LocaleSet:
-    case XFA_XDPPACKET_ConnectionSet:
-    case XFA_XDPPACKET_SourceSet:
-      return ParseAsXDPPacket_LocaleConnectionSourceSet(pXMLDocumentNode,
-                                                        ePacketID);
-    default:
-      return ParseAsXDPPacket_User(pXMLDocumentNode, ePacketID);
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_XDP(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  if (!XFA_FDEExtension_MatchNodeName(
-          pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName,
-          XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI,
-          XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
-    return nullptr;
-  }
-  CXFA_Node* pXFARootNode =
-      m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Xfa);
-  if (!pXFARootNode) {
-    return nullptr;
-  }
-  m_pRootNode = pXFARootNode;
-  pXFARootNode->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"xfa"));
-  {
-    IFDE_XMLElement* pElement = (IFDE_XMLElement*)pXMLDocumentNode;
-    int32_t iAttributeCount = pElement->CountAttributes();
-    for (int32_t i = 0; i < iAttributeCount; i++) {
-      CFX_WideString wsAttriName, wsAttriValue;
-      pElement->GetAttribute(i, wsAttriName, wsAttriValue);
-      if (wsAttriName == FX_WSTRC(L"uuid")) {
-        pXFARootNode->SetCData(XFA_ATTRIBUTE_Uuid, wsAttriValue);
-      } else if (wsAttriName == FX_WSTRC(L"timeStamp")) {
-        pXFARootNode->SetCData(XFA_ATTRIBUTE_TimeStamp, wsAttriValue);
-      }
-    }
-  }
-  IFDE_XMLNode* pXMLConfigDOMRoot = nullptr;
-  CXFA_Node* pXFAConfigDOMRoot = nullptr;
-  {
-    for (IFDE_XMLNode* pChildItem =
-             pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-         pChildItem;
-         pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-      const XFA_PACKETINFO* pPacketInfo =
-          XFA_GetPacketByIndex(XFA_PACKET_Config);
-      if (!XFA_FDEExtension_MatchNodeName(pChildItem, pPacketInfo->pName,
-                                          pPacketInfo->pURI,
-                                          pPacketInfo->eFlags)) {
-        continue;
-      }
-      if (pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) {
-        return nullptr;
-      }
-      pXMLConfigDOMRoot = pChildItem;
-      pXFAConfigDOMRoot =
-          ParseAsXDPPacket_Config(pXMLConfigDOMRoot, XFA_XDPPACKET_Config);
-      pXFARootNode->InsertChild(pXFAConfigDOMRoot, NULL);
-    }
-  }
-  IFDE_XMLNode* pXMLDatasetsDOMRoot = nullptr;
-  IFDE_XMLNode* pXMLFormDOMRoot = nullptr;
-  IFDE_XMLNode* pXMLTemplateDOMRoot = nullptr;
-  {
-    for (IFDE_XMLNode* pChildItem =
-             pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-         pChildItem;
-         pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-      if (!pChildItem || pChildItem->GetType() != FDE_XMLNODE_Element) {
-        continue;
-      }
-      if (pChildItem == pXMLConfigDOMRoot) {
-        continue;
-      }
-      IFDE_XMLElement* pElement =
-          reinterpret_cast<IFDE_XMLElement*>(pChildItem);
-      CFX_WideString wsPacketName;
-      pElement->GetLocalTagName(wsPacketName);
-      const XFA_PACKETINFO* pPacketInfo = XFA_GetPacketByName(wsPacketName);
-      if (pPacketInfo && pPacketInfo->pURI) {
-        if (!XFA_FDEExtension_MatchNodeName(pElement, pPacketInfo->pName,
-                                            pPacketInfo->pURI,
-                                            pPacketInfo->eFlags)) {
-          pPacketInfo = nullptr;
-        }
-      }
-      XFA_XDPPACKET ePacket =
-          pPacketInfo ? pPacketInfo->eName : XFA_XDPPACKET_USER;
-      if (ePacket == XFA_XDPPACKET_XDP) {
-        continue;
-      }
-      if (ePacket == XFA_XDPPACKET_Datasets) {
-        if (pXMLDatasetsDOMRoot) {
-          return nullptr;
-        }
-        pXMLDatasetsDOMRoot = pElement;
-      } else if (ePacket == XFA_XDPPACKET_Form) {
-        if (pXMLFormDOMRoot) {
-          return nullptr;
-        }
-        pXMLFormDOMRoot = pElement;
-      } else if (ePacket == XFA_XDPPACKET_Template) {
-        if (pXMLTemplateDOMRoot) {
-          // Found a duplicate template packet.
-          return nullptr;
-        }
-        CXFA_Node* pPacketNode = ParseAsXDPPacket(pElement, ePacket);
-        if (pPacketNode) {
-          pXMLTemplateDOMRoot = pElement;
-          pXFARootNode->InsertChild(pPacketNode);
-        }
-      } else {
-        CXFA_Node* pPacketNode = ParseAsXDPPacket(pElement, ePacket);
-        if (pPacketNode) {
-          if (pPacketInfo &&
-              (pPacketInfo->eFlags & XFA_XDPPACKET_FLAGS_SUPPORTONE) &&
-              pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) {
-            return nullptr;
-          }
-          pXFARootNode->InsertChild(pPacketNode);
-        }
-      }
-    }
-  }
-  if (!pXMLTemplateDOMRoot) {
-    // No template is found.
-    return nullptr;
-  }
-  if (pXMLDatasetsDOMRoot) {
-    CXFA_Node* pPacketNode =
-        ParseAsXDPPacket(pXMLDatasetsDOMRoot, XFA_XDPPACKET_Datasets);
-    if (pPacketNode) {
-      pXFARootNode->InsertChild(pPacketNode);
-    }
-  }
-  if (pXMLFormDOMRoot) {
-    CXFA_Node* pPacketNode =
-        ParseAsXDPPacket(pXMLFormDOMRoot, XFA_XDPPACKET_Form);
-    if (pPacketNode) {
-      pXFARootNode->InsertChild(pPacketNode);
-    }
-  }
-  pXFARootNode->SetXMLMappingNode(pXMLDocumentNode);
-  return pXFARootNode;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Config(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  if (!XFA_FDEExtension_MatchNodeName(
-          pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Config)->pName,
-          XFA_GetPacketByIndex(XFA_PACKET_Config)->pURI,
-          XFA_GetPacketByIndex(XFA_PACKET_Config)->eFlags)) {
-    return NULL;
-  }
-  CXFA_Node* pNode =
-      m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_ELEMENT_Config);
-  if (!pNode) {
-    return NULL;
-  }
-  pNode->SetCData(XFA_ATTRIBUTE_Name,
-                  XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
-  if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-    return NULL;
-  }
-  pNode->SetXMLMappingNode(pXMLDocumentNode);
-  return pNode;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  CXFA_Node* pNode = NULL;
-  if (ePacketID == XFA_XDPPACKET_Template) {
-    if (XFA_FDEExtension_MatchNodeName(
-            pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Template)->pName,
-            XFA_GetPacketByIndex(XFA_PACKET_Template)->pURI,
-            XFA_GetPacketByIndex(XFA_PACKET_Template)->eFlags)) {
-      pNode =
-          m_pFactory->CreateNode(XFA_XDPPACKET_Template, XFA_ELEMENT_Template);
-      if (!pNode) {
-        return NULL;
-      }
-      pNode->SetCData(XFA_ATTRIBUTE_Name,
-                      XFA_GetPacketByIndex(XFA_PACKET_Template)->pName);
-      if (m_bDocumentParser) {
-        CFX_WideString wsNamespaceURI;
-        IFDE_XMLElement* pXMLDocumentElement =
-            (IFDE_XMLElement*)pXMLDocumentNode;
-        pXMLDocumentElement->GetNamespaceURI(wsNamespaceURI);
-        if (wsNamespaceURI.IsEmpty()) {
-          pXMLDocumentElement->GetString(L"xmlns:xfa", wsNamespaceURI);
-        }
-        pNode->GetDocument()->RecognizeXFAVersionNumber(wsNamespaceURI);
-      }
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
-      }
-    }
-  } else if (ePacketID == XFA_XDPPACKET_Form) {
-    if (XFA_FDEExtension_MatchNodeName(
-            pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Form)->pName,
-            XFA_GetPacketByIndex(XFA_PACKET_Form)->pURI,
-            XFA_GetPacketByIndex(XFA_PACKET_Form)->eFlags)) {
-      IFDE_XMLElement* pXMLDocumentElement = (IFDE_XMLElement*)pXMLDocumentNode;
-      CFX_WideString wsChecksum;
-      pXMLDocumentElement->GetString(L"checksum", wsChecksum);
-      if (wsChecksum.GetLength() != 28 ||
-          m_pXMLParser->m_dwCheckStatus != 0x03) {
-        return NULL;
-      }
-      IXFA_ChecksumContext* pChecksum = XFA_Checksum_Create();
-      pChecksum->StartChecksum();
-      pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[0],
-                                m_pXMLParser->m_nSize[0]);
-      pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[1],
-                                m_pXMLParser->m_nSize[1]);
-      pChecksum->FinishChecksum();
-      CFX_ByteString bsCheck;
-      pChecksum->GetChecksum(bsCheck);
-      pChecksum->Release();
-      if (bsCheck != wsChecksum.UTF8Encode()) {
-        return NULL;
-      }
-
-      pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
-      if (!pNode) {
-        return NULL;
-      }
-      pNode->SetCData(XFA_ATTRIBUTE_Name,
-                      XFA_GetPacketByIndex(XFA_PACKET_Form)->pName);
-      pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum);
-      CXFA_Node* pTemplateRoot =
-          m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template);
-      CXFA_Node* pTemplateChosen =
-          pTemplateRoot
-              ? pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform)
-              : NULL;
-      FX_BOOL bUseAttribute = TRUE;
-      if (pTemplateChosen &&
-          pTemplateChosen->GetEnum(XFA_ATTRIBUTE_RestoreState) !=
-              XFA_ATTRIBUTEENUM_Auto) {
-        bUseAttribute = FALSE;
-      }
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) {
-        return NULL;
-      }
-    }
-  }
-  if (pNode) {
-    pNode->SetXMLMappingNode(pXMLDocumentNode);
-  }
-  return pNode;
-}
-static IFDE_XMLNode* XFA_GetDataSetsFromXDP(IFDE_XMLNode* pXMLDocumentNode) {
-  if (XFA_FDEExtension_MatchNodeName(
-          pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName,
-          XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
-          XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
-    return pXMLDocumentNode;
-  }
-  if (!XFA_FDEExtension_MatchNodeName(
-          pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName,
-          XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI,
-          XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
-    return NULL;
-  }
-  for (IFDE_XMLNode* pDatasetsNode =
-           pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pDatasetsNode;
-       pDatasetsNode = pDatasetsNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    if (!XFA_FDEExtension_MatchNodeName(
-            pDatasetsNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName,
-            XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
-            XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
-      continue;
-    }
-    return pDatasetsNode;
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Data(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  IFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode);
-  if (pDatasetsXMLNode) {
-    CXFA_Node* pNode =
-        m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel);
-    if (!pNode) {
-      return NULL;
-    }
-    pNode->SetCData(XFA_ATTRIBUTE_Name,
-                    XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName);
-    if (!DataLoader(pNode, pDatasetsXMLNode, FALSE)) {
-      return NULL;
-    }
-    pNode->SetXMLMappingNode(pDatasetsXMLNode);
-    return pNode;
-  }
-  IFDE_XMLNode* pDataXMLNode = NULL;
-  if (XFA_FDEExtension_MatchNodeName(
-          pXMLDocumentNode, FX_WSTRC(L"data"),
-          XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
-          XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
-    ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa");
-    pDataXMLNode = pXMLDocumentNode;
-  } else {
-    IFDE_XMLElement* pDataElement =
-        IFDE_XMLElement::Create(FX_WSTRC(L"xfa:data"));
-    IFDE_XMLNode* pParentXMLNode =
-        pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::Parent);
-    if (pParentXMLNode) {
-      pParentXMLNode->RemoveChildNode(pXMLDocumentNode);
-    }
-    FXSYS_assert(pXMLDocumentNode->GetType() == FDE_XMLNODE_Element);
-    if (pXMLDocumentNode->GetType() == FDE_XMLNODE_Element) {
-      ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa");
-    }
-    pDataElement->InsertChildNode(pXMLDocumentNode);
-    pDataXMLNode = pDataElement;
-  }
-  if (pDataXMLNode) {
-    CXFA_Node* pNode =
-        m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
-    if (!pNode) {
-      if (pDataXMLNode != pXMLDocumentNode) {
-        pDataXMLNode->Release();
-      }
-      return NULL;
-    }
-    CFX_WideString wsLocalName;
-    ((IFDE_XMLElement*)pDataXMLNode)->GetLocalTagName(wsLocalName);
-    pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
-    if (!DataLoader(pNode, pDataXMLNode, TRUE)) {
-      return NULL;
-    }
-    pNode->SetXMLMappingNode(pDataXMLNode);
-    if (pDataXMLNode != pXMLDocumentNode) {
-      pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
-    }
-    return pNode;
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  CXFA_Node* pNode = NULL;
-  if (ePacketID == XFA_XDPPACKET_LocaleSet) {
-    if (XFA_FDEExtension_MatchNodeName(
-            pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName,
-            XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pURI,
-            XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->eFlags)) {
-      pNode = m_pFactory->CreateNode(XFA_XDPPACKET_LocaleSet,
-                                     XFA_ELEMENT_LocaleSet);
-      if (!pNode) {
-        return NULL;
-      }
-      pNode->SetCData(XFA_ATTRIBUTE_Name,
-                      XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName);
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
-      }
-    }
-  } else if (ePacketID == XFA_XDPPACKET_ConnectionSet) {
-    if (XFA_FDEExtension_MatchNodeName(
-            pXMLDocumentNode,
-            XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName,
-            XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pURI,
-            XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->eFlags)) {
-      pNode = m_pFactory->CreateNode(XFA_XDPPACKET_ConnectionSet,
-                                     XFA_ELEMENT_ConnectionSet);
-      if (!pNode) {
-        return NULL;
-      }
-      pNode->SetCData(XFA_ATTRIBUTE_Name,
-                      XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName);
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
-      }
-    }
-  } else if (ePacketID == XFA_XDPPACKET_SourceSet) {
-    if (XFA_FDEExtension_MatchNodeName(
-            pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName,
-            XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pURI,
-            XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->eFlags)) {
-      pNode = m_pFactory->CreateNode(XFA_XDPPACKET_SourceSet,
-                                     XFA_ELEMENT_SourceSet);
-      if (!pNode) {
-        return NULL;
-      }
-      pNode->SetCData(XFA_ATTRIBUTE_Name,
-                      XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName);
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
-      }
-    }
-  }
-  if (pNode) {
-    pNode->SetXMLMappingNode(pXMLDocumentNode);
-  }
-  return pNode;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  if (XFA_FDEExtension_MatchNodeName(
-          pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName,
-          XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pURI,
-          XFA_GetPacketByIndex(XFA_PACKET_Xdc)->eFlags)) {
-    CXFA_Node* pNode =
-        m_pFactory->CreateNode(XFA_XDPPACKET_Xdc, XFA_ELEMENT_Xdc);
-    if (!pNode) {
-      return NULL;
-    }
-    pNode->SetCData(XFA_ATTRIBUTE_Name,
-                    XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName);
-    pNode->SetXMLMappingNode(pXMLDocumentNode);
-    return pNode;
-  }
-  return NULL;
-}
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User(
-    IFDE_XMLNode* pXMLDocumentNode,
-    XFA_XDPPACKET ePacketID) {
-  CXFA_Node* pNode =
-      m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Packet);
-  if (!pNode) {
-    return NULL;
-  }
-  CFX_WideString wsName;
-  ((IFDE_XMLElement*)pXMLDocumentNode)->GetLocalTagName(wsName);
-  pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
-  if (!UserPacketLoader(pNode, pXMLDocumentNode)) {
-    return NULL;
-  }
-  pNode->SetXMLMappingNode(pXMLDocumentNode);
-  return pNode;
-}
-CXFA_Node* CXFA_SimpleParser::UserPacketLoader(CXFA_Node* pXFANode,
-                                               IFDE_XMLNode* pXMLDoc) {
-  return pXFANode;
-}
-static FX_BOOL XFA_FDEExtension_IsStringAllWhitespace(CFX_WideString wsText) {
-  wsText.TrimRight(L"\x20\x9\xD\xA");
-  return wsText.IsEmpty();
-}
-CXFA_Node* CXFA_SimpleParser::DataLoader(CXFA_Node* pXFANode,
-                                         IFDE_XMLNode* pXMLDoc,
-                                         FX_BOOL bDoTransform) {
-  ParseDataGroup(pXFANode, pXMLDoc, XFA_XDPPACKET_Datasets);
-  return pXFANode;
-}
-CXFA_Node* CXFA_SimpleParser::NormalLoader(CXFA_Node* pXFANode,
-                                           IFDE_XMLNode* pXMLDoc,
-                                           XFA_XDPPACKET ePacketID,
-                                           FX_BOOL bUseAttribute) {
-  FX_BOOL bOneOfPropertyFound = FALSE;
-  for (IFDE_XMLNode* pXMLChild = pXMLDoc->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    switch (pXMLChild->GetType()) {
-      case FDE_XMLNODE_Element: {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild;
-        CFX_WideString wsTagName;
-        pXMLElement->GetLocalTagName(wsTagName);
-        const XFA_ELEMENTINFO* pElemInfo = XFA_GetElementByName(wsTagName);
-        if (!pElemInfo) {
-          continue;
-        }
-        const XFA_PROPERTY* pPropertyInfo = XFA_GetPropertyOfElement(
-            pXFANode->GetClassID(), pElemInfo->eName, ePacketID);
-        if (pPropertyInfo &&
-            ((pPropertyInfo->uFlags &
-              (XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf)) != 0)) {
-          if (bOneOfPropertyFound) {
-            break;
-          }
-          bOneOfPropertyFound = TRUE;
-        }
-        CXFA_Node* pXFAChild =
-            m_pFactory->CreateNode(ePacketID, pElemInfo->eName);
-        if (pXFAChild == NULL) {
-          return NULL;
-        }
-        if (ePacketID == XFA_XDPPACKET_Config) {
-          pXFAChild->SetAttribute(XFA_ATTRIBUTE_Name, wsTagName);
-        }
-        FX_BOOL IsNeedValue = TRUE;
-        for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count;
-             i++) {
-          CFX_WideString wsAttrQualifiedName;
-          CFX_WideString wsAttrName;
-          CFX_WideString wsAttrValue;
-          pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
-          XFA_FDEExtension_GetAttributeLocalName(wsAttrQualifiedName,
-                                                 wsAttrName);
-          if (wsAttrName == FX_WSTRC(L"nil") &&
-              wsAttrValue == FX_WSTRC(L"true")) {
-            IsNeedValue = FALSE;
-          }
-          const XFA_ATTRIBUTEINFO* lpAttrInfo =
-              XFA_GetAttributeByName(wsAttrName);
-          if (!lpAttrInfo) {
-            continue;
-          }
-          if (!bUseAttribute && lpAttrInfo->eName != XFA_ATTRIBUTE_Name &&
-              lpAttrInfo->eName != XFA_ATTRIBUTE_Save) {
-            continue;
-          }
-          pXFAChild->SetAttribute(lpAttrInfo->eName, wsAttrValue);
-        }
-        pXFANode->InsertChild(pXFAChild);
-        if (pElemInfo->eName == XFA_ELEMENT_Validate ||
-            pElemInfo->eName == XFA_ELEMENT_Locale) {
-          if (ePacketID == XFA_XDPPACKET_Config) {
-            ParseContentNode(pXFAChild, pXMLElement, ePacketID);
-          } else {
-            NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
-          }
-          break;
-        }
-        switch (pXFAChild->GetObjectType()) {
-          case XFA_OBJECTTYPE_ContentNode:
-          case XFA_OBJECTTYPE_TextNode:
-          case XFA_OBJECTTYPE_NodeC:
-          case XFA_OBJECTTYPE_NodeV:
-            if (IsNeedValue) {
-              ParseContentNode(pXFAChild, pXMLElement, ePacketID);
-            }
-            break;
-          default:
-            NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
-            break;
-        }
-      } break;
-      case FDE_XMLNODE_Instruction:
-        ParseInstruction(pXFANode, (IFDE_XMLInstruction*)pXMLChild, ePacketID);
-        break;
-      default:
-        break;
-    }
-  }
-  return pXFANode;
-}
-FX_BOOL XFA_RecognizeRichText(IFDE_XMLElement* pRichTextXMLNode) {
-  if (pRichTextXMLNode) {
-    CFX_WideString wsNamespaceURI;
-    XFA_FDEExtension_GetElementTagNamespaceURI(pRichTextXMLNode,
-                                               wsNamespaceURI);
-    if (wsNamespaceURI == FX_WSTRC(L"http://www.w3.org/1999/xhtml")) {
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-class RichTextNodeVisitor {
- public:
-  static inline IFDE_XMLNode* GetFirstChild(IFDE_XMLNode* pNode) {
-    return pNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-  }
-  static inline IFDE_XMLNode* GetNextSibling(IFDE_XMLNode* pNode) {
-    return pNode->GetNodeItem(IFDE_XMLNode::NextSibling);
-  }
-  static inline IFDE_XMLNode* GetParent(IFDE_XMLNode* pNode) {
-    return pNode->GetNodeItem(IFDE_XMLNode::Parent);
-  }
-};
-
-void XFA_ConvertXMLToPlainText(IFDE_XMLElement* pRootXMLNode,
-                               CFX_WideString& wsOutput) {
-  for (IFDE_XMLNode* pXMLChild =
-           pRootXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    switch (pXMLChild->GetType()) {
-      case FDE_XMLNODE_Element: {
-        CFX_WideString wsTextData;
-        ((IFDE_XMLElement*)pXMLChild)->GetTextData(wsTextData);
-        wsTextData += FX_WSTRC(L"\n");
-        wsOutput += wsTextData;
-      } break;
-      case FDE_XMLNODE_Text: {
-        CFX_WideString wsText;
-        ((IFDE_XMLText*)pXMLChild)->GetText(wsText);
-        if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
-          continue;
-        } else {
-          wsOutput = wsText;
-        }
-      } break;
-      case FDE_XMLNODE_CharData: {
-        CFX_WideString wsCharData;
-        ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsCharData);
-        if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
-          continue;
-        } else {
-          wsOutput = wsCharData;
-        }
-      } break;
-      default:
-        FXSYS_assert(FALSE);
-        break;
-    }
-  }
-}
-
-void CXFA_SimpleParser::ParseContentNode(CXFA_Node* pXFANode,
-                                         IFDE_XMLNode* pXMLNode,
-                                         XFA_XDPPACKET ePacketID) {
-  XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
-  if (pXFANode->GetClassID() == XFA_ELEMENT_ExData) {
-    CFX_WideStringC wsContentType =
-        pXFANode->GetCData(XFA_ATTRIBUTE_ContentType);
-    if (wsContentType == FX_WSTRC(L"text/html"))
-      element = XFA_ELEMENT_SharpxHTML;
-    else if (wsContentType == FX_WSTRC(L"text/xml"))
-      element = XFA_ELEMENT_Sharpxml;
-  }
-  if (element == XFA_ELEMENT_SharpxHTML)
-    pXFANode->SetXMLMappingNode(pXMLNode);
-
-  CFX_WideString wsValue;
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
-    if (eNodeType == FDE_XMLNODE_Instruction)
-      continue;
-
-    if (element == XFA_ELEMENT_SharpxHTML) {
-      if (eNodeType != FDE_XMLNODE_Element)
-        break;
-
-      if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild))
-        XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsValue);
-    } else if (element == XFA_ELEMENT_Sharpxml) {
-      if (eNodeType != FDE_XMLNODE_Element)
-        break;
-      XFA_ConvertXMLToPlainText((IFDE_XMLElement*)pXMLChild, wsValue);
-    } else {
-      if (eNodeType == FDE_XMLNODE_Element)
-        break;
-      if (eNodeType == FDE_XMLNODE_Text)
-        ((IFDE_XMLText*)pXMLChild)->GetText(wsValue);
-      else if (eNodeType == FDE_XMLNODE_CharData)
-        ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsValue);
-    }
-    break;
-  }
-  if (!wsValue.IsEmpty()) {
-    if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
-      CXFA_Node* pContentRawDataNode =
-          m_pFactory->CreateNode(ePacketID, element);
-      FXSYS_assert(pContentRawDataNode);
-      pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
-      pXFANode->InsertChild(pContentRawDataNode);
-    } else {
-      pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
-    }
-  }
-}
-
-void CXFA_SimpleParser::ParseDataGroup(CXFA_Node* pXFANode,
-                                       IFDE_XMLNode* pXMLNode,
-                                       XFA_XDPPACKET ePacketID) {
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    switch (pXMLChild->GetType()) {
-      case FDE_XMLNODE_Element: {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild;
-        {
-          CFX_WideString wsNamespaceURI;
-          XFA_FDEExtension_GetElementTagNamespaceURI(pXMLElement,
-                                                     wsNamespaceURI);
-          if (wsNamespaceURI ==
-                  FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") ||
-              wsNamespaceURI ==
-                  FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") ||
-              wsNamespaceURI ==
-                  FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance")) {
-            continue;
-          }
-          if (0) {
-            continue;
-          }
-        }
-        XFA_ELEMENT eNodeType = XFA_ELEMENT_DataModel;
-        if (eNodeType == XFA_ELEMENT_DataModel) {
-          CFX_WideString wsDataNodeAttr;
-          if (XFA_FDEExtension_FindAttributeWithNS(
-                  pXMLElement, FX_WSTRC(L"dataNode"),
-                  FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"),
-                  wsDataNodeAttr)) {
-            if (wsDataNodeAttr == FX_WSTRC(L"dataGroup")) {
-              eNodeType = XFA_ELEMENT_DataGroup;
-            } else if (wsDataNodeAttr == FX_WSTRC(L"dataValue")) {
-              eNodeType = XFA_ELEMENT_DataValue;
-            }
-          }
-        }
-        CFX_WideString wsContentType;
-        if (eNodeType == XFA_ELEMENT_DataModel) {
-          if (XFA_FDEExtension_FindAttributeWithNS(
-                  pXMLElement, FX_WSTRC(L"contentType"),
-                  FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"),
-                  wsContentType)) {
-            if (!wsContentType.IsEmpty()) {
-              eNodeType = XFA_ELEMENT_DataValue;
-            }
-          }
-        }
-        if (eNodeType == XFA_ELEMENT_DataModel) {
-          for (IFDE_XMLNode* pXMLDataChild =
-                   pXMLElement->GetNodeItem(IFDE_XMLNode::FirstChild);
-               pXMLDataChild; pXMLDataChild = pXMLDataChild->GetNodeItem(
-                                  IFDE_XMLNode::NextSibling)) {
-            if (pXMLDataChild->GetType() == FDE_XMLNODE_Element) {
-              if (!XFA_RecognizeRichText((IFDE_XMLElement*)pXMLDataChild)) {
-                eNodeType = XFA_ELEMENT_DataGroup;
-                break;
-              }
-            }
-          }
-        }
-        if (eNodeType == XFA_ELEMENT_DataModel) {
-          eNodeType = XFA_ELEMENT_DataValue;
-        }
-        CXFA_Node* pXFAChild =
-            m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
-        if (pXFAChild == NULL) {
-          return;
-        }
-        CFX_WideString wsNodeName;
-        pXMLElement->GetLocalTagName(wsNodeName);
-        pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeName);
-        FX_BOOL bNeedValue = TRUE;
-        if (1) {
-          for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count;
-               i++) {
-            CFX_WideString wsAttrQualifiedName;
-            CFX_WideString wsAttrValue;
-            CFX_WideString wsAttrName;
-            CFX_WideString wsAttrNamespaceURI;
-            pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
-            if (!XFA_FDEExtension_ResolveAttribute(
-                    pXMLElement, wsAttrQualifiedName, wsAttrName,
-                    wsAttrNamespaceURI)) {
-              continue;
-            }
-            if (wsAttrName == FX_WSTRC(L"nil") &&
-                wsAttrValue == FX_WSTRC(L"true")) {
-              bNeedValue = FALSE;
-              continue;
-            }
-            if (wsAttrNamespaceURI ==
-                    FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") ||
-                wsAttrNamespaceURI ==
-                    FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") ||
-                wsAttrNamespaceURI ==
-                    FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance") ||
-                wsAttrNamespaceURI ==
-                    FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/")) {
-              continue;
-            }
-            if (0) {
-              continue;
-            }
-            CXFA_Node* pXFAMetaData = m_pFactory->CreateNode(
-                XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue);
-            if (pXFAMetaData == NULL) {
-              return;
-            }
-            pXFAMetaData->SetCData(XFA_ATTRIBUTE_Name, wsAttrName);
-            pXFAMetaData->SetCData(XFA_ATTRIBUTE_QualifiedName,
-                                   wsAttrQualifiedName);
-            pXFAMetaData->SetCData(XFA_ATTRIBUTE_Value, wsAttrValue);
-            pXFAMetaData->SetEnum(XFA_ATTRIBUTE_Contains,
-                                  XFA_ATTRIBUTEENUM_MetaData);
-            pXFAChild->InsertChild(pXFAMetaData);
-            pXFAMetaData->SetXMLMappingNode(pXMLElement);
-            pXFAMetaData->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-          }
-          if (!bNeedValue) {
-            CFX_WideString wsNilName = FX_WSTRC(L"xsi:nil");
-            pXMLElement->RemoveAttribute(wsNilName);
-          }
-        }
-        pXFANode->InsertChild(pXFAChild);
-        if (eNodeType == XFA_ELEMENT_DataGroup) {
-          ParseDataGroup(pXFAChild, pXMLElement, ePacketID);
-        } else {
-          if (bNeedValue) {
-            ParseDataValue(pXFAChild, pXMLChild, XFA_XDPPACKET_Datasets);
-          }
-        }
-        pXFAChild->SetXMLMappingNode(pXMLElement);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-      }
-        continue;
-      case FDE_XMLNODE_CharData: {
-        IFDE_XMLCharData* pXMLCharData = (IFDE_XMLCharData*)pXMLChild;
-        CFX_WideString wsCharData;
-        pXMLCharData->GetCharData(wsCharData);
-        if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
-          continue;
-        }
-        CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
-                                                      XFA_ELEMENT_DataValue);
-        if (pXFAChild == NULL) {
-          return;
-        }
-        pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData);
-        pXFANode->InsertChild(pXFAChild);
-        pXFAChild->SetXMLMappingNode(pXMLCharData);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-      }
-        continue;
-      case FDE_XMLNODE_Text: {
-        IFDE_XMLText* pXMLText = (IFDE_XMLText*)pXMLChild;
-        CFX_WideString wsText;
-        pXMLText->GetText(wsText);
-        if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
-          continue;
-        }
-        CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
-                                                      XFA_ELEMENT_DataValue);
-        if (pXFAChild == NULL) {
-          return;
-        }
-        pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText);
-        pXFANode->InsertChild(pXFAChild);
-        pXFAChild->SetXMLMappingNode(pXMLText);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-      }
-        continue;
-      case FDE_XMLNODE_Instruction:
-        continue;
-      default:
-        continue;
-    }
-  }
-}
-
-void CXFA_SimpleParser::ParseDataValue(CXFA_Node* pXFANode,
-                                       IFDE_XMLNode* pXMLNode,
-                                       XFA_XDPPACKET ePacketID) {
-  CFX_WideTextBuf wsValueTextBuf;
-  CFX_WideTextBuf wsCurValueTextBuf;
-  FX_BOOL bMarkAsCompound = FALSE;
-  IFDE_XMLNode* pXMLCurValueNode = nullptr;
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
-    if (eNodeType == FDE_XMLNODE_Instruction)
-      continue;
-
-    CFX_WideString wsText;
-    if (eNodeType == FDE_XMLNODE_Text) {
-      ((IFDE_XMLText*)pXMLChild)->GetText(wsText);
-      if (!pXMLCurValueNode)
-        pXMLCurValueNode = pXMLChild;
-
-      wsCurValueTextBuf << wsText;
-    } else if (eNodeType == FDE_XMLNODE_CharData) {
-      ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsText);
-      if (!pXMLCurValueNode)
-        pXMLCurValueNode = pXMLChild;
-
-      wsCurValueTextBuf << wsText;
-    } else if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild)) {
-      XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsText);
-      if (!pXMLCurValueNode)
-        pXMLCurValueNode = pXMLChild;
-
-      wsCurValueTextBuf << wsText;
-    } else {
-      bMarkAsCompound = TRUE;
-      if (pXMLCurValueNode) {
-        CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString();
-        if (!wsCurValue.IsEmpty()) {
-          CXFA_Node* pXFAChild =
-              m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
-          if (!pXFAChild)
-            return;
-
-          pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L""));
-          pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
-          pXFANode->InsertChild(pXFAChild);
-          pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
-          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-          wsValueTextBuf << wsCurValue;
-          wsCurValueTextBuf.Clear();
-        }
-        pXMLCurValueNode = nullptr;
-      }
-      CXFA_Node* pXFAChild =
-          m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
-      if (!pXFAChild)
-        return;
-
-      CFX_WideString wsNodeStr;
-      ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr);
-      pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
-      ParseDataValue(pXFAChild, pXMLChild, ePacketID);
-      pXFANode->InsertChild(pXFAChild);
-      pXFAChild->SetXMLMappingNode(pXMLChild);
-      pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-      CFX_WideStringC wsCurValue = pXFAChild->GetCData(XFA_ATTRIBUTE_Value);
-      wsValueTextBuf << wsCurValue;
-    }
-  }
-  if (pXMLCurValueNode) {
-    CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString();
-    if (!wsCurValue.IsEmpty()) {
-      if (bMarkAsCompound) {
-        CXFA_Node* pXFAChild =
-            m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
-        if (!pXFAChild)
-          return;
-
-        pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L""));
-        pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
-        pXFANode->InsertChild(pXFAChild);
-        pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
-      }
-      wsValueTextBuf << wsCurValue;
-      wsCurValueTextBuf.Clear();
-    }
-    pXMLCurValueNode = nullptr;
-  }
-  CFX_WideStringC wsNodeValue = wsValueTextBuf.GetWideString();
-  pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsNodeValue);
-}
-
-void CXFA_SimpleParser::ParseInstruction(CXFA_Node* pXFANode,
-                                         IFDE_XMLInstruction* pXMLInstruction,
-                                         XFA_XDPPACKET ePacketID) {
-  if (!m_bDocumentParser) {
-    return;
-  }
-  CFX_WideString wsTargetName;
-  pXMLInstruction->GetTargetName(wsTargetName);
-  if (wsTargetName == FX_WSTRC(L"originalXFAVersion")) {
-    CFX_WideString wsData;
-    if (pXMLInstruction->GetData(0, wsData) &&
-        (pXFANode->GetDocument()->RecognizeXFAVersionNumber(wsData) !=
-         XFA_VERSION_UNKNOWN)) {
-      wsData.Empty();
-      if (pXMLInstruction->GetData(1, wsData) &&
-          wsData == FX_WSTRC(L"v2.7-scripting:1")) {
-        pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_Scripting, TRUE);
-      }
-    }
-  } else if (wsTargetName == FX_WSTRC(L"acrobat")) {
-    CFX_WideString wsData;
-    if (pXMLInstruction->GetData(0, wsData) &&
-        wsData == FX_WSTRC(L"JavaScript")) {
-      if (pXMLInstruction->GetData(1, wsData) &&
-          wsData == FX_WSTRC(L"strictScoping")) {
-        pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_StrictScoping, TRUE);
-      }
-    }
-  }
-}
-void CXFA_SimpleParser::CloseParser() {
-  if (m_pXMLDoc) {
-    m_pXMLDoc->Release();
-    m_pXMLDoc = NULL;
-  }
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = NULL;
-  }
-}
-IXFA_DocParser* IXFA_DocParser::Create(IXFA_Notify* pNotify) {
-  return new CXFA_DocumentParser(pNotify);
-}
-CXFA_DocumentParser::CXFA_DocumentParser(IXFA_Notify* pNotify)
-    : m_nodeParser(NULL, TRUE), m_pNotify(pNotify), m_pDocument(NULL) {}
-CXFA_DocumentParser::~CXFA_DocumentParser() {
-  CloseParser();
-}
-int32_t CXFA_DocumentParser::StartParse(IFX_FileRead* pStream,
-                                        XFA_XDPPACKET ePacketID) {
-  CloseParser();
-  int32_t nRetStatus = m_nodeParser.StartParse(pStream, ePacketID);
-  if (nRetStatus == XFA_PARSESTATUS_Ready) {
-    m_pDocument = new CXFA_Document(this);
-    m_nodeParser.SetFactory(m_pDocument);
-  }
-  return nRetStatus;
-}
-int32_t CXFA_DocumentParser::DoParse(IFX_Pause* pPause) {
-  int32_t nRetStatus = m_nodeParser.DoParse(pPause);
-  if (nRetStatus >= XFA_PARSESTATUS_Done) {
-    FXSYS_assert(m_pDocument);
-    m_pDocument->SetRoot(m_nodeParser.GetRootNode());
-  }
-  return nRetStatus;
-}
-int32_t CXFA_DocumentParser::ParseXMLData(const CFX_WideString& wsXML,
-                                          IFDE_XMLNode*& pXMLNode,
-                                          IFX_Pause* pPause) {
-  CloseParser();
-  int32_t nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, NULL);
-  if (nRetStatus == XFA_PARSESTATUS_Done && pXMLNode) {
-    m_pDocument = new CXFA_Document(this);
-    m_nodeParser.SetFactory(m_pDocument);
-  }
-  return nRetStatus;
-}
-void CXFA_DocumentParser::ConstructXFANode(CXFA_Node* pXFANode,
-                                           IFDE_XMLNode* pXMLNode) {
-  if (!pXFANode || !pXMLNode) {
-    return;
-  }
-  m_nodeParser.ConstructXFANode(pXFANode, pXMLNode);
-  CXFA_Node* pRootNode = m_nodeParser.GetRootNode();
-  if (m_pDocument && pRootNode) {
-    m_pDocument->SetRoot(pRootNode);
-  }
-}
-void CXFA_DocumentParser::CloseParser() {
-  if (m_pDocument) {
-    delete m_pDocument;
-    m_pDocument = NULL;
-  }
-  m_nodeParser.CloseParser();
-}
-CXFA_XMLParser::CXFA_XMLParser(IFDE_XMLNode* pRoot, IFX_Stream* pStream)
-    : m_nElementStart(0),
-      m_dwCheckStatus(0),
-      m_dwCurrentCheckStatus(0),
-      m_pRoot(pRoot),
-      m_pStream(pStream),
-      m_pParser(nullptr),
-      m_pParent(pRoot),
-      m_pChild(nullptr),
-      m_NodeStack(16),
-      m_dwStatus(FDE_XMLSYNTAXSTATUS_None) {
-  ASSERT(m_pParent && m_pStream);
-  m_NodeStack.Push(m_pParent);
-  m_pParser = IFDE_XMLSyntaxParser::Create();
-  m_pParser->Init(m_pStream, 32 * 1024, 1024 * 1024);
-}
-CXFA_XMLParser::~CXFA_XMLParser() {
-  if (m_pParser) {
-    m_pParser->Release();
-  }
-  m_NodeStack.RemoveAll();
-  m_ws1.Empty();
-  m_ws2.Empty();
-}
-int32_t CXFA_XMLParser::DoParser(IFX_Pause* pPause) {
-  if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error) {
-    return -1;
-  }
-  if (m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) {
-    return 100;
-  }
-  int32_t iCount = 0;
-  while (TRUE) {
-    m_dwStatus = m_pParser->DoSyntaxParse();
-    switch (m_dwStatus) {
-      case FDE_XMLSYNTAXSTATUS_InstructionOpen:
-        break;
-      case FDE_XMLSYNTAXSTATUS_InstructionClose:
-        if (m_pChild) {
-          if (m_pChild->GetType() != FDE_XMLNODE_Instruction) {
-            m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
-            break;
-          }
-        }
-        m_pChild = m_pParent;
-        break;
-      case FDE_XMLSYNTAXSTATUS_ElementOpen:
-        if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 2) {
-          m_nElementStart = m_pParser->GetCurrentPos() - 1;
-        }
-        break;
-      case FDE_XMLSYNTAXSTATUS_ElementBreak:
-        break;
-      case FDE_XMLSYNTAXSTATUS_ElementClose:
-        if (m_pChild->GetType() != FDE_XMLNODE_Element) {
-          m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
-          break;
-        }
-        m_pParser->GetTagName(m_ws1);
-        ((IFDE_XMLElement*)m_pChild)->GetTagName(m_ws2);
-        if (m_ws1.GetLength() > 0 && !m_ws1.Equal(m_ws2)) {
-          m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
-          break;
-        }
-        m_NodeStack.Pop();
-        if (m_NodeStack.GetSize() < 1) {
-          m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
-          break;
-        } else if (m_dwCurrentCheckStatus != 0 && m_NodeStack.GetSize() == 2) {
-          m_nSize[m_dwCurrentCheckStatus - 1] =
-              m_pParser->GetCurrentBinaryPos() -
-              m_nStart[m_dwCurrentCheckStatus - 1];
-          m_dwCurrentCheckStatus = 0;
-        }
-
-        m_pParent = (IFDE_XMLNode*)*m_NodeStack.GetTopElement();
-        m_pChild = m_pParent;
-        iCount++;
-        break;
-      case FDE_XMLSYNTAXSTATUS_TargetName:
-        m_pParser->GetTargetName(m_ws1);
-        if (m_ws1 == FX_WSTRC(L"originalXFAVersion") ||
-            m_ws1 == FX_WSTRC(L"acrobat")) {
-          m_pChild = IFDE_XMLInstruction::Create(m_ws1);
-          m_pParent->InsertChildNode(m_pChild);
-        } else {
-          m_pChild = NULL;
-        }
-        m_ws1.Empty();
-        break;
-      case FDE_XMLSYNTAXSTATUS_TagName:
-        m_pParser->GetTagName(m_ws1);
-        m_pChild = IFDE_XMLElement::Create(m_ws1);
-        m_pParent->InsertChildNode(m_pChild);
-        m_NodeStack.Push(m_pChild);
-        m_pParent = m_pChild;
-
-        if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 3) {
-          CFX_WideString wsTag;
-          ((IFDE_XMLElement*)m_pChild)->GetLocalTagName(wsTag);
-          if (wsTag == FX_WSTRC(L"template")) {
-            m_dwCheckStatus |= 0x01;
-            m_dwCurrentCheckStatus = 0x01;
-            m_nStart[0] = m_pParser->GetCurrentBinaryPos() -
-                          (m_pParser->GetCurrentPos() - m_nElementStart);
-          } else if (wsTag == FX_WSTRC(L"datasets")) {
-            m_dwCheckStatus |= 0x02;
-            m_dwCurrentCheckStatus = 0x02;
-            m_nStart[1] = m_pParser->GetCurrentBinaryPos() -
-                          (m_pParser->GetCurrentPos() - m_nElementStart);
-          }
-        }
-        break;
-      case FDE_XMLSYNTAXSTATUS_AttriName:
-        m_pParser->GetAttributeName(m_ws1);
-        break;
-      case FDE_XMLSYNTAXSTATUS_AttriValue:
-        if (m_pChild) {
-          m_pParser->GetAttributeName(m_ws2);
-          if (m_pChild->GetType() == FDE_XMLNODE_Element) {
-            ((IFDE_XMLElement*)m_pChild)->SetString(m_ws1, m_ws2);
-          }
-        }
-        m_ws1.Empty();
-        break;
-      case FDE_XMLSYNTAXSTATUS_Text:
-        m_pParser->GetTextData(m_ws1);
-        m_pChild = IFDE_XMLText::Create(m_ws1);
-        m_pParent->InsertChildNode(m_pChild);
-        m_pChild = m_pParent;
-        break;
-      case FDE_XMLSYNTAXSTATUS_CData:
-        m_pParser->GetTextData(m_ws1);
-        m_pChild = IFDE_XMLCharData::Create(m_ws1);
-        m_pParent->InsertChildNode(m_pChild);
-        m_pChild = m_pParent;
-        break;
-      case FDE_XMLSYNTAXSTATUS_TargetData:
-        if (m_pChild) {
-          if (m_pChild->GetType() != FDE_XMLNODE_Instruction) {
-            m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
-            break;
-          }
-          if (!m_ws1.IsEmpty()) {
-            ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
-          }
-          m_pParser->GetTargetData(m_ws1);
-          ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
-        }
-        m_ws1.Empty();
-        break;
-      default:
-        break;
-    }
-    if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error ||
-        m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) {
-      break;
-    }
-    if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
-      break;
-    }
-  }
-  return (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error || m_NodeStack.GetSize() != 1)
-             ? -1
-             : m_pParser->GetStatus();
-}
diff --git a/xfa/src/fxfa/parser/xfa_parser_imp.h b/xfa/src/fxfa/parser/xfa_parser_imp.h
deleted file mode 100644
index f288bc0930..0000000000
--- a/xfa/src/fxfa/parser/xfa_parser_imp.h
+++ /dev/null
@@ -1,138 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_PARSER_IMP_H_
-#define XFA_SRC_FXFA_PARSER_XFA_PARSER_IMP_H_
-
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-
-class CXFA_XMLParser;
-
-class CXFA_SimpleParser : public IXFA_Parser {
- public:
-  CXFA_SimpleParser(IXFA_ObjFactory* pFactory, FX_BOOL bDocumentParser = FALSE);
-  ~CXFA_SimpleParser();
-  virtual void Release() { delete this; }
-
-  virtual int32_t StartParse(IFX_FileRead* pStream,
-                             XFA_XDPPACKET ePacketID = XFA_XDPPACKET_XDP);
-  virtual int32_t DoParse(IFX_Pause* pPause = NULL);
-  virtual int32_t ParseXMLData(const CFX_WideString& wsXML,
-                               IFDE_XMLNode*& pXMLNode,
-                               IFX_Pause* pPause = NULL);
-  virtual void ConstructXFANode(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode);
-  virtual IXFA_ObjFactory* GetFactory() const { return m_pFactory; }
-  virtual CXFA_Node* GetRootNode() const { return m_pRootNode; }
-  virtual IFDE_XMLDoc* GetXMLDoc() const { return m_pXMLDoc; }
-  virtual void CloseParser();
-
- protected:
-  CXFA_Node* ParseAsXDPPacket(IFDE_XMLNode* pXMLDocumentNode,
-                              XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_XDP(IFDE_XMLNode* pXMLDocumentNode,
-                                  XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_Config(IFDE_XMLNode* pXMLDocumentNode,
-                                     XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_TemplateForm(IFDE_XMLNode* pXMLDocumentNode,
-                                           XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_Data(IFDE_XMLNode* pXMLDocumentNode,
-                                   XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_LocaleConnectionSourceSet(
-      IFDE_XMLNode* pXMLDocumentNode,
-      XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_Xdc(IFDE_XMLNode* pXMLDocumentNode,
-                                  XFA_XDPPACKET ePacketID);
-  CXFA_Node* ParseAsXDPPacket_User(IFDE_XMLNode* pXMLDocumentNode,
-                                   XFA_XDPPACKET ePacketID);
-  CXFA_Node* NormalLoader(CXFA_Node* pXFANode,
-                          IFDE_XMLNode* pXMLDoc,
-                          XFA_XDPPACKET ePacketID,
-                          FX_BOOL bUseAttribute = TRUE);
-  CXFA_Node* DataLoader(CXFA_Node* pXFANode,
-                        IFDE_XMLNode* pXMLDoc,
-                        FX_BOOL bDoTransform);
-  CXFA_Node* UserPacketLoader(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLDoc);
-  void ParseContentNode(CXFA_Node* pXFANode,
-                        IFDE_XMLNode* pXMLNode,
-                        XFA_XDPPACKET ePacketID);
-  void ParseDataValue(CXFA_Node* pXFANode,
-                      IFDE_XMLNode* pXMLNode,
-                      XFA_XDPPACKET ePacketID);
-  void ParseDataGroup(CXFA_Node* pXFANode,
-                      IFDE_XMLNode* pXMLNode,
-                      XFA_XDPPACKET ePacketID);
-  void ParseInstruction(CXFA_Node* pXFANode,
-                        IFDE_XMLInstruction* pXMLInstruction,
-                        XFA_XDPPACKET ePacketID);
-  void SetFactory(IXFA_ObjFactory* pFactory);
-
-  CXFA_XMLParser* m_pXMLParser;
-  IFDE_XMLDoc* m_pXMLDoc;
-  IFX_Stream* m_pStream;
-  IFX_FileRead* m_pFileRead;
-  IXFA_ObjFactory* m_pFactory;
-  CXFA_Node* m_pRootNode;
-  XFA_XDPPACKET m_ePacketID;
-  FX_BOOL m_bDocumentParser;
-  friend class CXFA_DocumentParser;
-};
-
-class CXFA_DocumentParser : public IXFA_DocParser {
- public:
-  CXFA_DocumentParser(IXFA_Notify* pNotify);
-  ~CXFA_DocumentParser();
-  virtual void Release() { delete this; }
-  virtual int32_t StartParse(IFX_FileRead* pStream,
-                             XFA_XDPPACKET ePacketID = XFA_XDPPACKET_XDP);
-  virtual int32_t DoParse(IFX_Pause* pPause = NULL);
-  virtual int32_t ParseXMLData(const CFX_WideString& wsXML,
-                               IFDE_XMLNode*& pXMLNode,
-                               IFX_Pause* pPause = NULL);
-  virtual void ConstructXFANode(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode);
-  virtual IXFA_ObjFactory* GetFactory() const {
-    return m_nodeParser.GetFactory();
-  }
-  virtual CXFA_Node* GetRootNode() const { return m_nodeParser.GetRootNode(); }
-  virtual IFDE_XMLDoc* GetXMLDoc() const { return m_nodeParser.GetXMLDoc(); }
-  virtual IXFA_Notify* GetNotify() const { return m_pNotify; }
-  virtual CXFA_Document* GetDocument() const { return m_pDocument; }
-  virtual void CloseParser();
-
- protected:
-  CXFA_SimpleParser m_nodeParser;
-  IXFA_Notify* m_pNotify;
-  CXFA_Document* m_pDocument;
-};
-typedef CFX_StackTemplate<IFDE_XMLNode*> CXFA_XMLNodeStack;
-
-class CXFA_XMLParser : public IFDE_XMLParser {
- public:
-  CXFA_XMLParser(IFDE_XMLNode* pRoot, IFX_Stream* pStream);
-  ~CXFA_XMLParser();
-
-  virtual void Release() { delete this; }
-  virtual int32_t DoParser(IFX_Pause* pPause);
-
-  FX_FILESIZE m_nStart[2];
-  size_t m_nSize[2];
-  FX_FILESIZE m_nElementStart;
-  FX_WORD m_dwCheckStatus;
-  FX_WORD m_dwCurrentCheckStatus;
-
- protected:
-  IFDE_XMLNode* m_pRoot;
-  IFX_Stream* m_pStream;
-  IFDE_XMLSyntaxParser* m_pParser;
-
-  IFDE_XMLNode* m_pParent;
-  IFDE_XMLNode* m_pChild;
-  CXFA_XMLNodeStack m_NodeStack;
-  CFX_WideString m_ws1;
-  CFX_WideString m_ws2;
-  FX_DWORD m_dwStatus;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_PARSER_IMP_H_
diff --git a/xfa/src/fxfa/parser/xfa_parser_imp_embeddertest.cpp b/xfa/src/fxfa/parser/xfa_parser_imp_embeddertest.cpp
deleted file mode 100644
index 63fe272872..0000000000
--- a/xfa/src/fxfa/parser/xfa_parser_imp_embeddertest.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2015 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.
-
-#include "testing/embedder_test.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-class XFAParserImpEmbeddertest : public EmbedderTest {};
-
-TEST_F(XFAParserImpEmbeddertest, Bug_216) {
-  EXPECT_TRUE(OpenDocument("bug_216.pdf"));
-  FPDF_PAGE page = LoadPage(0);
-  EXPECT_NE(nullptr, page);
-  UnloadPage(page);
-}
diff --git a/xfa/src/fxfa/parser/xfa_script.h b/xfa/src/fxfa/parser/xfa_script.h
deleted file mode 100644
index 286e8f704e..0000000000
--- a/xfa/src/fxfa/parser/xfa_script.h
+++ /dev/null
@@ -1,121 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_H_
-
-#include "xfa/include/fxfa/fxfa.h"
-#include "xfa/include/fxfa/fxfa_objectacc.h"
-
-#define XFA_RESOLVENODE_Children 0x0001
-#define XFA_RESOLVENODE_Attributes 0x0004
-#define XFA_RESOLVENODE_Properties 0x0008
-#define XFA_RESOLVENODE_Siblings 0x0020
-#define XFA_RESOLVENODE_Parent 0x0040
-#define XFA_RESOLVENODE_AnyChild 0x0080
-#define XFA_RESOLVENODE_ALL 0x0100
-#define XFA_RESOLVENODE_CreateNode 0x0400
-#define XFA_RESOLVENODE_Bind 0x0800
-#define XFA_RESOLVENODE_BindNew 0x1000
-
-enum XFA_SCRIPTLANGTYPE {
-  XFA_SCRIPTLANGTYPE_Formcalc = XFA_SCRIPTTYPE_Formcalc,
-  XFA_SCRIPTLANGTYPE_Javascript = XFA_SCRIPTTYPE_Javascript,
-  XFA_SCRIPTLANGTYPE_Unkown = XFA_SCRIPTTYPE_Unkown,
-};
-
-enum XFA_RESOVENODE_RSTYPE {
-  XFA_RESOVENODE_RSTYPE_Nodes,
-  XFA_RESOVENODE_RSTYPE_Attribute,
-  XFA_RESOLVENODE_RSTYPE_CreateNodeOne,
-  XFA_RESOLVENODE_RSTYPE_CreateNodeAll,
-  XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll,
-  XFA_RESOVENODE_RSTYPE_ExistNodes,
-};
-
-class CXFA_HVALUEArray : public CFX_ArrayTemplate<FXJSE_HVALUE> {
- public:
-  CXFA_HVALUEArray(FXJSE_HRUNTIME hRunTime) : m_hRunTime(hRunTime) {}
-  ~CXFA_HVALUEArray() {
-    for (int32_t i = 0; i < GetSize(); i++) {
-      FXJSE_Value_Release(GetAt(i));
-    }
-  }
-  void GetAttributeObject(CXFA_ObjArray& objArray) {
-    for (int32_t i = 0; i < GetSize(); i++) {
-      CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(GetAt(i), NULL);
-      objArray.Add(pObject);
-    }
-  }
-  FXJSE_HRUNTIME m_hRunTime;
-};
-
-struct XFA_RESOLVENODE_RS {
-  XFA_RESOLVENODE_RS()
-      : dwFlags(XFA_RESOVENODE_RSTYPE_Nodes), pScriptAttribute(NULL) {}
-  ~XFA_RESOLVENODE_RS() { nodes.RemoveAll(); }
-  int32_t GetAttributeResult(CXFA_HVALUEArray& hValueArray) const {
-    if (pScriptAttribute && pScriptAttribute->eValueType == XFA_SCRIPT_Object) {
-      FXJSE_HRUNTIME hRunTime = hValueArray.m_hRunTime;
-      for (int32_t i = 0; i < nodes.GetSize(); i++) {
-        FXJSE_HVALUE hValue = FXJSE_Value_Create(hRunTime);
-        (nodes[i]->*(pScriptAttribute->lpfnCallback))(
-            hValue, FALSE, (XFA_ATTRIBUTE)pScriptAttribute->eAttribute);
-        hValueArray.Add(hValue);
-      }
-    }
-    return hValueArray.GetSize();
-  }
-
-  CXFA_ObjArray nodes;
-  XFA_RESOVENODE_RSTYPE dwFlags;
-  const XFA_SCRIPTATTRIBUTEINFO* pScriptAttribute;
-};
-
-struct XFA_JSBUILTININFO {
-  uint32_t uUnicodeHash;
-  const FX_CHAR* pName;
-};
-
-const XFA_JSBUILTININFO* XFA_GetJSBuiltinByHash(uint32_t uHashCode);
-
-class IXFA_ScriptContext {
- public:
-  virtual ~IXFA_ScriptContext() {}
-  virtual void Release() = 0;
-  virtual void Initialize(FXJSE_HRUNTIME hRuntime) = 0;
-
-  virtual void SetEventParam(CXFA_EventParam param) = 0;
-  virtual CXFA_EventParam* GetEventParam() = 0;
-  virtual FX_BOOL RunScript(XFA_SCRIPTLANGTYPE eScriptType,
-                            const CFX_WideStringC& wsScript,
-                            FXJSE_HVALUE hRetValue,
-                            CXFA_Object* pThisObject = NULL) = 0;
-  virtual int32_t ResolveObjects(CXFA_Object* refNode,
-                                 const CFX_WideStringC& wsExpression,
-                                 XFA_RESOLVENODE_RS& resolveNodeRS,
-                                 FX_DWORD dwStyles = XFA_RESOLVENODE_Children,
-                                 CXFA_Node* bindNode = NULL) = 0;
-  virtual FXJSE_HVALUE GetJSValueFromMap(CXFA_Object* pObject) = 0;
-  virtual void CacheList(CXFA_NodeList* pList) = 0;
-  virtual CXFA_Object* GetThisObject() const = 0;
-  virtual FXJSE_HRUNTIME GetRuntime() const = 0;
-  virtual int32_t GetIndexByName(CXFA_Node* refNode) = 0;
-  virtual int32_t GetIndexByClassName(CXFA_Node* refNode) = 0;
-  virtual void GetSomExpression(CXFA_Node* refNode,
-                                CFX_WideString& wsExpression) = 0;
-
-  virtual void SetNodesOfRunScript(CXFA_NodeArray* pArray) = 0;
-  virtual void AddNodesOfRunScript(const CXFA_NodeArray& nodes) = 0;
-  virtual void AddNodesOfRunScript(CXFA_Node* pNode) = 0;
-  virtual FXJSE_HCLASS GetJseNormalClass() = 0;
-  virtual XFA_SCRIPTLANGTYPE GetType() = 0;
-  virtual void SetRunAtType(XFA_ATTRIBUTEENUM eRunAt) = 0;
-  virtual FX_BOOL IsRunAtClient() = 0;
-};
-IXFA_ScriptContext* XFA_ScriptContext_Create(CXFA_Document* pDocument);
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_datawindow.cpp b/xfa/src/fxfa/parser/xfa_script_datawindow.cpp
deleted file mode 100644
index 33146adcd0..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_datawindow.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_datawindow.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CScript_DataWindow::CScript_DataWindow(CXFA_Document* pDocument)
-    : CXFA_OrdinaryObject(pDocument, XFA_ELEMENT_DataWindow) {
-  m_uScriptHash = XFA_HASHCODE_DataWindow;
-}
-CScript_DataWindow::~CScript_DataWindow() {}
-void CScript_DataWindow::Script_DataWindow_MoveCurrentRecord(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_DataWindow::Script_DataWindow_Record(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_DataWindow::Script_DataWindow_GotoRecord(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_DataWindow::Script_DataWindow_IsRecordGroup(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_DataWindow::Script_DataWindow_RecordsBefore(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {}
-void CScript_DataWindow::Script_DataWindow_CurrentRecordNumber(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {}
-void CScript_DataWindow::Script_DataWindow_RecordsAfter(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {}
-void CScript_DataWindow::Script_DataWindow_IsDefined(FXJSE_HVALUE hValue,
-                                                     FX_BOOL bSetting,
-                                                     XFA_ATTRIBUTE eAttribute) {
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_datawindow.h b/xfa/src/fxfa/parser/xfa_script_datawindow.h
deleted file mode 100644
index 2639d3c5d3..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_datawindow.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_DATAWINDOW_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_DATAWINDOW_H_
-
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-class CScript_DataWindow : public CXFA_OrdinaryObject {
- public:
-  CScript_DataWindow(CXFA_Document* pDocument);
-  virtual ~CScript_DataWindow();
-  void Script_DataWindow_MoveCurrentRecord(CFXJSE_Arguments* pArguments);
-  void Script_DataWindow_Record(CFXJSE_Arguments* pArguments);
-  void Script_DataWindow_GotoRecord(CFXJSE_Arguments* pArguments);
-  void Script_DataWindow_IsRecordGroup(CFXJSE_Arguments* pArguments);
-  void Script_DataWindow_RecordsBefore(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_DataWindow_CurrentRecordNumber(FXJSE_HVALUE hValue,
-                                             FX_BOOL bSetting,
-                                             XFA_ATTRIBUTE eAttribute);
-  void Script_DataWindow_RecordsAfter(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_DataWindow_IsDefined(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_DATAWINDOW_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_eventpseudomodel.cpp b/xfa/src/fxfa/parser/xfa_script_eventpseudomodel.cpp
deleted file mode 100644
index 8c8cd5214e..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_eventpseudomodel.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_eventpseudomodel.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CScript_EventPseudoModel::CScript_EventPseudoModel(CXFA_Document* pDocument)
-    : CXFA_OrdinaryObject(pDocument, XFA_ELEMENT_EventPseudoModel) {
-  m_uScriptHash = XFA_HASHCODE_Event;
-}
-CScript_EventPseudoModel::~CScript_EventPseudoModel() {}
-void Script_EventPseudoModel_StringProperty(FXJSE_HVALUE hValue,
-                                            CFX_WideString& wsValue,
-                                            FX_BOOL bSetting) {
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
-  } else {
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-  }
-}
-void Script_EventPseudoModel_InterProperty(FXJSE_HVALUE hValue,
-                                           int32_t& iValue,
-                                           FX_BOOL bSetting) {
-  if (bSetting) {
-    iValue = FXJSE_Value_ToInteger(hValue);
-  } else {
-    FXJSE_Value_SetInteger(hValue, iValue);
-  }
-}
-void Script_EventPseudoModel_BooleanProperty(FXJSE_HVALUE hValue,
-                                             FX_BOOL& bValue,
-                                             FX_BOOL bSetting) {
-  if (bSetting) {
-    bValue = FXJSE_Value_ToBoolean(hValue);
-  } else {
-    FXJSE_Value_SetBoolean(hValue, bValue);
-  }
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Property(
-    FXJSE_HVALUE hValue,
-    FX_DWORD dwFlag,
-    FX_BOOL bSetting) {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  CXFA_EventParam* pEventParam = pScriptContext->GetEventParam();
-  if (!pEventParam) {
-    return;
-  }
-  switch (dwFlag) {
-    case XFA_EVENT_CANCELACTION:
-      Script_EventPseudoModel_BooleanProperty(
-          hValue, pEventParam->m_bCancelAction, bSetting);
-      break;
-    case XFA_EVENT_CHANGE:
-      Script_EventPseudoModel_StringProperty(hValue, pEventParam->m_wsChange,
-                                             bSetting);
-      break;
-    case XFA_EVENT_COMMITKEY:
-      Script_EventPseudoModel_InterProperty(hValue, pEventParam->m_iCommitKey,
-                                            bSetting);
-      break;
-    case XFA_EVENT_FULLTEXT:
-      Script_EventPseudoModel_StringProperty(hValue, pEventParam->m_wsFullText,
-                                             bSetting);
-      break;
-    case XFA_EVENT_KEYDOWN:
-      Script_EventPseudoModel_BooleanProperty(hValue, pEventParam->m_bKeyDown,
-                                              bSetting);
-      break;
-    case XFA_EVENT_MODIFIER:
-      Script_EventPseudoModel_BooleanProperty(hValue, pEventParam->m_bModifier,
-                                              bSetting);
-      break;
-    case XFA_EVENT_NEWCONTENTTYPE:
-      Script_EventPseudoModel_StringProperty(
-          hValue, pEventParam->m_wsNewContentType, bSetting);
-      break;
-    case XFA_EVENT_NEWTEXT:
-      Script_EventPseudoModel_StringProperty(hValue, pEventParam->m_wsNewText,
-                                             bSetting);
-      break;
-    case XFA_EVENT_PREVCONTENTTYPE:
-      Script_EventPseudoModel_StringProperty(
-          hValue, pEventParam->m_wsPrevContentType, bSetting);
-      break;
-    case XFA_EVENT_PREVTEXT:
-      Script_EventPseudoModel_StringProperty(hValue, pEventParam->m_wsPrevText,
-                                             bSetting);
-      break;
-    case XFA_EVENT_REENTER:
-      Script_EventPseudoModel_BooleanProperty(hValue, pEventParam->m_bReenter,
-                                              bSetting);
-      break;
-    case XFA_EVENT_SELEND:
-      Script_EventPseudoModel_InterProperty(hValue, pEventParam->m_iSelEnd,
-                                            bSetting);
-      break;
-    case XFA_EVENT_SELSTART:
-      Script_EventPseudoModel_InterProperty(hValue, pEventParam->m_iSelStart,
-                                            bSetting);
-      break;
-    case XFA_EVENT_SHIFT:
-      Script_EventPseudoModel_BooleanProperty(hValue, pEventParam->m_bShift,
-                                              bSetting);
-      break;
-    case XFA_EVENT_SOAPFAULTCODE:
-      Script_EventPseudoModel_StringProperty(
-          hValue, pEventParam->m_wsSoapFaultCode, bSetting);
-      break;
-    case XFA_EVENT_SOAPFAULTSTRING:
-      Script_EventPseudoModel_StringProperty(
-          hValue, pEventParam->m_wsSoapFaultString, bSetting);
-      break;
-    case XFA_EVENT_TARGET:
-      break;
-    default:
-      break;
-  }
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_CancelAction(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_CANCELACTION, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Change(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_CHANGE, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_CommitKey(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_COMMITKEY, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_FullText(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_FULLTEXT, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_KeyDown(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_KEYDOWN, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Modifier(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_MODIFIER, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_NewContentType(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_NEWCONTENTTYPE, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_NewText(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_NEWTEXT, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_PrevContentType(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_PREVCONTENTTYPE, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_PrevText(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_PREVTEXT, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Reenter(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_REENTER, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_SelEnd(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_SELEND, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_SelStart(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_SELSTART, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Shift(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_SHIFT, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_SoapFaultCode(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_SOAPFAULTCODE, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_SoapFaultString(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_SOAPFAULTSTRING, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Target(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  Script_EventPseudoModel_Property(hValue, XFA_EVENT_TARGET, bSetting);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Emit(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  CXFA_EventParam* pEventParam = pScriptContext->GetEventParam();
-  if (!pEventParam) {
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_WidgetHandler* pWidgetHandler = pNotify->GetWidgetHandler();
-  if (!pWidgetHandler) {
-    return;
-  }
-  pWidgetHandler->ProcessEvent(pEventParam->m_pTarget, pEventParam);
-}
-void CScript_EventPseudoModel::Script_EventPseudoModel_Reset(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
-    return;
-  }
-  CXFA_EventParam* pEventParam = pScriptContext->GetEventParam();
-  if (!pEventParam) {
-    return;
-  }
-  pEventParam->Reset();
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_eventpseudomodel.h b/xfa/src/fxfa/parser/xfa_script_eventpseudomodel.h
deleted file mode 100644
index 770ec2e4b9..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_eventpseudomodel.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_EVENTPSEUDOMODEL_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_EVENTPSEUDOMODEL_H_
-
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-#define XFA_EVENT_CHANGE 0
-#define XFA_EVENT_COMMITKEY 1
-#define XFA_EVENT_FULLTEXT 2
-#define XFA_EVENT_KEYDOWN 3
-#define XFA_EVENT_MODIFIER 4
-#define XFA_EVENT_NEWCONTENTTYPE 5
-#define XFA_EVENT_NEWTEXT 6
-#define XFA_EVENT_PREVCONTENTTYPE 7
-#define XFA_EVENT_PREVTEXT 8
-#define XFA_EVENT_REENTER 9
-#define XFA_EVENT_SELEND 10
-#define XFA_EVENT_SELSTART 11
-#define XFA_EVENT_SHIFT 12
-#define XFA_EVENT_SOAPFAULTCODE 13
-#define XFA_EVENT_SOAPFAULTSTRING 14
-#define XFA_EVENT_TARGET 15
-#define XFA_EVENT_CANCELACTION 16
-
-class CScript_EventPseudoModel : public CXFA_OrdinaryObject {
- public:
-  explicit CScript_EventPseudoModel(CXFA_Document* pDocument);
-  virtual ~CScript_EventPseudoModel();
-
-  void Script_EventPseudoModel_CancelAction(FXJSE_HVALUE hValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_Change(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_CommitKey(FXJSE_HVALUE hValue,
-                                         FX_BOOL bSetting,
-                                         XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_FullText(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_KeyDown(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_Modifier(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_NewContentType(FXJSE_HVALUE hValue,
-                                              FX_BOOL bSetting,
-                                              XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_NewText(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_PrevContentType(FXJSE_HVALUE hValue,
-                                               FX_BOOL bSetting,
-                                               XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_PrevText(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_Reenter(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_SelEnd(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_SelStart(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_Shift(FXJSE_HVALUE hValue,
-                                     FX_BOOL bSetting,
-                                     XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_SoapFaultCode(FXJSE_HVALUE hValue,
-                                             FX_BOOL bSetting,
-                                             XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_SoapFaultString(FXJSE_HVALUE hValue,
-                                               FX_BOOL bSetting,
-                                               XFA_ATTRIBUTE eAttribute);
-  void Script_EventPseudoModel_Target(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-
-  void Script_EventPseudoModel_Emit(CFXJSE_Arguments* pArguments);
-  void Script_EventPseudoModel_Reset(CFXJSE_Arguments* pArguments);
-
- protected:
-  void Script_EventPseudoModel_Property(FXJSE_HVALUE hValue,
-                                        FX_DWORD dwFlag,
-                                        FX_BOOL bSetting);
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_EVENTPSEUDOMODEL_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_hostpseudomodel.cpp b/xfa/src/fxfa/parser/xfa_script_hostpseudomodel.cpp
deleted file mode 100644
index 4e5be8f3c4..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_hostpseudomodel.cpp
+++ /dev/null
@@ -1,800 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_hostpseudomodel.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CScript_HostPseudoModel::CScript_HostPseudoModel(CXFA_Document* pDocument)
-    : CXFA_OrdinaryObject(pDocument, XFA_ELEMENT_HostPseudoModel) {
-  m_uScriptHash = XFA_HASHCODE_Host;
-}
-CScript_HostPseudoModel::~CScript_HostPseudoModel() {}
-void CScript_HostPseudoModel::Script_HostPseudoModel_LoadString(
-    FXJSE_HVALUE hValue,
-    IXFA_Notify* pNotify,
-    FX_DWORD dwFlag) {
-  CFX_WideString wsValue;
-  pNotify->GetAppProvider()->LoadString(dwFlag, wsValue);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_AppType(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CFX_WideString wsAppType;
-  pNotify->GetAppProvider()->GetAppType(wsAppType);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsAppType));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_FoxitAppType(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CFX_WideString wsAppType;
-  pNotify->GetAppProvider()->GetFoxitAppType(wsAppType);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsAppType));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_CalculationsEnabled(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  if (bSetting) {
-    pNotify->GetDocProvider()->SetCalculationsEnabled(
-        hDoc, FXJSE_Value_ToBoolean(hValue));
-    return;
-  }
-  FX_BOOL bEnabled = pNotify->GetDocProvider()->IsCalculationsEnabled(hDoc);
-  FXJSE_Value_SetBoolean(hValue, bEnabled);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_CurrentPage(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  if (bSetting) {
-    pNotify->GetDocProvider()->SetCurrentPage(hDoc,
-                                              FXJSE_Value_ToInteger(hValue));
-    return;
-  }
-  int32_t iCurrentPage = pNotify->GetDocProvider()->GetCurrentPage(hDoc);
-  FXJSE_Value_SetInteger(hValue, iCurrentPage);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Language(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_LANGUAGE);
-    return;
-  }
-  CFX_WideString wsLanguage;
-  pNotify->GetAppProvider()->GetLanguage(wsLanguage);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsLanguage));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_NumPages(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_NUMPAGES);
-    return;
-  }
-  int32_t iNumPages = pNotify->GetDocProvider()->CountPages(hDoc);
-  FXJSE_Value_SetInteger(hValue, iNumPages);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Platform(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_PLATFORM);
-    return;
-  }
-  CFX_WideString wsPlatform;
-  pNotify->GetAppProvider()->GetPlatform(wsPlatform);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsPlatform));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Title(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  if (bSetting) {
-    CFX_ByteString bsValue;
-    FXJSE_Value_ToUTF8String(hValue, bsValue);
-    pNotify->GetDocProvider()->SetTitle(
-        hDoc, CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()));
-    return;
-  }
-  CFX_WideString wsTitle;
-  pNotify->GetDocProvider()->GetTitle(hDoc, wsTitle);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsTitle));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_ValidationsEnabled(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  if (bSetting) {
-    pNotify->GetDocProvider()->SetValidationsEnabled(
-        hDoc, FXJSE_Value_ToBoolean(hValue));
-    return;
-  }
-  FX_BOOL bEnabled = pNotify->GetDocProvider()->IsValidationsEnabled(hDoc);
-  FXJSE_Value_SetBoolean(hValue, bEnabled);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Variation(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_VARIATION);
-    return;
-  }
-  CFX_WideString wsVariation;
-  pNotify->GetAppProvider()->GetVariation(wsVariation);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsVariation));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Version(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_VERSION);
-    return;
-  }
-  CFX_WideString wsVersion;
-  pNotify->GetAppProvider()->GetVersion(wsVersion);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsVersion));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_FoxitVersion(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_VERSION);
-    return;
-  }
-  CFX_WideString wsVersion;
-  pNotify->GetAppProvider()->GetFoxitVersion(wsVersion);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsVersion));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Name(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CFX_WideString wsAppName;
-  pNotify->GetAppProvider()->GetAppName(wsAppName);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsAppName));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_FoxitName(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-    return;
-  }
-  CFX_WideString wsFoxitAppName;
-  pNotify->GetAppProvider()->GetFoxitAppName(wsFoxitAppName);
-  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsFoxitAppName));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_GotoURL(
-    CFXJSE_Arguments* pArguments) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"gotoURL");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  CFX_WideString wsURL;
-  if (iLength >= 1) {
-    CFX_ByteString bsURL = pArguments->GetUTF8String(0);
-    wsURL = CFX_WideString::FromUTF8(bsURL, bsURL.GetLength());
-  }
-  pNotify->GetDocProvider()->GotoURL(hDoc, wsURL);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_OpenList(
-    CFXJSE_Arguments* pArguments) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"openList");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    FXJSE_HVALUE hValue = pArguments->GetValue(0);
-    if (FXJSE_Value_IsObject(hValue)) {
-      pNode = static_cast<CXFA_Node*>(FXJSE_Value_ToObject(hValue, nullptr));
-    } else if (FXJSE_Value_IsUTF8String(hValue)) {
-      CFX_ByteString bsString;
-      FXJSE_Value_ToUTF8String(hValue, bsString);
-      CFX_WideString wsExpression =
-          CFX_WideString::FromUTF8(bsString, bsString.GetLength());
-      IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-      if (!pScriptContext) {
-        FXJSE_Value_Release(hValue);
-        return;
-      }
-      CXFA_Object* pObject = pScriptContext->GetThisObject();
-      if (!pObject) {
-        FXJSE_Value_Release(hValue);
-        return;
-      }
-      FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Parent |
-                        XFA_RESOLVENODE_Siblings;
-      XFA_RESOLVENODE_RS resoveNodeRS;
-      int32_t iRet = pScriptContext->ResolveObjects(pObject, wsExpression,
-                                                    resoveNodeRS, dwFlag);
-      if (iRet < 1 || !resoveNodeRS.nodes[0]->IsNode()) {
-        FXJSE_Value_Release(hValue);
-        return;
-      }
-      pNode = resoveNodeRS.nodes[0]->AsNode();
-    }
-    FXJSE_Value_Release(hValue);
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  IXFA_Widget* hWidget = pNotify->GetHWidget(pDocLayout->GetLayoutItem(pNode));
-  if (!hWidget) {
-    return;
-  }
-  pNotify->GetDocProvider()->SetFocusWidget(pNotify->GetHDOC(), hWidget);
-  pNotify->OpenDropDownList(hWidget);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Response(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 4) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"response");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CFX_WideString wsQuestion;
-  CFX_WideString wsTitle;
-  CFX_WideString wsDefaultAnswer;
-  FX_BOOL bMark = FALSE;
-  if (iLength >= 1) {
-    CFX_ByteString bsQuestion = pArguments->GetUTF8String(0);
-    wsQuestion = CFX_WideString::FromUTF8(bsQuestion, bsQuestion.GetLength());
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsTitle = pArguments->GetUTF8String(1);
-    wsTitle = CFX_WideString::FromUTF8(bsTitle, bsTitle.GetLength());
-  }
-  if (iLength >= 3) {
-    CFX_ByteString bsDefaultAnswer = pArguments->GetUTF8String(2);
-    wsDefaultAnswer =
-        CFX_WideString::FromUTF8(bsDefaultAnswer, bsDefaultAnswer.GetLength());
-  }
-  if (iLength >= 4) {
-    bMark = pArguments->GetInt32(3) == 0 ? FALSE : TRUE;
-  }
-  CFX_WideString wsAnswer;
-  pNotify->GetAppProvider()->Response(wsAnswer, wsQuestion, wsTitle,
-                                      wsDefaultAnswer, bMark);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsAnswer));
-  }
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_DocumentInBatch(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  int32_t iCur = pNotify->GetAppProvider()->GetCurDocumentInBatch();
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iCur);
-  }
-}
-static int32_t XFA_FilterName(const CFX_WideStringC& wsExpression,
-                              int32_t nStart,
-                              CFX_WideString& wsFilter) {
-  FXSYS_assert(nStart > -1);
-  int32_t iLength = wsExpression.GetLength();
-  if (nStart >= iLength) {
-    return iLength;
-  }
-  FX_WCHAR* pBuf = wsFilter.GetBuffer(iLength - nStart);
-  int32_t nCount = 0;
-  const FX_WCHAR* pSrc = wsExpression.GetPtr();
-  FX_WCHAR wCur;
-  while (nStart < iLength) {
-    wCur = pSrc[nStart++];
-    if (wCur == ',') {
-      break;
-    }
-    pBuf[nCount++] = wCur;
-  }
-  wsFilter.ReleaseBuffer(nCount);
-  wsFilter.TrimLeft();
-  wsFilter.TrimRight();
-  return nStart;
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_ResetData(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 0 || iLength > 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resetData");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CFX_WideString wsExpression;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression =
-        CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  }
-  if (wsExpression.IsEmpty()) {
-    pNotify->ResetData();
-    return;
-  }
-  int32_t iStart = 0;
-  CFX_WideString wsName;
-  CXFA_Node* pNode = NULL;
-  int32_t iExpLength = wsExpression.GetLength();
-  while (iStart < iExpLength) {
-    iStart = XFA_FilterName(wsExpression, iStart, wsName);
-    IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-    if (!pScriptContext) {
-      return;
-    }
-    CXFA_Object* pObject = pScriptContext->GetThisObject();
-    if (!pObject) {
-      return;
-    }
-    FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Parent |
-                      XFA_RESOLVENODE_Siblings;
-    XFA_RESOLVENODE_RS resoveNodeRS;
-    int32_t iRet =
-        pScriptContext->ResolveObjects(pObject, wsName, resoveNodeRS, dwFlag);
-    if (iRet < 1 || !resoveNodeRS.nodes[0]->IsNode()) {
-      continue;
-    }
-    pNode = resoveNodeRS.nodes[0]->AsNode();
-    pNotify->ResetData(pNode->GetWidgetData());
-  }
-  if (!pNode) {
-    pNotify->ResetData();
-  }
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Beep(
-    CFXJSE_Arguments* pArguments) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 0 || iLength > 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"beep");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  FX_DWORD dwType = 4;
-  if (iLength >= 1) {
-    dwType = pArguments->GetInt32(0);
-  }
-  pNotify->GetAppProvider()->Beep(dwType);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_SetFocus(
-    CFXJSE_Arguments* pArguments) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setFocus");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    FXJSE_HVALUE hValue = pArguments->GetValue(0);
-    if (FXJSE_Value_IsObject(hValue)) {
-      pNode = static_cast<CXFA_Node*>(FXJSE_Value_ToObject(hValue, NULL));
-    } else if (FXJSE_Value_IsUTF8String(hValue)) {
-      CFX_ByteString bsString;
-      FXJSE_Value_ToUTF8String(hValue, bsString);
-      CFX_WideString wsExpression =
-          CFX_WideString::FromUTF8(bsString, bsString.GetLength());
-      IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-      if (!pScriptContext) {
-        FXJSE_Value_Release(hValue);
-        return;
-      }
-      CXFA_Object* pObject = pScriptContext->GetThisObject();
-      if (!pObject) {
-        FXJSE_Value_Release(hValue);
-        return;
-      }
-      FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Parent |
-                        XFA_RESOLVENODE_Siblings;
-      XFA_RESOLVENODE_RS resoveNodeRS;
-      int32_t iRet = pScriptContext->ResolveObjects(pObject, wsExpression,
-                                                    resoveNodeRS, dwFlag);
-      if (iRet < 1 || !resoveNodeRS.nodes[0]->IsNode()) {
-        FXJSE_Value_Release(hValue);
-        return;
-      }
-      pNode = resoveNodeRS.nodes[0]->AsNode();
-    }
-    FXJSE_Value_Release(hValue);
-  }
-  pNotify->SetFocusWidgetNode(pNode);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_GetFocus(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CXFA_Node* pNode = pNotify->GetFocusWidgetNode();
-  if (!pNode) {
-    return;
-  }
-  FXJSE_Value_Set(pArguments->GetReturnValue(),
-                  m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_MessageBox(
-    CFXJSE_Arguments* pArguments) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 4) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"messageBox");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CFX_WideString wsMessage;
-  CFX_WideString bsTitle;
-  FX_DWORD dwMessageType = XFA_MBICON_Error;
-  FX_DWORD dwButtonType = XFA_MB_OK;
-  if (iLength >= 1) {
-    if (!Script_HostPseudoModel_ValidateArgsForMsg(pArguments, 0, wsMessage)) {
-      return;
-    }
-  }
-  if (iLength >= 2) {
-    if (!Script_HostPseudoModel_ValidateArgsForMsg(pArguments, 1, bsTitle)) {
-      return;
-    }
-  }
-  if (iLength >= 3) {
-    dwMessageType = pArguments->GetInt32(2);
-    if (dwMessageType > XFA_MBICON_Status) {
-      dwMessageType = XFA_MBICON_Error;
-    }
-  }
-  if (iLength >= 4) {
-    dwButtonType = pArguments->GetInt32(3);
-    if (dwButtonType > XFA_MB_YesNoCancel) {
-      dwButtonType = XFA_MB_OK;
-    }
-  }
-  int32_t iValue = pNotify->GetAppProvider()->MsgBox(
-      wsMessage, bsTitle, dwMessageType, dwButtonType);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iValue);
-  }
-}
-FX_BOOL CScript_HostPseudoModel::Script_HostPseudoModel_ValidateArgsForMsg(
-    CFXJSE_Arguments* pArguments,
-    int32_t iArgIndex,
-    CFX_WideString& wsValue) {
-  if (pArguments == NULL || iArgIndex < 0) {
-    return FALSE;
-  }
-  FX_BOOL bIsJsType = FALSE;
-  if (m_pDocument->GetScriptContext()->GetType() ==
-      XFA_SCRIPTLANGTYPE_Javascript) {
-    bIsJsType = TRUE;
-  }
-  FXJSE_HVALUE hValueArg = pArguments->GetValue(iArgIndex);
-  if (!FXJSE_Value_IsUTF8String(hValueArg) && bIsJsType) {
-    ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
-    FXJSE_Value_Release(hValueArg);
-    return FALSE;
-  }
-  if (FXJSE_Value_IsNull(hValueArg)) {
-    wsValue = FX_WSTRC(L"");
-  } else {
-    CFX_ByteString byMessage;
-    FXJSE_Value_ToUTF8String(hValueArg, byMessage);
-    wsValue = CFX_WideString::FromUTF8(byMessage, byMessage.GetLength());
-  }
-  FXJSE_Value_Release(hValueArg);
-  return TRUE;
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_DocumentCountInBatch(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  int32_t iValue = pNotify->GetAppProvider()->GetDocumentCountInBatch();
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iValue);
-  }
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_Print(
-    CFXJSE_Arguments* pArguments) {
-  if (!m_pDocument->GetScriptContext()->IsRunAtClient()) {
-    return;
-  }
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 8) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"print");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  FX_DWORD dwOptions = 0;
-  FX_BOOL bShowDialog = TRUE;
-  if (iLength >= 1) {
-    bShowDialog = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
-  }
-  if (bShowDialog) {
-    dwOptions |= XFA_PRINTOPT_ShowDialog;
-  }
-  int32_t nStartPage = 0;
-  if (iLength >= 2) {
-    nStartPage = pArguments->GetInt32(1);
-  }
-  int32_t nEndPage = 0;
-  if (iLength >= 3) {
-    nEndPage = pArguments->GetInt32(2);
-  }
-  FX_BOOL bCanCancel = TRUE;
-  if (iLength >= 4) {
-    bCanCancel = pArguments->GetInt32(3) == 0 ? FALSE : TRUE;
-  }
-  if (bCanCancel) {
-    dwOptions |= XFA_PRINTOPT_CanCancel;
-  }
-  FX_BOOL bShrinkPage = TRUE;
-  if (iLength >= 5) {
-    bShrinkPage = pArguments->GetInt32(4) == 0 ? FALSE : TRUE;
-  }
-  if (bShrinkPage) {
-    dwOptions |= XFA_PRINTOPT_ShrinkPage;
-  }
-  FX_BOOL bAsImage = TRUE;
-  if (iLength >= 6) {
-    bAsImage = pArguments->GetInt32(5) == 0 ? FALSE : TRUE;
-  }
-  if (bAsImage) {
-    dwOptions |= XFA_PRINTOPT_AsImage;
-  }
-  FX_BOOL bReverseOrder = TRUE;
-  if (iLength >= 7) {
-    bAsImage = pArguments->GetInt32(5) == 0 ? FALSE : TRUE;
-  }
-  bReverseOrder = pArguments->GetInt32(6) == 0 ? FALSE : TRUE;
-  if (bReverseOrder) {
-    dwOptions |= XFA_PRINTOPT_ReverseOrder;
-  }
-  FX_BOOL bPrintAnnot = TRUE;
-  if (iLength >= 8) {
-    bPrintAnnot = pArguments->GetInt32(7) == 0 ? FALSE : TRUE;
-  }
-  if (bPrintAnnot) {
-    dwOptions |= XFA_PRINTOPT_PrintAnnot;
-  }
-  pNotify->GetDocProvider()->Print(hDoc, nStartPage, nEndPage, dwOptions);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_ImportData(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 0 || iLength > 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"importData");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CFX_WideString wsFilePath;
-  if (iLength > 0) {
-    CFX_ByteString bsFilePath = pArguments->GetUTF8String(0);
-    wsFilePath = CFX_WideString::FromUTF8(bsFilePath, bsFilePath.GetLength());
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  pNotify->GetDocProvider()->ImportData(hDoc, wsFilePath);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_ExportData(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 0 || iLength > 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"exportData");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  CFX_WideString wsFilePath;
-  FX_BOOL bXDP = TRUE;
-  if (iLength >= 1) {
-    CFX_ByteString bsFilePath = pArguments->GetUTF8String(0);
-    wsFilePath = CFX_WideString::FromUTF8(bsFilePath, bsFilePath.GetLength());
-  }
-  if (iLength >= 2) {
-    bXDP = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
-  }
-  pNotify->GetDocProvider()->ExportData(hDoc, wsFilePath, bXDP);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_PageUp(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  int32_t nCurPage = pNotify->GetDocProvider()->GetCurrentPage(hDoc);
-  int32_t nNewPage = 0;
-  if (nCurPage <= 1) {
-    return;
-  }
-  nNewPage = nCurPage - 1;
-  pNotify->GetDocProvider()->SetCurrentPage(hDoc, nNewPage);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_PageDown(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  int32_t nCurPage = pNotify->GetDocProvider()->GetCurrentPage(hDoc);
-  int32_t nPageCount = pNotify->GetDocProvider()->CountPages(hDoc);
-  if (!nPageCount || nCurPage == nPageCount) {
-    return;
-  }
-  int32_t nNewPage = 0;
-  if (nCurPage >= nPageCount) {
-    nNewPage = nPageCount - 1;
-  } else {
-    nNewPage = nCurPage + 1;
-  }
-  pNotify->GetDocProvider()->SetCurrentPage(hDoc, nNewPage);
-}
-void CScript_HostPseudoModel::Script_HostPseudoModel_CurrentDateTime(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  CFX_WideString wsDataTime = pNotify->GetCurrentDateTime();
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsDataTime));
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_hostpseudomodel.h b/xfa/src/fxfa/parser/xfa_script_hostpseudomodel.h
deleted file mode 100644
index 7154a255f6..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_hostpseudomodel.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_HOSTPSEUDOMODEL_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_HOSTPSEUDOMODEL_H_
-
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-class CScript_HostPseudoModel : public CXFA_OrdinaryObject {
- public:
-  CScript_HostPseudoModel(CXFA_Document* pDocument);
-  virtual ~CScript_HostPseudoModel();
-
-  void Script_HostPseudoModel_AppType(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_FoxitAppType(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_CalculationsEnabled(FXJSE_HVALUE hValue,
-                                                  FX_BOOL bSetting,
-                                                  XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_CurrentPage(FXJSE_HVALUE hValue,
-                                          FX_BOOL bSetting,
-                                          XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_Language(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_NumPages(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_Platform(FXJSE_HVALUE hValue,
-                                       FX_BOOL bSetting,
-                                       XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_Title(FXJSE_HVALUE hValue,
-                                    FX_BOOL bSetting,
-                                    XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_ValidationsEnabled(FXJSE_HVALUE hValue,
-                                                 FX_BOOL bSetting,
-                                                 XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_Variation(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_Version(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_FoxitVersion(FXJSE_HVALUE hValue,
-                                           FX_BOOL bSetting,
-                                           XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_Name(FXJSE_HVALUE hValue,
-                                   FX_BOOL bSetting,
-                                   XFA_ATTRIBUTE eAttribute);
-  void Script_HostPseudoModel_FoxitName(FXJSE_HVALUE hValue,
-                                        FX_BOOL bSetting,
-                                        XFA_ATTRIBUTE eAttribute);
-
-  void Script_HostPseudoModel_GotoURL(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_OpenList(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_Response(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_DocumentInBatch(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_ResetData(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_Beep(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_SetFocus(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_GetFocus(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_MessageBox(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_DocumentCountInBatch(
-      CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_Print(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_ImportData(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_ExportData(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_PageUp(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_PageDown(CFXJSE_Arguments* pArguments);
-  void Script_HostPseudoModel_CurrentDateTime(CFXJSE_Arguments* pArguments);
-
- protected:
-  void Script_HostPseudoModel_LoadString(FXJSE_HVALUE hValue,
-                                         IXFA_Notify* pNotify,
-                                         FX_DWORD dwFlag);
-  FX_BOOL Script_HostPseudoModel_ValidateArgsForMsg(
-      CFXJSE_Arguments* pArguments,
-      int32_t iArgIndex,
-      CFX_WideString& wsValue);
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_HOSTPSEUDOMODEL_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_imp.cpp b/xfa/src/fxfa/parser/xfa_script_imp.cpp
deleted file mode 100644
index 3682580eb5..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_imp.cpp
+++ /dev/null
@@ -1,781 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_imp.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_script_nodehelper.h"
-#include "xfa/src/fxfa/parser/xfa_script_resolveprocessor.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_ScriptContext::CXFA_ScriptContext(CXFA_Document* pDocument)
-    : m_pDocument(pDocument),
-      m_hJsContext(nullptr),
-      m_hJsRuntime(nullptr),
-      m_hJsClass(nullptr),
-      m_eScriptType(XFA_SCRIPTLANGTYPE_Unkown),
-      m_pScriptNodeArray(nullptr),
-      m_pResolveProcessor(nullptr),
-      m_hFM2JSContext(nullptr),
-      m_pThisObject(nullptr),
-      m_dwBuiltInInFlags(0),
-      m_eRunAtType(XFA_ATTRIBUTEENUM_Client) {
-  FXSYS_memset(&m_JsGlobalClass, 0, sizeof(FXJSE_CLASS));
-  FXSYS_memset(&m_JsNormalClass, 0, sizeof(FXJSE_CLASS));
-}
-CXFA_ScriptContext::~CXFA_ScriptContext() {
-  FX_POSITION ps = m_mapXFAToHValue.GetStartPosition();
-  while (ps) {
-    CXFA_Object* pXFAObj;
-    FXJSE_HVALUE pValue;
-    m_mapXFAToHValue.GetNextAssoc(ps, pXFAObj, pValue);
-    FXJSE_Value_Release(pValue);
-  }
-  m_mapXFAToHValue.RemoveAll();
-  ReleaseVariablesMap();
-  if (m_hFM2JSContext) {
-    XFA_FM2JS_ContextRelease(m_hFM2JSContext);
-    m_hFM2JSContext = NULL;
-  }
-  if (m_hJsContext) {
-    FXJSE_Context_Release(m_hJsContext);
-    m_hJsContext = NULL;
-  }
-  if (m_pResolveProcessor) {
-    delete m_pResolveProcessor;
-    m_pResolveProcessor = NULL;
-  }
-  m_upObjectArray.RemoveAll();
-  for (int32_t i = 0; i < m_CacheListArray.GetSize(); i++) {
-    delete ((CXFA_NodeList*)m_CacheListArray[i]);
-  }
-  m_CacheListArray.RemoveAll();
-}
-void CXFA_ScriptContext::Initialize(FXJSE_HRUNTIME hRuntime) {
-  m_hJsRuntime = hRuntime;
-  DefineJsContext();
-  DefineJsClass();
-  m_pResolveProcessor = new CXFA_ResolveProcessor;
-}
-void CXFA_ScriptContext::Release() {
-  delete this;
-}
-FX_BOOL CXFA_ScriptContext::RunScript(XFA_SCRIPTLANGTYPE eScriptType,
-                                      const CFX_WideStringC& wsScript,
-                                      FXJSE_HVALUE hRetValue,
-                                      CXFA_Object* pThisObject) {
-  CFX_ByteString btScript;
-  XFA_SCRIPTLANGTYPE eSaveType = m_eScriptType;
-  m_eScriptType = eScriptType;
-  if (eScriptType == XFA_SCRIPTLANGTYPE_Formcalc) {
-    if (!m_hFM2JSContext) {
-      m_hFM2JSContext = XFA_FM2JS_ContextCreate();
-      XFA_FM2JS_ContextInitialize(m_hFM2JSContext, m_hJsRuntime, m_hJsContext,
-                                  m_pDocument);
-    }
-    CFX_WideTextBuf wsJavaScript;
-    CFX_WideString wsErrorInfo;
-    int32_t iFlags = XFA_FM2JS_Translate(wsScript, wsJavaScript, wsErrorInfo);
-    if (iFlags) {
-      FXJSE_Value_SetUndefined(hRetValue);
-      return FALSE;
-    }
-    btScript =
-        FX_UTF8Encode(wsJavaScript.GetBuffer(), wsJavaScript.GetLength());
-  } else {
-    btScript = FX_UTF8Encode(wsScript.GetPtr(), wsScript.GetLength());
-  }
-  CXFA_Object* pOriginalObject = m_pThisObject;
-  m_pThisObject = pThisObject;
-  FXJSE_HVALUE pValue = pThisObject ? GetJSValueFromMap(pThisObject) : NULL;
-  FX_BOOL bRet = FXJSE_ExecuteScript(m_hJsContext, btScript, hRetValue, pValue);
-  m_pThisObject = pOriginalObject;
-  m_eScriptType = eSaveType;
-  return bRet;
-}
-void CXFA_ScriptContext::GlobalPropertySetter(FXJSE_HOBJECT hObject,
-                                              const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* lpOrginalNode =
-      (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-  CXFA_Document* pDoc = lpOrginalNode->GetDocument();
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pDoc->GetScriptContext();
-  CXFA_Object* lpCurNode = lpScriptContext->GetVariablesThis(lpOrginalNode);
-  CFX_WideString wsPropName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szPropName.GetPtr(), szPropName.GetLength());
-  FX_DWORD dwFlag = XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings |
-                    XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
-                    XFA_RESOLVENODE_Attributes;
-  CXFA_Node* pRefNode = ToNode(lpScriptContext->GetThisObject());
-  if (lpOrginalNode->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
-    pRefNode = ToNode(lpCurNode);
-  }
-  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName, hValue, dwFlag,
-                                       TRUE)) {
-    return;
-  }
-  if (lpOrginalNode->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
-    if (FXJSE_Value_IsUndefined(hValue)) {
-      FXJSE_Value_SetObjectOwnProp(hObject, szPropName, hValue);
-      return;
-    }
-  }
-  IXFA_Notify* pNotify = pDoc->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  pNotify->GetDocProvider()->SetGlobalProperty(pNotify->GetHDOC(), szPropName,
-                                               hValue);
-}
-FX_BOOL CXFA_ScriptContext::QueryNodeByFlag(CXFA_Node* refNode,
-                                            const CFX_WideStringC& propname,
-                                            FXJSE_HVALUE hValue,
-                                            FX_DWORD dwFlag,
-                                            FX_BOOL bSetting) {
-  if (!refNode)
-    return false;
-  XFA_RESOLVENODE_RS resolveRs;
-  if (ResolveObjects(refNode, propname, resolveRs, dwFlag) <= 0)
-    return false;
-  if (resolveRs.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
-    FXJSE_HVALUE pValue = GetJSValueFromMap(resolveRs.nodes[0]);
-    FXJSE_Value_Set(hValue, pValue);
-    return true;
-  }
-  if (resolveRs.dwFlags == XFA_RESOVENODE_RSTYPE_Attribute) {
-    const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo = resolveRs.pScriptAttribute;
-    if (lpAttributeInfo) {
-      (resolveRs.nodes[0]->*(lpAttributeInfo->lpfnCallback))(
-          hValue, bSetting, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
-    }
-  }
-  return true;
-}
-void CXFA_ScriptContext::GlobalPropertyGetter(FXJSE_HOBJECT hObject,
-                                              const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* pOrginalObject =
-      (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-  CXFA_Document* pDoc = pOrginalObject->GetDocument();
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pDoc->GetScriptContext();
-  CXFA_Object* lpCurNode = lpScriptContext->GetVariablesThis(pOrginalObject);
-  CFX_WideString wsPropName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szPropName.GetPtr(), szPropName.GetLength());
-  if (lpScriptContext->GetType() == XFA_SCRIPTLANGTYPE_Formcalc) {
-    if (szPropName == FOXIT_XFA_FM2JS_FORMCALC_RUNTIME) {
-      XFA_FM2JS_GlobalPropertyGetter(lpScriptContext->m_hFM2JSContext, hValue);
-      return;
-    }
-    uint32_t uHashCode =
-        FX_HashCode_String_GetW(wsPropName, wsPropName.GetLength());
-    if (uHashCode != XFA_HASHCODE_Layout) {
-      CXFA_Object* pObject =
-          lpScriptContext->GetDocument()->GetXFAObject(uHashCode);
-      if (pObject) {
-        FXJSE_Value_Set(hValue, lpScriptContext->GetJSValueFromMap(pObject));
-        return;
-      }
-    }
-  }
-  FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
-                    XFA_RESOLVENODE_Attributes;
-  CXFA_Node* pRefNode = ToNode(lpScriptContext->GetThisObject());
-  if (pOrginalObject->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
-    pRefNode = ToNode(lpCurNode);
-  }
-  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName, hValue, dwFlag,
-                                       FALSE)) {
-    return;
-  }
-  dwFlag = XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
-  if (lpScriptContext->QueryNodeByFlag(pRefNode, wsPropName, hValue, dwFlag,
-                                       FALSE)) {
-    return;
-  }
-  CXFA_Object* pScriptObject =
-      lpScriptContext->GetVariablesThis(pOrginalObject, TRUE);
-  if (pScriptObject &&
-      lpScriptContext->QueryVariableHValue(pScriptObject->AsNode(), szPropName,
-                                           hValue, TRUE)) {
-    return;
-  }
-  IXFA_Notify* pNotify = pDoc->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  pNotify->GetDocProvider()->GetGlobalProperty(pNotify->GetHDOC(), szPropName,
-                                               hValue);
-}
-void CXFA_ScriptContext::NormalPropertyGetter(FXJSE_HOBJECT hObject,
-                                              const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* pOrginalObject =
-      (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-  if (pOrginalObject == NULL) {
-    FXJSE_Value_SetUndefined(hValue);
-    return;
-  }
-  CFX_WideString wsPropName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szPropName.GetPtr(), szPropName.GetLength());
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pOrginalObject->GetDocument()->GetScriptContext();
-  CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOrginalObject);
-  if (wsPropName == FX_WSTRC(L"xfa")) {
-    FXJSE_HVALUE pValue = lpScriptContext->GetJSValueFromMap(
-        lpScriptContext->GetDocument()->GetRoot());
-    FXJSE_Value_Set(hValue, pValue);
-    return;
-  }
-  FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
-                    XFA_RESOLVENODE_Attributes;
-  FX_BOOL bRet = lpScriptContext->QueryNodeByFlag(ToNode(pObject), wsPropName,
-                                                  hValue, dwFlag, FALSE);
-  if (bRet) {
-    return;
-  }
-  if (pObject == lpScriptContext->GetThisObject() ||
-      (lpScriptContext->GetType() == XFA_SCRIPTLANGTYPE_Javascript &&
-       !lpScriptContext->IsStrictScopeInJavaScript())) {
-    dwFlag = XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
-    bRet = lpScriptContext->QueryNodeByFlag(ToNode(pObject), wsPropName, hValue,
-                                            dwFlag, FALSE);
-  }
-  if (bRet) {
-    return;
-  }
-  CXFA_Object* pScriptObject =
-      lpScriptContext->GetVariablesThis(pOrginalObject, TRUE);
-  if (pScriptObject) {
-    bRet = lpScriptContext->QueryVariableHValue(ToNode(pScriptObject),
-                                                szPropName, hValue, TRUE);
-  }
-  if (!bRet) {
-    FXJSE_Value_SetUndefined(hValue);
-  }
-}
-void CXFA_ScriptContext::NormalPropertySetter(FXJSE_HOBJECT hObject,
-                                              const CFX_ByteStringC& szPropName,
-                                              FXJSE_HVALUE hValue) {
-  CXFA_Object* pOrginalObject =
-      (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-  if (pOrginalObject == NULL) {
-    return;
-  }
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pOrginalObject->GetDocument()->GetScriptContext();
-  CXFA_Object* pObject = lpScriptContext->GetVariablesThis(pOrginalObject);
-  CFX_WideString wsPropName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szPropName.GetPtr(), szPropName.GetLength());
-  const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo =
-      XFA_GetScriptAttributeByName(pObject->GetClassID(), wsPropName);
-  if (lpAttributeInfo) {
-    (pObject->*(lpAttributeInfo->lpfnCallback))(
-        hValue, TRUE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
-  } else {
-    if (pObject->IsNode()) {
-      if (wsPropName.GetAt(0) == '#') {
-        wsPropName = wsPropName.Right(wsPropName.GetLength() - 1);
-      }
-      CXFA_Node* pNode = ToNode(pObject);
-      CXFA_Node* pPropOrChild = NULL;
-      const XFA_ELEMENTINFO* lpElementInfo = XFA_GetElementByName(wsPropName);
-      if (lpElementInfo) {
-        pPropOrChild = pNode->GetProperty(0, lpElementInfo->eName);
-      } else {
-        pPropOrChild = pNode->GetFirstChildByName(wsPropName);
-      }
-      if (pPropOrChild) {
-        CFX_WideString wsDefaultName = FX_WSTRC(L"{default}");
-        const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo =
-            XFA_GetScriptAttributeByName(pPropOrChild->GetClassID(),
-                                         wsDefaultName);
-        if (lpAttributeInfo) {
-          (pPropOrChild->*(lpAttributeInfo->lpfnCallback))(
-              hValue, TRUE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
-          return;
-        }
-      }
-    }
-    CXFA_Object* pScriptObject =
-        lpScriptContext->GetVariablesThis(pOrginalObject, TRUE);
-    if (pScriptObject) {
-      lpScriptContext->QueryVariableHValue(ToNode(pScriptObject), szPropName,
-                                           hValue, FALSE);
-    }
-  }
-}
-int32_t CXFA_ScriptContext::NormalPropTypeGetter(
-    FXJSE_HOBJECT hObject,
-    const CFX_ByteStringC& szPropName,
-    FX_BOOL bQueryIn) {
-  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-  if (pObject == NULL) {
-    return FXJSE_ClassPropType_None;
-  }
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pObject->GetDocument()->GetScriptContext();
-  pObject = lpScriptContext->GetVariablesThis(pObject);
-  XFA_ELEMENT objElement = pObject->GetClassID();
-  CFX_WideString wsPropName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szPropName.GetPtr(), szPropName.GetLength());
-  if (XFA_GetMethodByName(objElement, wsPropName)) {
-    return FXJSE_ClassPropType_Method;
-  }
-  if (bQueryIn && !XFA_GetScriptAttributeByName(objElement, wsPropName)) {
-    return FXJSE_ClassPropType_None;
-  }
-  return FXJSE_ClassPropType_Property;
-}
-int32_t CXFA_ScriptContext::GlobalPropTypeGetter(
-    FXJSE_HOBJECT hObject,
-    const CFX_ByteStringC& szPropName,
-    FX_BOOL bQueryIn) {
-  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-  if (pObject == NULL) {
-    return FXJSE_ClassPropType_None;
-  }
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pObject->GetDocument()->GetScriptContext();
-  pObject = lpScriptContext->GetVariablesThis(pObject);
-  XFA_ELEMENT objElement = pObject->GetClassID();
-  CFX_WideString wsPropName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szPropName.GetPtr(), szPropName.GetLength());
-  if (XFA_GetMethodByName(objElement, wsPropName)) {
-    return FXJSE_ClassPropType_Method;
-  }
-  return FXJSE_ClassPropType_Property;
-}
-void CXFA_ScriptContext::NormalMethodCall(FXJSE_HOBJECT hThis,
-                                          const CFX_ByteStringC& szFuncName,
-                                          CFXJSE_Arguments& args) {
-  CXFA_Object* pObject = (CXFA_Object*)FXJSE_Value_ToObject(hThis, NULL);
-  if (pObject == NULL) {
-    return;
-  }
-  CXFA_ScriptContext* lpScriptContext =
-      (CXFA_ScriptContext*)pObject->GetDocument()->GetScriptContext();
-  pObject = lpScriptContext->GetVariablesThis(pObject);
-  CFX_WideString wsFunName = CFX_WideString::FromUTF8(
-      (const FX_CHAR*)szFuncName.GetPtr(), szFuncName.GetLength());
-  const XFA_METHODINFO* lpMethodInfo =
-      XFA_GetMethodByName(pObject->GetClassID(), wsFunName);
-  if (NULL == lpMethodInfo) {
-    return;
-  }
-  (pObject->*(lpMethodInfo->lpfnCallback))(&args);
-}
-FX_BOOL CXFA_ScriptContext::IsStrictScopeInJavaScript() {
-  return m_pDocument->HasFlag(XFA_DOCFLAG_StrictScoping);
-}
-XFA_SCRIPTLANGTYPE CXFA_ScriptContext::GetType() {
-  return m_eScriptType;
-}
-void CXFA_ScriptContext::DefineJsContext() {
-  m_JsGlobalClass.constructor = NULL;
-  m_JsGlobalClass.name = "Root";
-  m_JsGlobalClass.propNum = 0;
-  m_JsGlobalClass.properties = NULL;
-  m_JsGlobalClass.methNum = 0;
-  m_JsGlobalClass.methods = NULL;
-  m_JsGlobalClass.dynPropGetter = CXFA_ScriptContext::GlobalPropertyGetter;
-  m_JsGlobalClass.dynPropSetter = CXFA_ScriptContext::GlobalPropertySetter;
-  m_JsGlobalClass.dynPropTypeGetter = CXFA_ScriptContext::GlobalPropTypeGetter;
-  m_JsGlobalClass.dynPropDeleter = NULL;
-  m_JsGlobalClass.dynMethodCall = CXFA_ScriptContext::NormalMethodCall;
-  m_hJsContext = FXJSE_Context_Create(m_hJsRuntime, &m_JsGlobalClass,
-                                      m_pDocument->GetRoot());
-  RemoveBuiltInObjs(m_hJsContext);
-  FXJSE_Context_EnableCompatibleMode(
-      m_hJsContext, FXJSE_COMPATIBLEMODEFLAG_CONSTRUCTOREXTRAMETHODS);
-}
-FXJSE_HCONTEXT CXFA_ScriptContext::CreateVariablesContext(
-    CXFA_Node* pScriptNode,
-    CXFA_Node* pSubform) {
-  if (pScriptNode == NULL || pSubform == NULL) {
-    return NULL;
-  }
-  if (m_mapVariableToHValue.GetCount() == 0) {
-    m_JsGlobalVariablesClass.constructor = NULL;
-    m_JsGlobalVariablesClass.name = "XFAScriptObject";
-    m_JsGlobalVariablesClass.propNum = 0;
-    m_JsGlobalVariablesClass.properties = NULL;
-    m_JsGlobalVariablesClass.methNum = 0;
-    m_JsGlobalVariablesClass.methods = NULL;
-    m_JsGlobalVariablesClass.dynPropGetter =
-        CXFA_ScriptContext::GlobalPropertyGetter;
-    m_JsGlobalVariablesClass.dynPropSetter =
-        CXFA_ScriptContext::GlobalPropertySetter;
-    m_JsGlobalVariablesClass.dynPropTypeGetter =
-        CXFA_ScriptContext::NormalPropTypeGetter;
-    m_JsGlobalVariablesClass.dynPropDeleter = NULL;
-    m_JsGlobalVariablesClass.dynMethodCall =
-        CXFA_ScriptContext::NormalMethodCall;
-  }
-  CXFA_ThisProxy* lpVariableNode = new CXFA_ThisProxy(pSubform, pScriptNode);
-  FXJSE_HCONTEXT hVariablesContext = FXJSE_Context_Create(
-      m_hJsRuntime, &m_JsGlobalVariablesClass, (CXFA_Object*)lpVariableNode);
-  RemoveBuiltInObjs(hVariablesContext);
-  FXJSE_Context_EnableCompatibleMode(
-      hVariablesContext, FXJSE_COMPATIBLEMODEFLAG_CONSTRUCTOREXTRAMETHODS);
-  m_mapVariableToHValue.SetAt(pScriptNode, hVariablesContext);
-  return hVariablesContext;
-}
-CXFA_Object* CXFA_ScriptContext::GetVariablesThis(CXFA_Object* pObject,
-                                                  FX_BOOL bScriptNode) {
-  if (pObject->GetObjectType() == XFA_OBJECTTYPE_VariablesThis) {
-    return bScriptNode ? ((CXFA_ThisProxy*)pObject)->GetScriptNode()
-                       : ((CXFA_ThisProxy*)pObject)->GetThisNode();
-  }
-  return pObject;
-}
-FX_BOOL CXFA_ScriptContext::RunVariablesScript(CXFA_Node* pScriptNode) {
-  if (pScriptNode == NULL) {
-    return FALSE;
-  }
-  if (pScriptNode->GetClassID() == XFA_ELEMENT_Script) {
-    CXFA_Node* pParent = pScriptNode->GetNodeItem(XFA_NODEITEM_Parent);
-    if (!pParent || pParent->GetClassID() != XFA_ELEMENT_Variables) {
-      return FALSE;
-    }
-    if (m_mapVariableToHValue.GetValueAt(pScriptNode)) {
-      return TRUE;
-    }
-    CXFA_Node* pTextNode = pScriptNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    if (!pTextNode) {
-      return FALSE;
-    }
-    CFX_WideStringC wsScript;
-    if (!pTextNode->TryCData(XFA_ATTRIBUTE_Value, wsScript)) {
-      return FALSE;
-    }
-    CFX_ByteString btScript =
-        FX_UTF8Encode(wsScript.GetPtr(), wsScript.GetLength());
-    FXJSE_HVALUE hRetValue = FXJSE_Value_Create(m_hJsRuntime);
-    CXFA_Node* pThisObject = pParent->GetNodeItem(XFA_NODEITEM_Parent);
-    FXJSE_HCONTEXT hVariablesContext =
-        CreateVariablesContext(pScriptNode, pThisObject);
-    CXFA_Object* pOriginalObject = m_pThisObject;
-    m_pThisObject = pThisObject;
-    FX_BOOL bRet = FXJSE_ExecuteScript(hVariablesContext, btScript, hRetValue);
-    m_pThisObject = pOriginalObject;
-    FXJSE_Value_Release(hRetValue);
-    return bRet;
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_ScriptContext::QueryVariableHValue(
-    CXFA_Node* pScriptNode,
-    const CFX_ByteStringC& szPropName,
-    FXJSE_HVALUE hValue,
-    FX_BOOL bGetter) {
-  if (!pScriptNode || pScriptNode->GetClassID() != XFA_ELEMENT_Script) {
-    return FALSE;
-  }
-  CXFA_Node* variablesNode = pScriptNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!variablesNode || variablesNode->GetClassID() != XFA_ELEMENT_Variables) {
-    return FALSE;
-  }
-  FX_BOOL bRes = FALSE;
-  void* lpVariables = m_mapVariableToHValue.GetValueAt(pScriptNode);
-  if (lpVariables) {
-    FXJSE_HCONTEXT hVariableContext = (FXJSE_HCONTEXT)lpVariables;
-    FXJSE_HVALUE hObject = FXJSE_Context_GetGlobalObject(hVariableContext);
-    FXJSE_HVALUE hVariableValue = FXJSE_Value_Create(m_hJsRuntime);
-    if (!bGetter) {
-      FXJSE_Value_SetObjectOwnProp(hObject, szPropName, hValue);
-      bRes = TRUE;
-    } else if (FXJSE_Value_ObjectHasOwnProp(hObject, szPropName, FALSE)) {
-      FXJSE_Value_GetObjectProp(hObject, szPropName, hVariableValue);
-      if (FXJSE_Value_IsFunction(hVariableValue)) {
-        FXJSE_Value_SetFunctionBind(hValue, hVariableValue, hObject);
-      } else if (bGetter) {
-        FXJSE_Value_Set(hValue, hVariableValue);
-      } else {
-        FXJSE_Value_Set(hVariableValue, hValue);
-      }
-      bRes = TRUE;
-    }
-    FXJSE_Value_Release(hVariableValue);
-    FXJSE_Value_Release(hObject);
-  }
-  return bRes;
-}
-void CXFA_ScriptContext::ReleaseVariablesMap() {
-  FX_POSITION ps = m_mapVariableToHValue.GetStartPosition();
-  while (ps) {
-    CXFA_Object* pScriptNode;
-    FXJSE_HCONTEXT hVariableContext;
-    m_mapVariableToHValue.GetNextAssoc(ps, pScriptNode, hVariableContext);
-    FXJSE_HVALUE hObject = FXJSE_Context_GetGlobalObject(hVariableContext);
-    CXFA_Object* lpCurNode = (CXFA_Object*)FXJSE_Value_ToObject(hObject, NULL);
-    if (lpCurNode) {
-      delete (CXFA_ThisProxy*)lpCurNode;
-      lpCurNode = NULL;
-    }
-    FXJSE_Value_Release(hObject);
-    FXJSE_Context_Release(hVariableContext);
-    hVariableContext = NULL;
-  }
-  m_mapVariableToHValue.RemoveAll();
-}
-void CXFA_ScriptContext::DefineJsClass() {
-  m_JsNormalClass.constructor = NULL;
-  m_JsNormalClass.name = "XFAObject";
-  m_JsNormalClass.propNum = 0;
-  m_JsNormalClass.properties = NULL;
-  m_JsNormalClass.methNum = 0;
-  m_JsNormalClass.methods = NULL;
-  m_JsNormalClass.dynPropGetter = CXFA_ScriptContext::NormalPropertyGetter;
-  m_JsNormalClass.dynPropSetter = CXFA_ScriptContext::NormalPropertySetter;
-  m_JsNormalClass.dynPropTypeGetter = CXFA_ScriptContext::NormalPropTypeGetter;
-  m_JsNormalClass.dynPropDeleter = NULL;
-  m_JsNormalClass.dynMethodCall = CXFA_ScriptContext::NormalMethodCall;
-  m_hJsClass = FXJSE_DefineClass(m_hJsContext, &m_JsNormalClass);
-}
-void CXFA_ScriptContext::RemoveBuiltInObjs(FXJSE_HCONTEXT jsContext) const {
-  static const CFX_ByteStringC OBJ_NAME[2] = {"Number", "Date"};
-  FXJSE_HVALUE hObject = FXJSE_Context_GetGlobalObject(jsContext);
-  FXJSE_HVALUE hProp = FXJSE_Value_Create(m_hJsRuntime);
-  for (int i = 0; i < 2; ++i) {
-    if (FXJSE_Value_GetObjectProp(hObject, OBJ_NAME[i], hProp))
-      FXJSE_Value_DeleteObjectProp(hObject, OBJ_NAME[i]);
-  }
-  FXJSE_Value_Release(hProp);
-  FXJSE_Value_Release(hObject);
-}
-FXJSE_HCLASS CXFA_ScriptContext::GetJseNormalClass() {
-  return m_hJsClass;
-}
-int32_t CXFA_ScriptContext::ResolveObjects(CXFA_Object* refNode,
-                                           const CFX_WideStringC& wsExpression,
-                                           XFA_RESOLVENODE_RS& resolveNodeRS,
-                                           FX_DWORD dwStyles,
-                                           CXFA_Node* bindNode) {
-  if (wsExpression.IsEmpty()) {
-    return 0;
-  }
-  if (m_eScriptType != XFA_SCRIPTLANGTYPE_Formcalc ||
-      (dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
-    m_upObjectArray.RemoveAll();
-  }
-  if (refNode && refNode->IsNode() &&
-      (dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
-    m_upObjectArray.Add(refNode->AsNode());
-  }
-  FX_BOOL bNextCreate = FALSE;
-  if (dwStyles & XFA_RESOLVENODE_CreateNode) {
-    m_pResolveProcessor->GetNodeHelper()->XFA_SetCreateNodeType(bindNode);
-  }
-  m_pResolveProcessor->GetNodeHelper()->m_pCreateParent = NULL;
-  m_pResolveProcessor->GetNodeHelper()->m_iCurAllStart = -1;
-  CXFA_ResolveNodesData rndFind;
-  int32_t nStart = 0;
-  int32_t nLevel = 0;
-  int32_t nRet = -1;
-  rndFind.m_pSC = this;
-  CXFA_ObjArray findNodes;
-  findNodes.Add(refNode ? refNode : m_pDocument->GetRoot());
-  int32_t nNodes = 0;
-  while (TRUE) {
-    nNodes = findNodes.GetSize();
-    int32_t i = 0;
-    rndFind.m_dwStyles = dwStyles;
-    m_pResolveProcessor->m_iCurStart = nStart;
-    nStart = m_pResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression,
-                                                             nStart, rndFind);
-    if (nStart < 1) {
-      if ((dwStyles & XFA_RESOLVENODE_CreateNode) && !bNextCreate) {
-        CXFA_Node* pDataNode = NULL;
-        nStart = m_pResolveProcessor->GetNodeHelper()->m_iCurAllStart;
-        if (nStart != -1) {
-          pDataNode = m_pDocument->GetNotBindNode(findNodes);
-          if (pDataNode) {
-            findNodes.RemoveAll();
-            findNodes.Add(pDataNode);
-            break;
-          }
-        } else {
-          pDataNode = findNodes[0]->AsNode();
-          findNodes.RemoveAll();
-          findNodes.Add(pDataNode);
-          break;
-        }
-        dwStyles |= XFA_RESOLVENODE_Bind;
-        findNodes.RemoveAll();
-        findNodes.Add(m_pResolveProcessor->GetNodeHelper()->m_pAllStartParent);
-        continue;
-      } else {
-        break;
-      }
-    }
-    if (bNextCreate) {
-      FX_BOOL bCreate =
-          m_pResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
-              rndFind.m_wsName, rndFind.m_wsCondition,
-              nStart == wsExpression.GetLength(), this);
-      if (bCreate) {
-        continue;
-      } else {
-        break;
-      }
-    }
-    CXFA_ObjArray retNodes;
-    while (i < nNodes) {
-      FX_BOOL bDataBind = FALSE;
-      if (((dwStyles & XFA_RESOLVENODE_Bind) ||
-           (dwStyles & XFA_RESOLVENODE_CreateNode)) &&
-          nNodes > 1) {
-        CXFA_ResolveNodesData rndBind;
-        m_pResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression, nStart,
-                                                        rndBind);
-        m_pResolveProcessor->XFA_ResolveNode_SetIndexDataBind(
-            rndBind.m_wsCondition, i, nNodes);
-        bDataBind = TRUE;
-      }
-      rndFind.m_CurNode = findNodes[i++];
-      rndFind.m_nLevel = nLevel;
-      rndFind.m_dwFlag = XFA_RESOVENODE_RSTYPE_Nodes;
-      nRet = m_pResolveProcessor->XFA_ResolveNodes(rndFind);
-      if (nRet < 1) {
-        continue;
-      }
-      if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute &&
-          rndFind.m_pScriptAttribute && nStart < wsExpression.GetLength()) {
-        FXJSE_HVALUE hValue = FXJSE_Value_Create(m_hJsRuntime);
-        (rndFind.m_Nodes[0]->*(rndFind.m_pScriptAttribute->lpfnCallback))(
-            hValue, FALSE,
-            (XFA_ATTRIBUTE)rndFind.m_pScriptAttribute->eAttribute);
-        rndFind.m_Nodes.SetAt(0,
-                              (CXFA_Object*)FXJSE_Value_ToObject(hValue, NULL));
-        FXJSE_Value_Release(hValue);
-      }
-      int32_t iSize = m_upObjectArray.GetSize();
-      if (iSize) {
-        m_upObjectArray.RemoveAt(iSize - 1);
-      }
-      retNodes.Append(rndFind.m_Nodes);
-      rndFind.m_Nodes.RemoveAll();
-      if (bDataBind) {
-        break;
-      }
-    }
-    findNodes.RemoveAll();
-    nNodes = retNodes.GetSize();
-    if (nNodes < 1) {
-      if (dwStyles & XFA_RESOLVENODE_CreateNode) {
-        bNextCreate = TRUE;
-        if (m_pResolveProcessor->GetNodeHelper()->m_pCreateParent == NULL) {
-          m_pResolveProcessor->GetNodeHelper()->m_pCreateParent =
-              ToNode(rndFind.m_CurNode);
-          m_pResolveProcessor->GetNodeHelper()->m_iCreateCount = 1;
-        }
-        FX_BOOL bCreate =
-            m_pResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
-                rndFind.m_wsName, rndFind.m_wsCondition,
-                nStart == wsExpression.GetLength(), this);
-        if (bCreate) {
-          continue;
-        } else {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    findNodes.Copy(retNodes);
-    rndFind.m_Nodes.RemoveAll();
-    if (nLevel == 0) {
-      dwStyles &= ~(XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings);
-    }
-    nLevel++;
-  }
-  if (!bNextCreate) {
-    resolveNodeRS.dwFlags = rndFind.m_dwFlag;
-    if (nNodes > 0) {
-      resolveNodeRS.nodes.Append(findNodes);
-    }
-    if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute) {
-      resolveNodeRS.pScriptAttribute = rndFind.m_pScriptAttribute;
-      return 1;
-    }
-  }
-  if (dwStyles & (XFA_RESOLVENODE_CreateNode | XFA_RESOLVENODE_Bind |
-                  XFA_RESOLVENODE_BindNew)) {
-    m_pResolveProcessor->XFA_ResolveNode_SetResultCreateNode(
-        resolveNodeRS, rndFind.m_wsCondition);
-    if (!bNextCreate && (dwStyles & XFA_RESOLVENODE_CreateNode)) {
-      resolveNodeRS.dwFlags = XFA_RESOVENODE_RSTYPE_ExistNodes;
-    }
-    return resolveNodeRS.nodes.GetSize();
-  }
-  return nNodes;
-}
-FXJSE_HVALUE CXFA_ScriptContext::GetJSValueFromMap(CXFA_Object* pObject) {
-  if (!pObject) {
-    return NULL;
-  }
-  if (pObject->IsNode()) {
-    RunVariablesScript(pObject->AsNode());
-  }
-  void* pValue = m_mapXFAToHValue.GetValueAt(pObject);
-  if (pValue == NULL) {
-    FXJSE_HVALUE jsHvalue = FXJSE_Value_Create(m_hJsRuntime);
-    FXJSE_Value_SetObject(jsHvalue, pObject, m_hJsClass);
-    m_mapXFAToHValue.SetAt(pObject, jsHvalue);
-    pValue = jsHvalue;
-  }
-  return (FXJSE_HVALUE)pValue;
-}
-int32_t CXFA_ScriptContext::GetIndexByName(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
-                                    lpNodeHelper->XFA_NodeIsProperty(refNode),
-                                    FALSE);
-}
-int32_t CXFA_ScriptContext::GetIndexByClassName(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
-                                    lpNodeHelper->XFA_NodeIsProperty(refNode),
-                                    TRUE);
-}
-void CXFA_ScriptContext::GetSomExpression(CXFA_Node* refNode,
-                                          CFX_WideString& wsExpression) {
-  CXFA_NodeHelper* lpNodeHelper = m_pResolveProcessor->GetNodeHelper();
-  lpNodeHelper->XFA_GetNameExpression(refNode, wsExpression, TRUE,
-                                      XFA_LOGIC_Transparent);
-}
-void CXFA_ScriptContext::SetNodesOfRunScript(CXFA_NodeArray* pArray) {
-  m_pScriptNodeArray = pArray;
-}
-void CXFA_ScriptContext::AddNodesOfRunScript(const CXFA_NodeArray& nodes) {
-  if (!m_pScriptNodeArray) {
-    return;
-  }
-  if (nodes.GetSize() > 0) {
-    m_pScriptNodeArray->Copy(nodes);
-  }
-}
-void CXFA_ScriptContext::AddNodesOfRunScript(CXFA_Node* pNode) {
-  if (!m_pScriptNodeArray) {
-    return;
-  }
-  if (m_pScriptNodeArray->Find(pNode) == -1) {
-    m_pScriptNodeArray->Add(pNode);
-  }
-}
-IXFA_ScriptContext* XFA_ScriptContext_Create(CXFA_Document* pDocument) {
-  return new CXFA_ScriptContext(pDocument);
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_imp.h b/xfa/src/fxfa/parser/xfa_script_imp.h
deleted file mode 100644
index 529ab6d087..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_imp.h
+++ /dev/null
@@ -1,127 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_IMP_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_IMP_H_
-
-#include <map>
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-
-#define XFA_RESOLVENODE_TagName 0x0002
-
-class CXFA_ResolveProcessor;
-
-class CXFA_ScriptContext : public IXFA_ScriptContext {
- public:
-  explicit CXFA_ScriptContext(CXFA_Document* pDocument);
-  ~CXFA_ScriptContext();
-
-  virtual void Release();
-  virtual void Initialize(FXJSE_HRUNTIME hRuntime);
-  virtual void SetEventParam(CXFA_EventParam param) { m_eventParam = param; }
-  virtual CXFA_EventParam* GetEventParam() { return &m_eventParam; }
-  virtual FX_BOOL RunScript(XFA_SCRIPTLANGTYPE eScriptType,
-                            const CFX_WideStringC& wsScript,
-                            FXJSE_HVALUE hRetValue,
-                            CXFA_Object* pThisObject = NULL);
-
-  virtual int32_t ResolveObjects(CXFA_Object* refNode,
-                                 const CFX_WideStringC& wsExpression,
-                                 XFA_RESOLVENODE_RS& resolveNodeRS,
-                                 FX_DWORD dwStyles = XFA_RESOLVENODE_Children,
-                                 CXFA_Node* bindNode = NULL);
-  virtual FXJSE_HVALUE GetJSValueFromMap(CXFA_Object* pObject);
-  virtual void CacheList(CXFA_NodeList* pList) { m_CacheListArray.Add(pList); }
-  virtual CXFA_Object* GetThisObject() const { return m_pThisObject; }
-  virtual FXJSE_HRUNTIME GetRuntime() const { return m_hJsRuntime; }
-
-  virtual int32_t GetIndexByName(CXFA_Node* refNode);
-  virtual int32_t GetIndexByClassName(CXFA_Node* refNode);
-  virtual void GetSomExpression(CXFA_Node* refNode,
-                                CFX_WideString& wsExpression);
-
-  virtual void SetNodesOfRunScript(CXFA_NodeArray* pArray);
-  virtual void AddNodesOfRunScript(const CXFA_NodeArray& nodes);
-  virtual void AddNodesOfRunScript(CXFA_Node* pNode);
-  virtual FXJSE_HCLASS GetJseNormalClass();
-
-  virtual void SetRunAtType(XFA_ATTRIBUTEENUM eRunAt) { m_eRunAtType = eRunAt; }
-  virtual FX_BOOL IsRunAtClient() {
-    return m_eRunAtType != XFA_ATTRIBUTEENUM_Server;
-  }
-  FX_BOOL QueryNodeByFlag(CXFA_Node* refNode,
-                          const CFX_WideStringC& propname,
-                          FXJSE_HVALUE hValue,
-                          FX_DWORD dwFlag,
-                          FX_BOOL bSetting);
-  FX_BOOL QueryVariableHValue(CXFA_Node* pScriptNode,
-                              const CFX_ByteStringC& szPropName,
-                              FXJSE_HVALUE hValue,
-                              FX_BOOL bGetter);
-  FX_BOOL QueryBuiltinHValue(const CFX_ByteStringC& szPropName,
-                             FXJSE_HVALUE hValue);
-  static void GlobalPropertyGetter(FXJSE_HOBJECT hObject,
-                                   const CFX_ByteStringC& szPropName,
-                                   FXJSE_HVALUE hValue);
-  static void GlobalPropertySetter(FXJSE_HOBJECT hObject,
-                                   const CFX_ByteStringC& szPropName,
-                                   FXJSE_HVALUE hValue);
-  static void NormalPropertyGetter(FXJSE_HOBJECT hObject,
-                                   const CFX_ByteStringC& szPropName,
-                                   FXJSE_HVALUE hValue);
-  static void NormalPropertySetter(FXJSE_HOBJECT hObject,
-                                   const CFX_ByteStringC& szPropName,
-                                   FXJSE_HVALUE hValue);
-  static void NormalMethodCall(FXJSE_HOBJECT hThis,
-                               const CFX_ByteStringC& szFuncName,
-                               CFXJSE_Arguments& args);
-  static int32_t NormalPropTypeGetter(FXJSE_HOBJECT hObject,
-                                      const CFX_ByteStringC& szPropName,
-                                      FX_BOOL bQueryIn);
-  static int32_t GlobalPropTypeGetter(FXJSE_HOBJECT hObject,
-                                      const CFX_ByteStringC& szPropName,
-                                      FX_BOOL bQueryIn);
-  FX_BOOL RunVariablesScript(CXFA_Node* pScriptNode);
-  CXFA_Object* GetVariablesThis(CXFA_Object* pObject,
-                                FX_BOOL bScriptNode = FALSE);
-  void ReleaseVariablesMap();
-  FX_BOOL IsStrictScopeInJavaScript();
-  XFA_SCRIPTLANGTYPE GetType();
-  CXFA_NodeArray& GetUpObjectArray() { return m_upObjectArray; }
-  CXFA_Document* GetDocument() const { return m_pDocument; }
-
- protected:
-  void DefineJsContext();
-  FXJSE_HCONTEXT CreateVariablesContext(CXFA_Node* pScriptNode,
-                                        CXFA_Node* pSubform);
-  void DefineJsClass();
-  void RemoveBuiltInObjs(FXJSE_HCONTEXT jsContext) const;
-
-  CXFA_Document* m_pDocument;
-  FXJSE_HCONTEXT m_hJsContext;
-  FXJSE_HRUNTIME m_hJsRuntime;
-  FXJSE_HCLASS m_hJsClass;
-  XFA_SCRIPTLANGTYPE m_eScriptType;
-  FXJSE_CLASS m_JsGlobalClass;
-  FXJSE_CLASS m_JsNormalClass;
-  CFX_MapPtrTemplate<CXFA_Object*, FXJSE_HVALUE> m_mapXFAToHValue;
-  FXJSE_CLASS m_JsGlobalVariablesClass;
-  CFX_MapPtrTemplate<CXFA_Object*, FXJSE_HCONTEXT> m_mapVariableToHValue;
-  CXFA_EventParam m_eventParam;
-  CXFA_NodeArray m_upObjectArray;
-  CFX_PtrArray m_CacheListArray;
-  CXFA_NodeArray* m_pScriptNodeArray;
-  CXFA_ResolveProcessor* m_pResolveProcessor;
-  XFA_HFM2JSCONTEXT m_hFM2JSContext;
-  CXFA_Object* m_pThisObject;
-  FX_DWORD m_dwBuiltInInFlags;
-  XFA_ATTRIBUTEENUM m_eRunAtType;
-};
-
-#endif  //  XFA_SRC_FXFA_PARSER_XFA_SCRIPT_IMP_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.cpp b/xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.cpp
deleted file mode 100644
index fe8990ac1a..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.cpp
+++ /dev/null
@@ -1,552 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_layoutpseudomodel.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/src/fxfa/parser/xfa_layout_appadapter.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CScript_LayoutPseudoModel::CScript_LayoutPseudoModel(CXFA_Document* pDocument)
-    : CXFA_OrdinaryObject(pDocument, XFA_ELEMENT_LayoutPseudoModel) {
-  m_uScriptHash = XFA_HASHCODE_Layout;
-}
-CScript_LayoutPseudoModel::~CScript_LayoutPseudoModel() {}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_Ready(
-    FXJSE_HVALUE hValue,
-    FX_BOOL bSetting,
-    XFA_ATTRIBUTE eAttribute) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_UNABLE_SET_READY);
-    return;
-  }
-  int32_t iStatus = pNotify->GetLayoutStatus();
-  FXJSE_Value_SetBoolean(hValue, iStatus >= 2);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_HWXY(
-    CFXJSE_Arguments* pArguments,
-    XFA_LAYOUTMODEL_HWXY layoutModel) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 3) {
-    const FX_WCHAR* methodName = NULL;
-    switch (layoutModel) {
-      case XFA_LAYOUTMODEL_H:
-        methodName = L"h";
-        break;
-      case XFA_LAYOUTMODEL_W:
-        methodName = L"w";
-        break;
-      case XFA_LAYOUTMODEL_X:
-        methodName = L"x";
-        break;
-      case XFA_LAYOUTMODEL_Y:
-        methodName = L"y";
-        break;
-    }
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, methodName);
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  CFX_WideString wsUnit = FX_WSTRC(L"pt");
-  int32_t iIndex = 0;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsUnit = pArguments->GetUTF8String(1);
-    if (!bsUnit.IsEmpty()) {
-      wsUnit = CFX_WideString::FromUTF8(bsUnit, bsUnit.GetLength());
-    }
-  }
-  if (iLength >= 3) {
-    iIndex = pArguments->GetInt32(2);
-  }
-  if (!pNode) {
-    return;
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  CFX_RectF rtRect;
-  CXFA_Measurement measure;
-  CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode);
-  if (!pLayoutItem) {
-    return;
-  }
-  while (iIndex > 0 && pLayoutItem) {
-    pLayoutItem = pLayoutItem->GetNext();
-    iIndex--;
-  }
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (!pLayoutItem) {
-    FXJSE_Value_SetFloat(hValue, 0);
-    return;
-  }
-  pLayoutItem->GetRect(rtRect, TRUE);
-  switch (layoutModel) {
-    case XFA_LAYOUTMODEL_H:
-      measure.Set(rtRect.height, XFA_UNIT_Pt);
-      break;
-    case XFA_LAYOUTMODEL_W:
-      measure.Set(rtRect.width, XFA_UNIT_Pt);
-      break;
-    case XFA_LAYOUTMODEL_X:
-      measure.Set(rtRect.left, XFA_UNIT_Pt);
-      break;
-    case XFA_LAYOUTMODEL_Y:
-      measure.Set(rtRect.top, XFA_UNIT_Pt);
-      break;
-  }
-  XFA_UNIT unit = measure.GetUnit(wsUnit);
-  FX_FLOAT fValue = measure.ToUnit(unit);
-  fValue = FXSYS_round(fValue * 1000) / 1000.0f;
-  if (hValue) {
-    FXJSE_Value_SetFloat(hValue, fValue);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_H(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_HWXY(pArguments, XFA_LAYOUTMODEL_H);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_W(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_HWXY(pArguments, XFA_LAYOUTMODEL_W);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_X(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_HWXY(pArguments, XFA_LAYOUTMODEL_X);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_Y(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_HWXY(pArguments, XFA_LAYOUTMODEL_Y);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_NumberedPageCount(
-    CFXJSE_Arguments* pArguments,
-    FX_BOOL bNumbered) {
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  int32_t iPageCount = 0;
-  int32_t iPageNum = pDocLayout->CountPages();
-  if (bNumbered) {
-    for (int32_t i = 0; i < iPageNum; i++) {
-      IXFA_LayoutPage* pLayoutPage = pDocLayout->GetPage(i);
-      if (!pLayoutPage) {
-        continue;
-      }
-      CXFA_Node* pMasterPage = pLayoutPage->GetMasterPage();
-      if (pMasterPage->GetInteger(XFA_ATTRIBUTE_Numbered)) {
-        iPageCount++;
-      }
-    }
-  } else {
-    iPageCount = iPageNum;
-  }
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iPageCount);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_PageCount(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_NumberedPageCount(pArguments, TRUE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_PageSpan(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"pageSpan");
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  if (!pNode) {
-    return;
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode);
-  if (!pLayoutItem) {
-    FXJSE_Value_SetInteger(hValue, -1);
-    return;
-  }
-  int32_t iLast = pLayoutItem->GetLast()->GetPage()->GetPageIndex();
-  int32_t iFirst = pLayoutItem->GetFirst()->GetPage()->GetPageIndex();
-  int32_t iPageSpan = iLast - iFirst + 1;
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iPageSpan);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_Page(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_PageImp(pArguments, FALSE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_GetObjArray(
-    IXFA_DocLayout* pDocLayout,
-    int32_t iPageNo,
-    const CFX_WideString& wsType,
-    FX_BOOL bOnPageArea,
-    CXFA_NodeArray& retArray) {
-  CXFA_ContainerLayoutItem* pLayoutPage =
-      (CXFA_ContainerLayoutItem*)pDocLayout->GetPage(iPageNo);
-  if (!pLayoutPage) {
-    return;
-  }
-  if (wsType == FX_WSTRC(L"pageArea")) {
-    if (CXFA_Node* pMasterPage = pLayoutPage->m_pFormNode) {
-      retArray.Add(pMasterPage);
-    }
-    return;
-  }
-  if (wsType == FX_WSTRC(L"contentArea")) {
-    for (CXFA_LayoutItem* pItem = pLayoutPage->m_pFirstChild; pItem;
-         pItem = pItem->m_pNextSibling) {
-      if (pItem->m_pFormNode->GetClassID() == XFA_ELEMENT_ContentArea) {
-        retArray.Add(pItem->m_pFormNode);
-      }
-    }
-    return;
-  }
-  CFX_MapPtrToPtr formItems;
-  formItems.InitHashTable(256, TRUE);
-  if (wsType.IsEmpty()) {
-    if (CXFA_Node* pMasterPage = pLayoutPage->m_pFormNode) {
-      retArray.Add(pMasterPage);
-    }
-    for (CXFA_LayoutItem* pItem = pLayoutPage->m_pFirstChild; pItem;
-         pItem = pItem->m_pNextSibling) {
-      if (pItem->m_pFormNode->GetClassID() == XFA_ELEMENT_ContentArea) {
-        retArray.Add(pItem->m_pFormNode);
-        if (!bOnPageArea) {
-          CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem,
-                                    CXFA_TraverseStrategy_ContentLayoutItem>
-          iterator((CXFA_ContentLayoutItem*)pItem->m_pFirstChild);
-          for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent();
-               pItemChild; pItemChild = iterator.MoveToNext()) {
-            if (!pItemChild->IsContentLayoutItem()) {
-              continue;
-            }
-            XFA_ELEMENT eElementType = pItemChild->m_pFormNode->GetClassID();
-            if (eElementType != XFA_ELEMENT_Field &&
-                eElementType != XFA_ELEMENT_Draw &&
-                eElementType != XFA_ELEMENT_Subform &&
-                eElementType != XFA_ELEMENT_Area) {
-              continue;
-            }
-            if (formItems.GetValueAt(pItemChild->m_pFormNode)) {
-              continue;
-            }
-            formItems.SetAt(pItemChild->m_pFormNode, this);
-            retArray.Add(pItemChild->m_pFormNode);
-          }
-        }
-      } else {
-        if (bOnPageArea) {
-          CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem,
-                                    CXFA_TraverseStrategy_ContentLayoutItem>
-          iterator((CXFA_ContentLayoutItem*)pItem);
-          for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent();
-               pItemChild; pItemChild = iterator.MoveToNext()) {
-            if (!pItemChild->IsContentLayoutItem()) {
-              continue;
-            }
-            XFA_ELEMENT eElementType = pItemChild->m_pFormNode->GetClassID();
-            if (eElementType != XFA_ELEMENT_Field &&
-                eElementType != XFA_ELEMENT_Draw &&
-                eElementType != XFA_ELEMENT_Subform &&
-                eElementType != XFA_ELEMENT_Area) {
-              continue;
-            }
-            if (formItems.GetValueAt(pItemChild->m_pFormNode)) {
-              continue;
-            }
-            formItems.SetAt(pItemChild->m_pFormNode, this);
-            retArray.Add(pItemChild->m_pFormNode);
-          }
-        }
-      }
-    }
-    return;
-  }
-  XFA_ELEMENT eType = XFA_ELEMENT_UNKNOWN;
-  if (wsType == FX_WSTRC(L"field")) {
-    eType = XFA_ELEMENT_Field;
-  } else if (wsType == FX_WSTRC(L"draw")) {
-    eType = XFA_ELEMENT_Draw;
-  } else if (wsType == FX_WSTRC(L"subform")) {
-    eType = XFA_ELEMENT_Subform;
-  } else if (wsType == FX_WSTRC(L"area")) {
-    eType = XFA_ELEMENT_Area;
-  }
-  if (eType != XFA_ELEMENT_UNKNOWN) {
-    for (CXFA_LayoutItem* pItem = pLayoutPage->m_pFirstChild; pItem;
-         pItem = pItem->m_pNextSibling) {
-      if (pItem->m_pFormNode->GetClassID() == XFA_ELEMENT_ContentArea) {
-        if (!bOnPageArea) {
-          CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem,
-                                    CXFA_TraverseStrategy_ContentLayoutItem>
-          iterator((CXFA_ContentLayoutItem*)pItem->m_pFirstChild);
-          for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent();
-               pItemChild; pItemChild = iterator.MoveToNext()) {
-            if (!pItemChild->IsContentLayoutItem()) {
-              continue;
-            }
-            if (pItemChild->m_pFormNode->GetClassID() != eType) {
-              continue;
-            }
-            if (formItems.GetValueAt(pItemChild->m_pFormNode)) {
-              continue;
-            }
-            formItems.SetAt(pItemChild->m_pFormNode, this);
-            retArray.Add(pItemChild->m_pFormNode);
-          }
-        }
-      } else {
-        if (bOnPageArea) {
-          CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem,
-                                    CXFA_TraverseStrategy_ContentLayoutItem>
-          iterator((CXFA_ContentLayoutItem*)pItem);
-          for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent();
-               pItemChild; pItemChild = iterator.MoveToNext()) {
-            if (!pItemChild->IsContentLayoutItem()) {
-              continue;
-            }
-            if (pItemChild->m_pFormNode->GetClassID() != eType) {
-              continue;
-            }
-            if (formItems.GetValueAt(pItemChild->m_pFormNode)) {
-              continue;
-            }
-            formItems.SetAt(pItemChild->m_pFormNode, this);
-            retArray.Add(pItemChild->m_pFormNode);
-          }
-        }
-      }
-    }
-    return;
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_PageContent(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"pageContent");
-    return;
-  }
-  int32_t iIndex = 0;
-  CFX_WideString wsType;
-  FX_BOOL bOnPageArea = FALSE;
-  if (iLength >= 1) {
-    iIndex = pArguments->GetInt32(0);
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsType = pArguments->GetUTF8String(1);
-    wsType = CFX_WideString::FromUTF8(bsType, bsType.GetLength());
-  }
-  if (iLength >= 3) {
-    bOnPageArea = pArguments->GetInt32(2) == 0 ? FALSE : TRUE;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  CXFA_NodeArray retArray;
-  Script_LayoutPseudoModel_GetObjArray(pDocLayout, iIndex, wsType, bOnPageArea,
-                                       retArray);
-  CXFA_ArrayNodeList* pArrayNodeList = new CXFA_ArrayNodeList(m_pDocument);
-  pArrayNodeList->SetArrayNodeList(retArray);
-  FXJSE_Value_SetObject(pArguments->GetReturnValue(),
-                        (CXFA_Object*)pArrayNodeList,
-                        m_pDocument->GetScriptContext()->GetJseNormalClass());
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_AbsPageCount(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_NumberedPageCount(pArguments, FALSE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_AbsPageCountInBatch(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  int32_t iPageCount = pNotify->GetDocProvider()->AbsPageCountInBatch(hDoc);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iPageCount);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_SheetCountInBatch(
-    CFXJSE_Arguments* pArguments) {
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  int32_t iPageCount = pNotify->GetDocProvider()->SheetCountInBatch(hDoc);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iPageCount);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_Relayout(
-    CFXJSE_Arguments* pArguments) {
-  CXFA_Node* pRootNode = m_pDocument->GetRoot();
-  CXFA_Node* pFormRoot = pRootNode->GetFirstChildByClass(XFA_ELEMENT_Form);
-  FXSYS_assert(pFormRoot);
-  CXFA_Node* pContentRootNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
-  CXFA_LayoutProcessor* pLayoutProcessor = m_pDocument->GetLayoutProcessor();
-  if (pContentRootNode) {
-    pLayoutProcessor->AddChangedContainer(pContentRootNode);
-  }
-  pLayoutProcessor->SetForceReLayout(TRUE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_AbsPageSpan(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_PageSpan(pArguments);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_AbsPageInBatch(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"absPageInBatch");
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  if (!pNode) {
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  IXFA_Widget* hWidget = pNotify->GetHWidget(pDocLayout->GetLayoutItem(pNode));
-  if (!hWidget) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  int32_t iPageCount = pNotify->GetDocProvider()->AbsPageInBatch(hDoc, hWidget);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iPageCount);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_SheetInBatch(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"sheetInBatch");
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  if (!pNode) {
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  IXFA_Widget* hWidget = pNotify->GetHWidget(pDocLayout->GetLayoutItem(pNode));
-  if (!hWidget) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  int32_t iPageCount = pNotify->GetDocProvider()->SheetInBatch(hDoc, hWidget);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, iPageCount);
-  }
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_Sheet(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_PageImp(pArguments, TRUE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_RelayoutPageArea(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_SheetCount(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_NumberedPageCount(pArguments, FALSE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_AbsPage(
-    CFXJSE_Arguments* pArguments) {
-  Script_LayoutPseudoModel_PageImp(pArguments, TRUE);
-}
-void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_PageImp(
-    CFXJSE_Arguments* pArguments,
-    FX_BOOL bAbsPage) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 1) {
-    const FX_WCHAR* methodName;
-    if (bAbsPage) {
-      methodName = L"absPage";
-    } else {
-      methodName = L"page";
-    }
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, methodName);
-    return;
-  }
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  int32_t iPage = 0;
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (!pNode && hValue) {
-    FXJSE_Value_SetInteger(hValue, iPage);
-  }
-  IXFA_DocLayout* pDocLayout = m_pDocument->GetDocLayout();
-  if (!pDocLayout) {
-    return;
-  }
-  CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode);
-  if (!pLayoutItem) {
-    FXJSE_Value_SetInteger(hValue, -1);
-    return;
-  }
-  iPage = pLayoutItem->GetFirst()->GetPage()->GetPageIndex();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, bAbsPage ? iPage : iPage + 1);
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.h b/xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.h
deleted file mode 100644
index 5b0dbb816f..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_layoutpseudomodel.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_LAYOUTPSEUDOMODEL_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_LAYOUTPSEUDOMODEL_H_
-
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-enum XFA_LAYOUTMODEL_HWXY {
-  XFA_LAYOUTMODEL_H,
-  XFA_LAYOUTMODEL_W,
-  XFA_LAYOUTMODEL_X,
-  XFA_LAYOUTMODEL_Y
-};
-
-class CScript_LayoutPseudoModel : public CXFA_OrdinaryObject {
- public:
-  explicit CScript_LayoutPseudoModel(CXFA_Document* pDocument);
-  ~CScript_LayoutPseudoModel();
-
-  void Script_LayoutPseudoModel_Ready(FXJSE_HVALUE hValue,
-                                      FX_BOOL bSetting,
-                                      XFA_ATTRIBUTE eAttribute);
-
-  void Script_LayoutPseudoModel_HWXY(CFXJSE_Arguments* pArguments,
-                                     XFA_LAYOUTMODEL_HWXY layoutModel);
-  void Script_LayoutPseudoModel_H(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_W(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_X(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_Y(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_NumberedPageCount(CFXJSE_Arguments* pArguments,
-                                                  FX_BOOL bNumbered);
-  void Script_LayoutPseudoModel_PageCount(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_PageSpan(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_Page(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_PageContent(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_AbsPageCount(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_AbsPageCountInBatch(
-      CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_SheetCountInBatch(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_Relayout(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_AbsPageSpan(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_AbsPageInBatch(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_SheetInBatch(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_Sheet(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_RelayoutPageArea(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_SheetCount(CFXJSE_Arguments* pArguments);
-  void Script_LayoutPseudoModel_AbsPage(CFXJSE_Arguments* pArguments);
-
- protected:
-  void Script_LayoutPseudoModel_GetObjArray(IXFA_DocLayout* pDocLayout,
-                                            int32_t iPageNo,
-                                            const CFX_WideString& wsType,
-                                            FX_BOOL bOnPageArea,
-                                            CXFA_NodeArray& retArray);
-  void Script_LayoutPseudoModel_PageImp(CFXJSE_Arguments* pArguments,
-                                        FX_BOOL bAbsPage);
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_LAYOUTPSEUDOMODEL_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_logpseudomodel.cpp b/xfa/src/fxfa/parser/xfa_script_logpseudomodel.cpp
deleted file mode 100644
index d5ddd811ad..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_logpseudomodel.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_logpseudomodel.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CScript_LogPseudoModel::CScript_LogPseudoModel(CXFA_Document* pDocument)
-    : CXFA_OrdinaryObject(pDocument, XFA_ELEMENT_LogPseudoModel) {
-  m_uScriptHash = XFA_HASHCODE_Log;
-}
-CScript_LogPseudoModel::~CScript_LogPseudoModel() {}
-void CScript_LogPseudoModel::Script_LogPseudoModel_Message(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_LogPseudoModel::Script_LogPseudoModel_TraceEnabled(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_LogPseudoModel::Script_LogPseudoModel_TraceActivate(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_LogPseudoModel::Script_LogPseudoModel_TraceDeactivate(
-    CFXJSE_Arguments* pArguments) {}
-void CScript_LogPseudoModel::Script_LogPseudoModel_Trace(
-    CFXJSE_Arguments* pArguments) {}
diff --git a/xfa/src/fxfa/parser/xfa_script_logpseudomodel.h b/xfa/src/fxfa/parser/xfa_script_logpseudomodel.h
deleted file mode 100644
index ee3d35c052..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_logpseudomodel.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_LOGPSEUDOMODEL_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_LOGPSEUDOMODEL_H_
-
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-class CScript_LogPseudoModel : public CXFA_OrdinaryObject {
- public:
-  explicit CScript_LogPseudoModel(CXFA_Document* pDocument);
-  virtual ~CScript_LogPseudoModel();
-
-  void Script_LogPseudoModel_Message(CFXJSE_Arguments* pArguments);
-  void Script_LogPseudoModel_TraceEnabled(CFXJSE_Arguments* pArguments);
-  void Script_LogPseudoModel_TraceActivate(CFXJSE_Arguments* pArguments);
-  void Script_LogPseudoModel_TraceDeactivate(CFXJSE_Arguments* pArguments);
-  void Script_LogPseudoModel_Trace(CFXJSE_Arguments* pArguments);
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_LOGPSEUDOMODEL_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_nodehelper.cpp b/xfa/src/fxfa/parser/xfa_script_nodehelper.cpp
deleted file mode 100644
index e2f047591e..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_nodehelper.cpp
+++ /dev/null
@@ -1,429 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_nodehelper.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_script_imp.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_NodeHelper::CXFA_NodeHelper(void)
-    : m_eLastCreateType(XFA_ELEMENT_DataValue),
-      m_pCreateParent(NULL),
-      m_iCreateCount(0),
-      m_iCreateFlag(XFA_RESOLVENODE_RSTYPE_CreateNodeOne),
-      m_iCurAllStart(-1),
-      m_pAllStartParent(NULL) {}
-CXFA_NodeHelper::~CXFA_NodeHelper(void) {}
-CXFA_Node* CXFA_NodeHelper::XFA_ResolveNodes_GetOneChild(
-    CXFA_Node* parent,
-    const FX_WCHAR* pwsName,
-    FX_BOOL bIsClassName) {
-  if (parent == NULL) {
-    return NULL;
-  }
-  CXFA_NodeArray siblings;
-  uint32_t uNameHash = FX_HashCode_String_GetW(pwsName, FXSYS_wcslen(pwsName));
-  XFA_NodeAcc_TraverseAnySiblings(parent, uNameHash, &siblings, bIsClassName);
-  if (siblings.GetSize() == 0) {
-    return NULL;
-  }
-  return siblings[0];
-}
-int32_t CXFA_NodeHelper::XFA_CountSiblings(CXFA_Node* pNode,
-                                           XFA_LOGIC_TYPE eLogicType,
-                                           CXFA_NodeArray* pSiblings,
-                                           FX_BOOL bIsClassName) {
-  if (!pNode)
-    return 0;
-  CXFA_Node* parent =
-      XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_NoTransparent);
-  if (!parent)
-    return 0;
-  const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
-      parent->GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
-  if (!pProperty && eLogicType == XFA_LOGIC_Transparent) {
-    parent = XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_Transparent);
-    if (parent == NULL) {
-      return 0;
-    }
-  }
-  if (bIsClassName) {
-    return XFA_NodeAcc_TraverseSiblings(parent, pNode->GetClassHashCode(),
-                                        pSiblings, eLogicType, bIsClassName);
-  } else {
-    return XFA_NodeAcc_TraverseSiblings(parent, pNode->GetNameHash(), pSiblings,
-                                        eLogicType, bIsClassName);
-  }
-}
-int32_t CXFA_NodeHelper::XFA_NodeAcc_TraverseAnySiblings(
-    CXFA_Node* parent,
-    FX_DWORD dNameHash,
-    CXFA_NodeArray* pSiblings,
-    FX_BOOL bIsClassName) {
-  if (parent == NULL || pSiblings == NULL) {
-    return 0;
-  }
-  int32_t nCount = 0;
-  int32_t i = 0;
-  CXFA_NodeArray properties;
-  parent->GetNodeList(properties, XFA_NODEFILTER_Properties);
-  int32_t nProperties = properties.GetSize();
-  for (i = 0; i < nProperties; ++i) {
-    CXFA_Node* child = properties[i];
-    if (bIsClassName) {
-      if (child->GetClassHashCode() == dNameHash) {
-        pSiblings->Add(child);
-        nCount++;
-      }
-    } else {
-      if (child->GetNameHash() == dNameHash) {
-        pSiblings->Add(child);
-        nCount++;
-      }
-    }
-    if (nCount > 0) {
-      return nCount;
-    }
-    nCount += XFA_NodeAcc_TraverseAnySiblings(child, dNameHash, pSiblings,
-                                              bIsClassName);
-  }
-  CXFA_NodeArray children;
-  parent->GetNodeList(children, XFA_NODEFILTER_Children);
-  int32_t nChildren = children.GetSize();
-  for (i = 0; i < nChildren; i++) {
-    CXFA_Node* child = children[i];
-    if (bIsClassName) {
-      if (child->GetClassHashCode() == dNameHash) {
-        if (pSiblings) {
-          pSiblings->Add(child);
-        }
-        nCount++;
-      }
-    } else {
-      if (child->GetNameHash() == dNameHash) {
-        if (pSiblings) {
-          pSiblings->Add(child);
-        }
-        nCount++;
-      }
-    }
-    if (nCount > 0) {
-      return nCount;
-    }
-    nCount += XFA_NodeAcc_TraverseAnySiblings(child, dNameHash, pSiblings,
-                                              bIsClassName);
-  }
-  return nCount;
-}
-int32_t CXFA_NodeHelper::XFA_NodeAcc_TraverseSiblings(CXFA_Node* parent,
-                                                      FX_DWORD dNameHash,
-                                                      CXFA_NodeArray* pSiblings,
-                                                      XFA_LOGIC_TYPE eLogicType,
-                                                      FX_BOOL bIsClassName,
-                                                      FX_BOOL bIsFindProperty) {
-  if (parent == NULL || pSiblings == NULL) {
-    return 0;
-  }
-  int32_t nCount = 0;
-  int32_t i = 0;
-  if (bIsFindProperty) {
-    CXFA_NodeArray properties;
-    parent->GetNodeList(properties, XFA_NODEFILTER_Properties);
-    int32_t nProperties = properties.GetSize();
-    for (i = 0; i < nProperties; ++i) {
-      CXFA_Node* child = properties[i];
-      if (bIsClassName) {
-        if (child->GetClassHashCode() == dNameHash) {
-          pSiblings->Add(child);
-          nCount++;
-        }
-      } else {
-        if (child->GetNameHash() == dNameHash) {
-          if (child->GetClassID() != XFA_ELEMENT_PageSet &&
-              child->GetClassID() != XFA_ELEMENT_Extras &&
-              child->GetClassID() != XFA_ELEMENT_Items) {
-            pSiblings->Add(child);
-            nCount++;
-          }
-        }
-      }
-      if (child->IsUnnamed() && child->GetClassID() == XFA_ELEMENT_PageSet) {
-        nCount += XFA_NodeAcc_TraverseSiblings(child, dNameHash, pSiblings,
-                                               eLogicType, bIsClassName, FALSE);
-      }
-    }
-    if (nCount > 0) {
-      return nCount;
-    }
-  }
-  CXFA_NodeArray children;
-  parent->GetNodeList(children, XFA_NODEFILTER_Children);
-  int32_t nChildren = children.GetSize();
-  for (i = 0; i < nChildren; i++) {
-    CXFA_Node* child = children[i];
-    if (child->GetClassID() == XFA_ELEMENT_Variables) {
-      continue;
-    }
-    if (bIsClassName) {
-      if (child->GetClassHashCode() == dNameHash) {
-        if (pSiblings) {
-          pSiblings->Add(child);
-        }
-        nCount++;
-      }
-    } else {
-      if (child->GetNameHash() == dNameHash) {
-        if (pSiblings) {
-          pSiblings->Add(child);
-        }
-        nCount++;
-      }
-    }
-    if (eLogicType == XFA_LOGIC_NoTransparent) {
-      continue;
-    }
-    if (XFA_NodeIsTransparent(child) &&
-        child->GetClassID() != XFA_ELEMENT_PageSet) {
-      nCount += XFA_NodeAcc_TraverseSiblings(child, dNameHash, pSiblings,
-                                             eLogicType, bIsClassName, FALSE);
-    }
-  }
-  return nCount;
-}
-CXFA_Node* CXFA_NodeHelper::XFA_ResolveNodes_GetParent(
-    CXFA_Node* pNode,
-    XFA_LOGIC_TYPE eLogicType) {
-  if (!pNode) {
-    return NULL;
-  }
-  if (eLogicType == XFA_LOGIC_NoTransparent) {
-    return pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  }
-  CXFA_Node* parent;
-  CXFA_Node* node = pNode;
-  while (TRUE) {
-    parent = XFA_ResolveNodes_GetParent(node);
-    if (parent == NULL) {
-      break;
-    }
-    XFA_ELEMENT parentElement = parent->GetClassID();
-    if ((!parent->IsUnnamed() && parentElement != XFA_ELEMENT_SubformSet) ||
-        parentElement == XFA_ELEMENT_Variables) {
-      break;
-    }
-    node = parent;
-  }
-  return parent;
-}
-int32_t CXFA_NodeHelper::XFA_GetIndex(CXFA_Node* pNode,
-                                      XFA_LOGIC_TYPE eLogicType,
-                                      FX_BOOL bIsProperty,
-                                      FX_BOOL bIsClassIndex) {
-  CXFA_Node* parent =
-      XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_NoTransparent);
-  if (parent == NULL) {
-    return 0;
-  }
-  if (!bIsProperty && eLogicType == XFA_LOGIC_Transparent) {
-    parent = XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_Transparent);
-    if (parent == NULL) {
-      return 0;
-    }
-  }
-  FX_DWORD dwHashName = pNode->GetNameHash();
-  if (bIsClassIndex) {
-    dwHashName = pNode->GetClassHashCode();
-  }
-  CXFA_NodeArray siblings;
-  int32_t iSize = XFA_NodeAcc_TraverseSiblings(parent, dwHashName, &siblings,
-                                               eLogicType, bIsClassIndex);
-  for (int32_t i = 0; i < iSize; ++i) {
-    CXFA_Node* child = siblings[i];
-    if (child == pNode) {
-      return i;
-    }
-  }
-  return 0;
-}
-void CXFA_NodeHelper::XFA_GetNameExpression(CXFA_Node* refNode,
-                                            CFX_WideString& wsName,
-                                            FX_BOOL bIsAllPath,
-                                            XFA_LOGIC_TYPE eLogicType) {
-  wsName.Empty();
-  if (bIsAllPath) {
-    XFA_GetNameExpression(refNode, wsName, FALSE, eLogicType);
-    CFX_WideString wsParent;
-    CXFA_Node* parent =
-        XFA_ResolveNodes_GetParent(refNode, XFA_LOGIC_NoTransparent);
-    while (parent) {
-      XFA_GetNameExpression(parent, wsParent, FALSE, eLogicType);
-      wsParent += L".";
-      wsParent += wsName;
-      wsName = wsParent;
-      parent = XFA_ResolveNodes_GetParent(parent, XFA_LOGIC_NoTransparent);
-    }
-    return;
-  }
-
-  CFX_WideStringC wsTagName;
-  CFX_WideString ws;
-  FX_BOOL bIsProperty = XFA_NodeIsProperty(refNode);
-  if (refNode->IsUnnamed() ||
-      (bIsProperty && refNode->GetClassID() != XFA_ELEMENT_PageSet)) {
-    refNode->GetClassName(wsTagName);
-    ws = wsTagName;
-    wsName.Format(L"#%s[%d]", (const FX_WCHAR*)ws,
-                  XFA_GetIndex(refNode, eLogicType, bIsProperty, TRUE));
-    return;
-  }
-  ws = refNode->GetCData(XFA_ATTRIBUTE_Name);
-  ws.Replace(L".", L"\\.");
-  wsName.Format(L"%s[%d]", (const FX_WCHAR*)ws,
-                XFA_GetIndex(refNode, eLogicType, bIsProperty, FALSE));
-}
-
-FX_BOOL CXFA_NodeHelper::XFA_NodeIsTransparent(CXFA_Node* refNode) {
-  if (refNode == NULL) {
-    return FALSE;
-  }
-  XFA_ELEMENT eRefNode = refNode->GetClassID();
-  if ((refNode->IsUnnamed() && refNode->IsContainerNode()) ||
-      eRefNode == XFA_ELEMENT_SubformSet || eRefNode == XFA_ELEMENT_Area ||
-      eRefNode == XFA_ELEMENT_Proto) {
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_NodeHelper::XFA_CreateNode_ForCondition(
-    CFX_WideString& wsCondition) {
-  int32_t iLen = wsCondition.GetLength();
-  CFX_WideString wsIndex = FX_WSTRC(L"0");
-  FX_BOOL bAll = FALSE;
-
-  if (iLen == 0) {
-    m_iCreateFlag = XFA_RESOLVENODE_RSTYPE_CreateNodeOne;
-    return FALSE;
-  }
-  if (wsCondition.GetAt(0) == '[') {
-    int32_t i = 1;
-    for (; i < iLen; ++i) {
-      FX_WCHAR ch = wsCondition[i];
-      if (ch == ' ') {
-        continue;
-      }
-      if (ch == '+' || ch == '-') {
-        break;
-      } else if (ch == '*') {
-        bAll = TRUE;
-        break;
-      } else {
-        break;
-      }
-    }
-    if (bAll) {
-      wsIndex = FX_WSTRC(L"1");
-      m_iCreateFlag = XFA_RESOLVENODE_RSTYPE_CreateNodeAll;
-    } else {
-      m_iCreateFlag = XFA_RESOLVENODE_RSTYPE_CreateNodeOne;
-      wsIndex = wsCondition.Mid(i, iLen - 1 - i);
-    }
-    int32_t iIndex = wsIndex.GetInteger();
-    m_iCreateCount = iIndex;
-    return TRUE;
-  }
-  return FALSE;
-}
-FX_BOOL CXFA_NodeHelper::XFA_ResolveNodes_CreateNode(
-    CFX_WideString wsName,
-    CFX_WideString wsCondition,
-    FX_BOOL bLastNode,
-    CXFA_ScriptContext* pScriptContext) {
-  if (m_pCreateParent == NULL) {
-    return FALSE;
-  }
-  FX_BOOL bIsClassName = FALSE;
-  FX_BOOL bResult = FALSE;
-  if (wsName.GetAt(0) == '!') {
-    wsName = wsName.Right(wsName.GetLength() - 1);
-    m_pCreateParent = ToNode(
-        pScriptContext->GetDocument()->GetXFAObject(XFA_HASHCODE_Datasets));
-  }
-  if (wsName.GetAt(0) == '#') {
-    bIsClassName = TRUE;
-    wsName = wsName.Right(wsName.GetLength() - 1);
-  }
-  if (m_iCreateCount == 0) {
-    XFA_CreateNode_ForCondition(wsCondition);
-  }
-  if (bIsClassName) {
-    const XFA_ELEMENTINFO* lpElement = XFA_GetElementByName(wsName);
-    if (lpElement == NULL) {
-      return FALSE;
-    }
-    for (int32_t iIndex = 0; iIndex < m_iCreateCount; iIndex++) {
-      CXFA_Node* pNewNode =
-          m_pCreateParent->CreateSamePacketNode(lpElement->eName);
-      if (pNewNode) {
-        m_pCreateParent->InsertChild(pNewNode);
-        if (iIndex == m_iCreateCount - 1) {
-          m_pCreateParent = pNewNode;
-        }
-        bResult = TRUE;
-      }
-    }
-  } else {
-    XFA_ELEMENT eClassType = XFA_ELEMENT_DataGroup;
-    if (bLastNode) {
-      eClassType = m_eLastCreateType;
-    }
-    for (int32_t iIndex = 0; iIndex < m_iCreateCount; iIndex++) {
-      CXFA_Node* pNewNode = m_pCreateParent->CreateSamePacketNode(eClassType);
-      if (pNewNode) {
-        pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, wsName);
-        pNewNode->CreateXMLMappingNode();
-        m_pCreateParent->InsertChild(pNewNode);
-        if (iIndex == m_iCreateCount - 1) {
-          m_pCreateParent = pNewNode;
-        }
-        bResult = TRUE;
-      }
-    }
-  }
-  if (!bResult) {
-    m_pCreateParent = NULL;
-  }
-  return bResult;
-}
-void CXFA_NodeHelper::XFA_SetCreateNodeType(CXFA_Node* refNode) {
-  if (refNode == NULL) {
-    return;
-  }
-  if (refNode->GetClassID() == XFA_ELEMENT_Subform) {
-    m_eLastCreateType = XFA_ELEMENT_DataGroup;
-  } else if (refNode->GetClassID() == XFA_ELEMENT_Field) {
-    m_eLastCreateType = XFA_FieldIsMultiListBox(refNode)
-                            ? XFA_ELEMENT_DataGroup
-                            : XFA_ELEMENT_DataValue;
-  } else if (refNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
-    m_eLastCreateType = XFA_ELEMENT_DataValue;
-  }
-}
-FX_BOOL CXFA_NodeHelper::XFA_NodeIsProperty(CXFA_Node* refNode) {
-  CXFA_Node* parent =
-      XFA_ResolveNodes_GetParent(refNode, XFA_LOGIC_NoTransparent);
-  return parent && refNode &&
-         XFA_GetPropertyOfElement(parent->GetClassID(), refNode->GetClassID(),
-                                  XFA_XDPPACKET_UNKNOWN);
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_nodehelper.h b/xfa/src/fxfa/parser/xfa_script_nodehelper.h
deleted file mode 100644
index 318a5a1ab3..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_nodehelper.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_NODEHELPER_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_NODEHELPER_H_
-
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-
-class CXFA_ScriptContext;
-
-enum XFA_LOGIC_TYPE {
-  XFA_LOGIC_NoTransparent,
-  XFA_LOGIC_Transparent,
-};
-
-class CXFA_NodeHelper {
- public:
-  CXFA_NodeHelper(void);
-  ~CXFA_NodeHelper(void);
-  CXFA_Node* XFA_ResolveNodes_GetOneChild(CXFA_Node* parent,
-                                          const FX_WCHAR* pwsName,
-                                          FX_BOOL bIsClassName = FALSE);
-  CXFA_Node* XFA_ResolveNodes_GetParent(
-      CXFA_Node* pNode,
-      XFA_LOGIC_TYPE eLogicType = XFA_LOGIC_NoTransparent);
-
-  int32_t XFA_NodeAcc_TraverseSiblings(CXFA_Node* parent,
-                                       FX_DWORD dNameHash,
-                                       CXFA_NodeArray* pSiblings,
-                                       XFA_LOGIC_TYPE eLogicType,
-                                       FX_BOOL bIsClassName = FALSE,
-                                       FX_BOOL bIsFindProperty = TRUE);
-  int32_t XFA_NodeAcc_TraverseAnySiblings(CXFA_Node* parent,
-                                          FX_DWORD dNameHash,
-                                          CXFA_NodeArray* pSiblings,
-                                          FX_BOOL bIsClassName = FALSE);
-  int32_t XFA_CountSiblings(CXFA_Node* pNode,
-                            XFA_LOGIC_TYPE eLogicType,
-                            CXFA_NodeArray* pSiblings,
-                            FX_BOOL bIsClassName = FALSE);
-  int32_t XFA_GetIndex(CXFA_Node* pNode,
-                       XFA_LOGIC_TYPE eLogicType = XFA_LOGIC_NoTransparent,
-                       FX_BOOL bIsProperty = FALSE,
-                       FX_BOOL bIsClassIndex = FALSE);
-  void XFA_GetNameExpression(
-      CXFA_Node* refNode,
-      CFX_WideString& wsName,
-      FX_BOOL bIsAllPath,
-      XFA_LOGIC_TYPE eLogicType = XFA_LOGIC_NoTransparent);
-  FX_BOOL XFA_NodeIsTransparent(CXFA_Node* refNode);
-  FX_BOOL XFA_ResolveNodes_CreateNode(CFX_WideString wsName,
-                                      CFX_WideString wsCondition,
-                                      FX_BOOL bLastNode,
-                                      CXFA_ScriptContext* pScriptContext);
-  FX_BOOL XFA_CreateNode_ForCondition(CFX_WideString& wsCondition);
-  void XFA_SetCreateNodeType(CXFA_Node* refNode);
-  FX_BOOL XFA_NodeIsProperty(CXFA_Node* refNode);
-
- public:
-  XFA_ELEMENT m_eLastCreateType;
-  CXFA_Node* m_pCreateParent;
-  int32_t m_iCreateCount;
-  XFA_RESOVENODE_RSTYPE m_iCreateFlag;
-  int32_t m_iCurAllStart;
-  CXFA_Node* m_pAllStartParent;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_NODEHELPER_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_resolveprocessor.cpp b/xfa/src/fxfa/parser/xfa_script_resolveprocessor.cpp
deleted file mode 100644
index 3f4a9c7b88..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_resolveprocessor.cpp
+++ /dev/null
@@ -1,825 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_resolveprocessor.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_script_imp.h"
-#include "xfa/src/fxfa/parser/xfa_script_nodehelper.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CXFA_ResolveProcessor::CXFA_ResolveProcessor(void)
-    : m_pNodeHelper(NULL), m_iCurStart(0) {
-  m_pNodeHelper = new CXFA_NodeHelper;
-}
-CXFA_ResolveProcessor::~CXFA_ResolveProcessor(void) {
-  if (m_pNodeHelper) {
-    delete m_pNodeHelper;
-    m_pNodeHelper = NULL;
-  }
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes(CXFA_ResolveNodesData& rnd) {
-  if (rnd.m_CurNode == NULL) {
-    return -1;
-  }
-  if (!rnd.m_CurNode->IsNode()) {
-    if (rnd.m_dwStyles & XFA_RESOLVENODE_Attributes) {
-      return XFA_ResolveNodes_ForAttributeRs(rnd.m_CurNode, rnd, rnd.m_wsName);
-    }
-    return 0;
-  }
-  if (rnd.m_dwStyles & XFA_RESOLVENODE_AnyChild) {
-    return XFA_ResolveNodes_AnyChild(rnd);
-  }
-  FX_WCHAR wch = rnd.m_wsName.GetAt(0);
-  switch (wch) {
-    case '$':
-      return XFA_ResolveNodes_Dollar(rnd);
-    case '!':
-      return XFA_ResolveNodes_Excalmatory(rnd);
-    case '#':
-      return XFA_ResolveNodes_NumberSign(rnd);
-    case '*':
-      return XFA_ResolveNodes_Asterisk(rnd);
-    case '.':
-      return XFA_ResolveNodes_AnyChild(rnd);
-    default:
-      break;
-  }
-  if (rnd.m_uHashName == XFA_HASHCODE_This && rnd.m_nLevel == 0) {
-    rnd.m_Nodes.Add(rnd.m_pSC->GetThisObject());
-    return 1;
-  } else if (rnd.m_CurNode->GetClassID() == XFA_ELEMENT_Xfa) {
-    CXFA_Object* pObjNode =
-        rnd.m_pSC->GetDocument()->GetXFAObject(rnd.m_uHashName);
-    if (pObjNode) {
-      rnd.m_Nodes.Add(pObjNode);
-    } else if (rnd.m_uHashName == XFA_HASHCODE_Xfa) {
-      rnd.m_Nodes.Add(rnd.m_CurNode);
-    } else if ((rnd.m_dwStyles & XFA_RESOLVENODE_Attributes) &&
-               XFA_ResolveNodes_ForAttributeRs(rnd.m_CurNode, rnd,
-                                               rnd.m_wsName)) {
-      return 1;
-    }
-    if (rnd.m_Nodes.GetSize() > 0) {
-      XFA_ResolveNode_FilterCondition(rnd, rnd.m_wsCondition);
-    }
-    return rnd.m_Nodes.GetSize();
-  }
-  int32_t nRet = XFA_ResolveNodes_Normal(rnd);
-  if (nRet < 1 && rnd.m_uHashName == XFA_HASHCODE_Xfa) {
-    rnd.m_Nodes.Add(rnd.m_pSC->GetDocument()->GetRoot());
-  }
-  return rnd.m_Nodes.GetSize();
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_AnyChild(
-    CXFA_ResolveNodesData& rnd) {
-  CFX_WideString wsName = rnd.m_wsName.Right(rnd.m_wsName.GetLength() - 1);
-  CFX_WideString wsCondition = rnd.m_wsCondition;
-  CXFA_Node* findNode = NULL;
-  CXFA_NodeArray siblings;
-  FX_BOOL bClassName = FALSE;
-  if (wsName.GetAt(0) == '#') {
-    bClassName = TRUE;
-    wsName = wsName.Right(wsName.GetLength() - 1);
-  }
-  findNode = m_pNodeHelper->XFA_ResolveNodes_GetOneChild(ToNode(rnd.m_CurNode),
-                                                         wsName, bClassName);
-  if (findNode == NULL) {
-    return 0;
-  }
-  if (wsCondition.IsEmpty()) {
-    rnd.m_Nodes.Add(findNode);
-    return rnd.m_Nodes.GetSize();
-  }
-  m_pNodeHelper->XFA_CountSiblings(findNode, XFA_LOGIC_Transparent,
-                                   (CXFA_NodeArray*)&rnd.m_Nodes, bClassName);
-  XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-  return rnd.m_Nodes.GetSize();
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_Dollar(
-    CXFA_ResolveNodesData& rnd) {
-  CXFA_ObjArray& nodes = rnd.m_Nodes;
-  CFX_WideString wsName = rnd.m_wsName;
-  CFX_WideString wsCondition = rnd.m_wsCondition;
-  int32_t iNameLen = wsName.GetLength();
-  if (iNameLen == 1) {
-    nodes.Add(rnd.m_CurNode);
-    return 1;
-  }
-  if (rnd.m_nLevel > 0) {
-    return -1;
-  }
-  FX_DWORD dwNameHash =
-      FX_HashCode_String_GetW((const FX_WCHAR*)wsName + 1, iNameLen - 1);
-  if (dwNameHash == XFA_HASHCODE_Xfa) {
-    nodes.Add(rnd.m_pSC->GetDocument()->GetRoot());
-  } else {
-    CXFA_Object* pObjNode = rnd.m_pSC->GetDocument()->GetXFAObject(dwNameHash);
-    if (pObjNode) {
-      rnd.m_Nodes.Add(pObjNode);
-    }
-  }
-  if (rnd.m_Nodes.GetSize() > 0) {
-    XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-  }
-  return rnd.m_Nodes.GetSize();
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_Excalmatory(
-    CXFA_ResolveNodesData& rnd) {
-  if (rnd.m_nLevel > 0) {
-    return 0;
-  }
-  CXFA_Node* datasets =
-      ToNode(rnd.m_pSC->GetDocument()->GetXFAObject(XFA_HASHCODE_Datasets));
-  if (!datasets) {
-    return 0;
-  }
-  CXFA_ResolveNodesData rndFind;
-  rndFind.m_pSC = rnd.m_pSC;
-  rndFind.m_CurNode = datasets;
-  rndFind.m_wsName = rnd.m_wsName.Right(rnd.m_wsName.GetLength() - 1);
-  rndFind.m_uHashName =
-      FX_HashCode_String_GetW(rndFind.m_wsName, rndFind.m_wsName.GetLength());
-  rndFind.m_nLevel = rnd.m_nLevel + 1;
-  rndFind.m_dwStyles = XFA_RESOLVENODE_Children;
-  rndFind.m_wsCondition = rnd.m_wsCondition;
-  XFA_ResolveNodes(rndFind);
-  if (rndFind.m_Nodes.GetSize() > 0) {
-    rnd.m_Nodes.Append(rndFind.m_Nodes);
-    rndFind.m_Nodes.RemoveAll();
-  }
-  return rnd.m_Nodes.GetSize();
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_NumberSign(
-    CXFA_ResolveNodesData& rnd) {
-  CFX_WideString wsName = rnd.m_wsName.Right(rnd.m_wsName.GetLength() - 1);
-  CFX_WideString wsCondition = rnd.m_wsCondition;
-  CXFA_Node* curNode = ToNode(rnd.m_CurNode);
-  if (XFA_ResolveNodes_ForAttributeRs(curNode, rnd, wsName)) {
-    return 1;
-  }
-  CXFA_ResolveNodesData rndFind;
-  rndFind.m_pSC = rnd.m_pSC;
-  rndFind.m_nLevel = rnd.m_nLevel + 1;
-  rndFind.m_dwStyles = rnd.m_dwStyles;
-  rndFind.m_dwStyles |= XFA_RESOLVENODE_TagName;
-  rndFind.m_dwStyles &= ~XFA_RESOLVENODE_Attributes;
-  rndFind.m_wsName = wsName;
-  rndFind.m_uHashName =
-      FX_HashCode_String_GetW(rndFind.m_wsName, rndFind.m_wsName.GetLength());
-  rndFind.m_wsCondition = wsCondition;
-  rndFind.m_CurNode = curNode;
-  XFA_ResolveNodes_Normal(rndFind);
-  if (rndFind.m_Nodes.GetSize() > 0) {
-    if (wsCondition.GetLength() == 0 && rndFind.m_Nodes.Find(curNode) >= 0) {
-      rnd.m_Nodes.Add(curNode);
-    } else {
-      rnd.m_Nodes.Append(rndFind.m_Nodes);
-      rndFind.m_Nodes.RemoveAll();
-    }
-  }
-  return rnd.m_Nodes.GetSize();
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_ForAttributeRs(
-    CXFA_Object* curNode,
-    CXFA_ResolveNodesData& rnd,
-    const CFX_WideStringC& strAttr) {
-  const XFA_SCRIPTATTRIBUTEINFO* lpScriptAttribute =
-      XFA_GetScriptAttributeByName(curNode->GetClassID(), strAttr);
-  if (lpScriptAttribute) {
-    rnd.m_pScriptAttribute = lpScriptAttribute;
-    rnd.m_Nodes.Add(curNode);
-    rnd.m_dwFlag = XFA_RESOVENODE_RSTYPE_Attribute;
-    return 1;
-  }
-  return 0;
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_Normal(
-    CXFA_ResolveNodesData& rnd) {
-  if (rnd.m_nLevel > 32) {
-    return 0;
-  }
-  if (!rnd.m_CurNode->IsNode()) {
-    return 0;
-  }
-  CXFA_Node* curNode = ToNode(rnd.m_CurNode);
-  CXFA_ObjArray& nodes = rnd.m_Nodes;
-  int32_t nNum = nodes.GetSize();
-  FX_DWORD dwStyles = rnd.m_dwStyles;
-  CFX_WideString& wsName = rnd.m_wsName;
-  uint32_t uNameHash = rnd.m_uHashName;
-  CFX_WideString& wsCondition = rnd.m_wsCondition;
-  CXFA_ResolveNodesData rndFind;
-  rndFind.m_wsName = rnd.m_wsName;
-  rndFind.m_wsCondition = rnd.m_wsCondition;
-  rndFind.m_pSC = rnd.m_pSC;
-  rndFind.m_nLevel = rnd.m_nLevel + 1;
-  rndFind.m_uHashName = uNameHash;
-  CXFA_NodeArray children;
-  CXFA_NodeArray properties;
-  CXFA_Node* pVariablesNode = NULL;
-  CXFA_Node* pPageSetNode = NULL;
-  CXFA_Node* pChild = curNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-  while (pChild) {
-    if (pChild->GetClassID() == XFA_ELEMENT_Variables) {
-      pVariablesNode = pChild;
-      pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-      continue;
-    } else if (pChild->GetClassID() == XFA_ELEMENT_PageSet) {
-      pPageSetNode = pChild;
-      pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-      continue;
-    } else {
-      const XFA_PROPERTY* pPropert = XFA_GetPropertyOfElement(
-          curNode->GetClassID(), pChild->GetClassID(), XFA_XDPPACKET_UNKNOWN);
-      if (pPropert) {
-        properties.Add(pChild);
-      } else {
-        children.Add(pChild);
-      }
-    }
-    pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-  }
-  if ((dwStyles & XFA_RESOLVENODE_Properties) && pVariablesNode) {
-    uint32_t uPropHash = pVariablesNode->GetClassHashCode();
-    if (uPropHash == uNameHash) {
-      nodes.Add(pVariablesNode);
-    } else {
-      rndFind.m_CurNode = pVariablesNode;
-      XFA_ResolveNodes_SetStylesForChild(dwStyles, rndFind);
-      CFX_WideString wsSaveCondition = rndFind.m_wsCondition;
-      rndFind.m_wsCondition.Empty();
-      XFA_ResolveNodes_Normal(rndFind);
-      rndFind.m_wsCondition = wsSaveCondition;
-      if (rndFind.m_Nodes.GetSize() > 0) {
-        nodes.Append(rndFind.m_Nodes);
-        rndFind.m_Nodes.RemoveAll();
-      }
-    }
-    if (nodes.GetSize() > nNum) {
-      XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-      if (nodes.GetSize() > 0) {
-        return 1;
-      }
-      return 0;
-    }
-  }
-  if (dwStyles & XFA_RESOLVENODE_Children) {
-    FX_BOOL bSetFlag = FALSE;
-    if (pPageSetNode && (dwStyles & XFA_RESOLVENODE_Properties)) {
-      children.Add(pPageSetNode);
-    }
-    for (int32_t i = 0; i < children.GetSize(); i++) {
-      CXFA_Node* child = children[i];
-      if (dwStyles & XFA_RESOLVENODE_TagName) {
-        if (child->GetClassHashCode() == uNameHash) {
-          nodes.Add(child);
-        }
-      } else if (child->GetNameHash() == uNameHash) {
-        nodes.Add(child);
-      }
-      if (m_pNodeHelper->XFA_NodeIsTransparent(child) &&
-          child->GetClassID() != XFA_ELEMENT_PageSet) {
-        if (!bSetFlag) {
-          XFA_ResolveNodes_SetStylesForChild(dwStyles, rndFind);
-          bSetFlag = TRUE;
-        }
-        rndFind.m_CurNode = child;
-        CFX_WideString wsSaveCondition = rndFind.m_wsCondition;
-        rndFind.m_wsCondition.Empty();
-        XFA_ResolveNodes_Normal(rndFind);
-        rndFind.m_wsCondition = wsSaveCondition;
-        if (rndFind.m_Nodes.GetSize() > 0) {
-          nodes.Append(rndFind.m_Nodes);
-          rndFind.m_Nodes.RemoveAll();
-        }
-      }
-    }
-    if (nodes.GetSize() > nNum) {
-      if (!(dwStyles & XFA_RESOLVENODE_ALL)) {
-        CXFA_NodeArray upArrayNodes;
-        if (m_pNodeHelper->XFA_NodeIsTransparent(ToNode(curNode))) {
-          m_pNodeHelper->XFA_CountSiblings(
-              ToNode(nodes[0]), XFA_LOGIC_Transparent, &upArrayNodes,
-              !!(dwStyles & XFA_RESOLVENODE_TagName));
-        }
-        if (upArrayNodes.GetSize() > nodes.GetSize()) {
-          upArrayNodes[0] = ToNode(nodes[0]);
-          nodes.RemoveAll();
-          nodes.Append((CXFA_ObjArray&)upArrayNodes);
-          upArrayNodes.RemoveAll();
-        }
-      }
-      XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-      if (nodes.GetSize() > 0) {
-        return 1;
-      }
-      return 0;
-    }
-  }
-  if (dwStyles & XFA_RESOLVENODE_Attributes) {
-    if (XFA_ResolveNodes_ForAttributeRs(curNode, rnd, wsName)) {
-      return 1;
-    }
-  }
-  if (dwStyles & XFA_RESOLVENODE_Properties) {
-    for (int32_t i = 0; i < properties.GetSize(); i++) {
-      CXFA_Node* childProperty = properties[i];
-      if (childProperty->IsUnnamed()) {
-        uint32_t uPropHash = childProperty->GetClassHashCode();
-        if (uPropHash == uNameHash) {
-          nodes.Add(childProperty);
-        }
-      } else if (childProperty->GetNameHash() == uNameHash &&
-                 childProperty->GetClassID() != XFA_ELEMENT_Extras &&
-                 childProperty->GetClassID() != XFA_ELEMENT_Items) {
-        nodes.Add(childProperty);
-      }
-    }
-    if (nodes.GetSize() > nNum) {
-      XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-      if (nodes.GetSize() > 0) {
-        return 1;
-      }
-      return 0;
-    }
-    CXFA_Node* pProp = NULL;
-    if (XFA_ELEMENT_Subform == curNode->GetClassID() &&
-        XFA_HASHCODE_Occur == uNameHash) {
-      CXFA_Node* pInstanceManager =
-          curNode->AsNode()->GetInstanceMgrOfSubform();
-      if (pInstanceManager) {
-        pProp = pInstanceManager->GetProperty(0, XFA_ELEMENT_Occur, TRUE);
-      }
-    } else {
-      const XFA_ELEMENTINFO* pElement = XFA_GetElementByName(wsName);
-      if (pElement) {
-        pProp = curNode->AsNode()->GetProperty(
-            0, pElement->eName, pElement->eName != XFA_ELEMENT_PageSet);
-      }
-    }
-    if (pProp) {
-      nodes.Add(pProp);
-      return nodes.GetSize();
-    }
-  }
-  CXFA_Node* parentNode = m_pNodeHelper->XFA_ResolveNodes_GetParent(
-      curNode->AsNode(), XFA_LOGIC_NoTransparent);
-  uint32_t uCurClassHash = curNode->GetClassHashCode();
-  if (!parentNode) {
-    if (uCurClassHash == uNameHash) {
-      nodes.Add(curNode->AsNode());
-      XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-      if (nodes.GetSize() > 0) {
-        return 1;
-      }
-    }
-    return 0;
-  }
-  if (dwStyles & XFA_RESOLVENODE_Siblings) {
-    CXFA_Node* child = parentNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    FX_DWORD dwSubStyles =
-        XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties;
-    if (dwStyles & XFA_RESOLVENODE_TagName) {
-      dwSubStyles |= XFA_RESOLVENODE_TagName;
-    }
-    if (dwStyles & XFA_RESOLVENODE_ALL) {
-      dwSubStyles |= XFA_RESOLVENODE_ALL;
-    }
-    rndFind.m_dwStyles = dwSubStyles;
-    while (child) {
-      if (child == curNode) {
-        if (dwStyles & XFA_RESOLVENODE_TagName) {
-          if (uCurClassHash == uNameHash) {
-            nodes.Add(curNode);
-          }
-        } else {
-          if (child->GetNameHash() == uNameHash) {
-            nodes.Add(curNode);
-            if (rnd.m_nLevel == 0 && wsCondition.GetLength() == 0) {
-              nodes.RemoveAll();
-              nodes.Add(curNode);
-              return 1;
-            }
-          }
-        }
-        child = child->GetNodeItem(XFA_NODEITEM_NextSibling);
-        continue;
-      }
-      if (dwStyles & XFA_RESOLVENODE_TagName) {
-        if (child->GetClassHashCode() == uNameHash) {
-          nodes.Add(child);
-        }
-      } else if (child->GetNameHash() == uNameHash) {
-        nodes.Add(child);
-      }
-      const XFA_PROPERTY* pPropert = XFA_GetPropertyOfElement(
-          parentNode->GetClassID(), child->GetClassID(), XFA_XDPPACKET_UNKNOWN);
-      FX_BOOL bInnerSearch = FALSE;
-      if (pPropert) {
-        if ((child->GetClassID() == XFA_ELEMENT_Variables ||
-             child->GetClassID() == XFA_ELEMENT_PageSet)) {
-          bInnerSearch = TRUE;
-        }
-      } else {
-        if (m_pNodeHelper->XFA_NodeIsTransparent(child)) {
-          bInnerSearch = TRUE;
-        }
-      }
-      if (bInnerSearch) {
-        rndFind.m_CurNode = child;
-        CFX_WideString wsOriginCondition = rndFind.m_wsCondition;
-        rndFind.m_wsCondition.Empty();
-        FX_DWORD dwOriginStyle = rndFind.m_dwStyles;
-        rndFind.m_dwStyles = dwOriginStyle | XFA_RESOLVENODE_ALL;
-        XFA_ResolveNodes_Normal(rndFind);
-        rndFind.m_dwStyles = dwOriginStyle;
-        rndFind.m_wsCondition = wsOriginCondition;
-        if (rndFind.m_Nodes.GetSize() > 0) {
-          nodes.Append(rndFind.m_Nodes);
-          rndFind.m_Nodes.RemoveAll();
-        }
-      }
-      child = child->GetNodeItem(XFA_NODEITEM_NextSibling);
-    }
-    if (nodes.GetSize() > nNum) {
-      if (m_pNodeHelper->XFA_NodeIsTransparent(parentNode)) {
-        CXFA_NodeArray upArrayNodes;
-        m_pNodeHelper->XFA_CountSiblings(
-            ToNode(nodes[0]), XFA_LOGIC_Transparent, &upArrayNodes,
-            !!(dwStyles & XFA_RESOLVENODE_TagName));
-        if (upArrayNodes.GetSize() > nodes.GetSize()) {
-          upArrayNodes[0] = ToNode(nodes[0]);
-          nodes.RemoveAll();
-          nodes.Append((CXFA_ObjArray&)upArrayNodes);
-          upArrayNodes.RemoveAll();
-        }
-      }
-      XFA_ResolveNode_FilterCondition(rnd, wsCondition);
-      if (nodes.GetSize() > 0) {
-        return 1;
-      }
-      return 0;
-    }
-  }
-  if (dwStyles & XFA_RESOLVENODE_Parent) {
-    FX_DWORD dwSubStyles = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent |
-                           XFA_RESOLVENODE_Properties;
-    if (dwStyles & XFA_RESOLVENODE_TagName) {
-      dwSubStyles |= XFA_RESOLVENODE_TagName;
-    }
-    if (dwStyles & XFA_RESOLVENODE_ALL) {
-      dwSubStyles |= XFA_RESOLVENODE_ALL;
-    }
-    rndFind.m_dwStyles = dwSubStyles;
-    rndFind.m_CurNode = parentNode;
-    CXFA_NodeArray& array = rnd.m_pSC->GetUpObjectArray();
-    array.Add(parentNode);
-    XFA_ResolveNodes_Normal(rndFind);
-    if (rndFind.m_Nodes.GetSize() > 0) {
-      nodes.Append(rndFind.m_Nodes);
-      rndFind.m_Nodes.RemoveAll();
-    }
-    if (nodes.GetSize() > nNum) {
-      return 1;
-    }
-  }
-  return 0;
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_Asterisk(
-    CXFA_ResolveNodesData& rnd) {
-  CXFA_Node* curNode = ToNode(rnd.m_CurNode);
-  CXFA_ObjArray& nodes = rnd.m_Nodes;
-  CXFA_NodeArray array;
-  curNode->GetNodeList(array,
-                       XFA_NODEFILTER_Children | XFA_NODEFILTER_Properties);
-  nodes.Append((CXFA_ObjArray&)array);
-  return nodes.GetSize();
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_PopStack(
-    CFX_Int32Array& stack) {
-  int32_t nType = -1;
-  int32_t iSize = stack.GetSize() - 1;
-  if (iSize > -1) {
-    nType = stack[iSize];
-    stack.RemoveAt(iSize, 1);
-  }
-  return nType;
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_GetFilter(
-    const CFX_WideStringC& wsExpression,
-    int32_t nStart,
-    CXFA_ResolveNodesData& rnd) {
-  FXSYS_assert(nStart > -1);
-  int32_t iLength = wsExpression.GetLength();
-  if (nStart >= iLength) {
-    return 0;
-  }
-  CFX_WideString& wsName = rnd.m_wsName;
-  CFX_WideString& wsCondition = rnd.m_wsCondition;
-  FX_WCHAR* pNameBuf = wsName.GetBuffer(iLength - nStart);
-  FX_WCHAR* pConditionBuf = wsCondition.GetBuffer(iLength - nStart);
-  int32_t nNameCount = 0;
-  int32_t nConditionCount = 0;
-  CFX_Int32Array stack;
-  int32_t nType = -1;
-  const FX_WCHAR* pSrc = wsExpression.GetPtr();
-  FX_WCHAR wPrev = 0, wCur;
-  FX_BOOL bIsCondition = FALSE;
-  while (nStart < iLength) {
-    wCur = pSrc[nStart++];
-    if (wCur == '.') {
-      if (wPrev == '\\') {
-        pNameBuf[nNameCount - 1] = wPrev = '.';
-        continue;
-      }
-      if (nNameCount == 0) {
-        pNameBuf[nNameCount++] = wCur;
-        continue;
-      }
-      FX_WCHAR wLookahead = nStart < iLength ? pSrc[nStart] : 0;
-      if (wLookahead != '[' && wLookahead != '(') {
-        if (nType < 0) {
-          break;
-        }
-      }
-    }
-    if (wCur == '[' || wCur == '(') {
-      bIsCondition = TRUE;
-    } else if (wCur == '.' && nStart < iLength &&
-               (pSrc[nStart] == '[' || pSrc[nStart] == '(')) {
-      bIsCondition = TRUE;
-    }
-    if (bIsCondition) {
-      pConditionBuf[nConditionCount++] = wCur;
-    } else {
-      pNameBuf[nNameCount++] = wCur;
-    }
-    FX_BOOL bRecursive = TRUE;
-    switch (nType) {
-      case 0:
-        if (wCur == ']') {
-          nType = XFA_ResolveNodes_PopStack(stack);
-          bRecursive = FALSE;
-        }
-        break;
-      case 1:
-        if (wCur == ')') {
-          nType = XFA_ResolveNodes_PopStack(stack);
-          bRecursive = FALSE;
-        }
-        break;
-      case 2:
-        if (wCur == '"') {
-          nType = XFA_ResolveNodes_PopStack(stack);
-          bRecursive = FALSE;
-        }
-        break;
-    }
-    if (bRecursive) {
-      switch (wCur) {
-        case '[':
-          stack.Add(nType);
-          nType = 0;
-          break;
-        case '(':
-          stack.Add(nType);
-          nType = 1;
-          break;
-        case '"':
-          stack.Add(nType);
-          nType = 2;
-          break;
-      }
-    }
-    wPrev = wCur;
-  }
-  if (stack.GetSize() > 0) {
-    return -1;
-  }
-  wsName.ReleaseBuffer(nNameCount);
-  wsName.TrimLeft();
-  wsName.TrimRight();
-  wsCondition.ReleaseBuffer(nConditionCount);
-  wsCondition.TrimLeft();
-  wsCondition.TrimRight();
-  rnd.m_uHashName = FX_HashCode_String_GetW(wsName, wsName.GetLength());
-  return nStart;
-}
-void CXFA_ResolveProcessor::XFA_ResolveNode_ConditionArray(
-    int32_t iCurIndex,
-    CFX_WideString wsCondition,
-    int32_t iFoundCount,
-    CXFA_ResolveNodesData& rnd) {
-  CXFA_NodeArray& findNodes = (CXFA_NodeArray&)rnd.m_Nodes;
-  int32_t iLen = wsCondition.GetLength();
-  FX_BOOL bRelative = FALSE;
-  FX_BOOL bAll = FALSE;
-  int32_t i = 1;
-  for (; i < iLen; ++i) {
-    FX_WCHAR ch = wsCondition[i];
-    if (ch == ' ') {
-      continue;
-    }
-    if (ch == '+' || ch == '-') {
-      bRelative = TRUE;
-      break;
-    } else if (ch == '*') {
-      bAll = TRUE;
-      break;
-    } else {
-      break;
-    }
-  }
-  if (bAll) {
-    if (rnd.m_dwStyles & XFA_RESOLVENODE_CreateNode) {
-      if (rnd.m_dwStyles & XFA_RESOLVENODE_Bind) {
-        m_pNodeHelper->m_pCreateParent = ToNode(rnd.m_CurNode);
-        m_pNodeHelper->m_iCreateCount = 1;
-        findNodes.RemoveAll();
-        m_pNodeHelper->m_iCurAllStart = -1;
-        m_pNodeHelper->m_pAllStartParent = NULL;
-      } else {
-        if (m_pNodeHelper->m_iCurAllStart == -1) {
-          m_pNodeHelper->m_iCurAllStart = m_iCurStart;
-          m_pNodeHelper->m_pAllStartParent = ToNode(rnd.m_CurNode);
-        }
-      }
-    } else if (rnd.m_dwStyles & XFA_RESOLVENODE_BindNew) {
-      if (m_pNodeHelper->m_iCurAllStart == -1) {
-        m_pNodeHelper->m_iCurAllStart = m_iCurStart;
-      }
-    }
-    return;
-  }
-  if (iFoundCount == 1 && !iLen) {
-    return;
-  }
-  CFX_WideString wsIndex;
-  wsIndex = wsCondition.Mid(i, iLen - 1 - i);
-  int32_t iIndex = wsIndex.GetInteger();
-  if (bRelative) {
-    iIndex += iCurIndex;
-  }
-  if (iFoundCount <= iIndex || iIndex < 0) {
-    if (rnd.m_dwStyles & XFA_RESOLVENODE_CreateNode) {
-      m_pNodeHelper->m_pCreateParent = ToNode(rnd.m_CurNode);
-      m_pNodeHelper->m_iCreateCount = iIndex - iFoundCount + 1;
-    }
-    findNodes.RemoveAll();
-  } else {
-    CXFA_Node* ret = findNodes[iIndex];
-    findNodes.RemoveAll();
-    findNodes.Add(ret);
-  }
-}
-void CXFA_ResolveProcessor::XFA_ResolveNode_DoPredicateFilter(
-    int32_t iCurIndex,
-    CFX_WideString wsCondition,
-    int32_t iFoundCount,
-    CXFA_ResolveNodesData& rnd) {
-  CXFA_NodeArray& findNodes = (CXFA_NodeArray&)rnd.m_Nodes;
-  FXSYS_assert(iFoundCount == findNodes.GetSize());
-  CFX_WideString wsExpression;
-  IXFA_ScriptContext* pContext = NULL;
-  XFA_SCRIPTLANGTYPE eLangType = XFA_SCRIPTLANGTYPE_Unkown;
-  if (wsCondition.Left(2) == FX_WSTRC(L".[") &&
-      wsCondition.Right(1) == FX_WSTRC(L"]")) {
-    eLangType = XFA_SCRIPTLANGTYPE_Formcalc;
-  } else if (wsCondition.Left(2) == FX_WSTRC(L".(") &&
-             wsCondition.Right(1) == FX_WSTRC(L")")) {
-    eLangType = XFA_SCRIPTLANGTYPE_Javascript;
-  } else {
-    return;
-  }
-  pContext = rnd.m_pSC;
-  wsExpression = wsCondition.Mid(2, wsCondition.GetLength() - 3);
-  for (int32_t i = iFoundCount - 1; i >= 0; i--) {
-    CXFA_Object* node = findNodes[i];
-    FX_BOOL bRet = FALSE;
-    FXJSE_HVALUE pRetValue = FXJSE_Value_Create(rnd.m_pSC->GetRuntime());
-    bRet = pContext->RunScript(eLangType, wsExpression, pRetValue, node);
-    if (!bRet || !FXJSE_Value_ToBoolean(pRetValue)) {
-      findNodes.RemoveAt(i);
-    }
-    FXJSE_Value_Release(pRetValue);
-  }
-}
-
-void CXFA_ResolveProcessor::XFA_ResolveNode_FilterCondition(
-    CXFA_ResolveNodesData& rnd,
-    CFX_WideString wsCondition) {
-  CXFA_NodeArray& findNodes = (CXFA_NodeArray&)rnd.m_Nodes;
-  int32_t iCurrIndex = 0;
-  const CXFA_NodeArray& array = rnd.m_pSC->GetUpObjectArray();
-  int32_t iSize = array.GetSize();
-  if (iSize) {
-    CXFA_Node* curNode = array[iSize - 1];
-    FX_BOOL bIsProperty = m_pNodeHelper->XFA_NodeIsProperty(curNode);
-    if (curNode->IsUnnamed() ||
-        (bIsProperty && curNode->GetClassID() != XFA_ELEMENT_PageSet)) {
-      iCurrIndex = m_pNodeHelper->XFA_GetIndex(curNode, XFA_LOGIC_Transparent,
-                                               bIsProperty, TRUE);
-    } else {
-      iCurrIndex = m_pNodeHelper->XFA_GetIndex(curNode, XFA_LOGIC_Transparent,
-                                               bIsProperty, FALSE);
-    }
-  }
-  int32_t iFoundCount = findNodes.GetSize();
-  wsCondition.TrimLeft();
-  wsCondition.TrimRight();
-  int32_t iLen = wsCondition.GetLength();
-  if (!iLen) {
-    if (rnd.m_dwStyles & XFA_RESOLVENODE_ALL) {
-      return;
-    }
-    if (iFoundCount == 1) {
-      return;
-    }
-    if (iFoundCount <= iCurrIndex) {
-      if (rnd.m_dwStyles & XFA_RESOLVENODE_CreateNode) {
-        m_pNodeHelper->m_pCreateParent = ToNode(rnd.m_CurNode);
-        m_pNodeHelper->m_iCreateCount = iCurrIndex - iFoundCount + 1;
-      }
-      findNodes.RemoveAll();
-      return;
-    } else {
-      CXFA_Node* ret = findNodes[iCurrIndex];
-      findNodes.RemoveAll();
-      findNodes.Add(ret);
-      return;
-    }
-  }
-  FX_WCHAR wTypeChar = wsCondition[0];
-  switch (wTypeChar) {
-    case '[':
-      XFA_ResolveNode_ConditionArray(iCurrIndex, wsCondition, iFoundCount, rnd);
-      return;
-    case '(':
-      return;
-    case '"':
-      return;
-    case '.':
-      if (iLen > 1 && (wsCondition[1] == '[' || wsCondition[1] == '(')) {
-        XFA_ResolveNode_DoPredicateFilter(iCurrIndex, wsCondition, iFoundCount,
-                                          rnd);
-      }
-    default:
-      return;
-  }
-}
-void CXFA_ResolveProcessor::XFA_ResolveNodes_SetStylesForChild(
-    FX_DWORD dwParentStyles,
-    CXFA_ResolveNodesData& rnd) {
-  FX_DWORD dwSubStyles = XFA_RESOLVENODE_Children;
-  if (dwParentStyles & XFA_RESOLVENODE_TagName) {
-    dwSubStyles |= XFA_RESOLVENODE_TagName;
-  }
-  dwSubStyles &= ~XFA_RESOLVENODE_Parent;
-  dwSubStyles &= ~XFA_RESOLVENODE_Siblings;
-  dwSubStyles &= ~XFA_RESOLVENODE_Properties;
-  dwSubStyles |= XFA_RESOLVENODE_ALL;
-  rnd.m_dwStyles = dwSubStyles;
-}
-int32_t CXFA_ResolveProcessor::XFA_ResolveNode_SetResultCreateNode(
-    XFA_RESOLVENODE_RS& resolveNodeRS,
-    CFX_WideString& wsLastCondition) {
-  if (m_pNodeHelper->m_pCreateParent) {
-    resolveNodeRS.nodes.Add(m_pNodeHelper->m_pCreateParent);
-  } else {
-    m_pNodeHelper->XFA_CreateNode_ForCondition(wsLastCondition);
-  }
-  resolveNodeRS.dwFlags = m_pNodeHelper->m_iCreateFlag;
-  if (resolveNodeRS.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) {
-    if (m_pNodeHelper->m_iCurAllStart != -1) {
-      resolveNodeRS.dwFlags = XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll;
-    }
-  }
-  return resolveNodeRS.nodes.GetSize();
-}
-void CXFA_ResolveProcessor::XFA_ResolveNode_SetIndexDataBind(
-    CFX_WideString& wsNextCondition,
-    int32_t& iIndex,
-    int32_t iCount) {
-  if (m_pNodeHelper->XFA_CreateNode_ForCondition(wsNextCondition)) {
-    if (m_pNodeHelper->m_eLastCreateType == XFA_ELEMENT_DataGroup) {
-      iIndex = 0;
-    } else {
-      iIndex = iCount - 1;
-    }
-  } else {
-    iIndex = iCount - 1;
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_resolveprocessor.h b/xfa/src/fxfa/parser/xfa_script_resolveprocessor.h
deleted file mode 100644
index 36e89392da..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_resolveprocessor.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_RESOLVEPROCESSOR_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_RESOLVEPROCESSOR_H_
-
-#include "xfa/include/fxfa/fxfa_objectacc.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-
-class CXFA_NodeHelper;
-class CXFA_ScriptContext;
-
-class CXFA_ResolveNodesData {
- public:
-  CXFA_ResolveNodesData(CXFA_ScriptContext* pSC = NULL)
-      : m_pSC(pSC),
-        m_CurNode(NULL),
-        m_wsName(),
-        m_uHashName(0),
-        m_wsCondition(),
-        m_nLevel(0),
-        m_Nodes(),
-        m_dwStyles(XFA_RESOLVENODE_Children),
-        m_pScriptAttribute(NULL),
-        m_dwFlag(XFA_RESOVENODE_RSTYPE_Nodes) {}
-  ~CXFA_ResolveNodesData() { m_Nodes.RemoveAll(); }
-  CXFA_ScriptContext* m_pSC;
-  CXFA_Object* m_CurNode;
-  CFX_WideString m_wsName;
-  uint32_t m_uHashName;
-  CFX_WideString m_wsCondition;
-  int32_t m_nLevel;
-  CXFA_ObjArray m_Nodes;
-  FX_DWORD m_dwStyles;
-  const XFA_SCRIPTATTRIBUTEINFO* m_pScriptAttribute;
-  XFA_RESOVENODE_RSTYPE m_dwFlag;
-};
-class CXFA_ResolveProcessor {
- public:
-  CXFA_ResolveProcessor(void);
-  ~CXFA_ResolveProcessor(void);
-  int32_t XFA_ResolveNodes(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_AnyChild(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_Dollar(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_Excalmatory(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_NumberSign(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_Asterisk(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_Normal(CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_ForAttributeRs(CXFA_Object* curNode,
-                                          CXFA_ResolveNodesData& rnd,
-                                          const CFX_WideStringC& strAttr);
-  void XFA_ResolveNode_ConditionArray(int32_t iCurIndex,
-                                      CFX_WideString wsCondition,
-                                      int32_t iFoundCount,
-                                      CXFA_ResolveNodesData& rnd);
-  void XFA_ResolveNode_DoPredicateFilter(int32_t iCurIndex,
-                                         CFX_WideString wsCondition,
-                                         int32_t iFoundCount,
-                                         CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNodes_GetFilter(const CFX_WideStringC& wsExpression,
-                                     int32_t nStart,
-                                     CXFA_ResolveNodesData& rnd);
-  void XFA_ResolveNode_FilterCondition(CXFA_ResolveNodesData& rnd,
-                                       CFX_WideString wsCondition);
-  int32_t XFA_ResolveNodes_PopStack(CFX_Int32Array& stack);
-  void XFA_ResolveNodes_SetStylesForChild(FX_DWORD dwParentStyles,
-                                          CXFA_ResolveNodesData& rnd);
-  int32_t XFA_ResolveNode_SetResultCreateNode(XFA_RESOLVENODE_RS& resolveNodeRS,
-                                              CFX_WideString& wsLastCondition);
-  void XFA_ResolveNode_SetIndexDataBind(CFX_WideString& wsNextCondition,
-                                        int32_t& iIndex,
-                                        int32_t iCount);
-  CXFA_NodeHelper* GetNodeHelper() { return m_pNodeHelper; }
-
- private:
-  CXFA_NodeHelper* m_pNodeHelper;
-
- public:
-  int32_t m_iCurStart;
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_RESOLVEPROCESSOR_H_
diff --git a/xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.cpp b/xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.cpp
deleted file mode 100644
index a721338864..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-// 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/src/fxfa/parser/xfa_script_signaturepseudomodel.h"
-
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-CScript_SignaturePseudoModel::CScript_SignaturePseudoModel(
-    CXFA_Document* pDocument)
-    : CXFA_OrdinaryObject(pDocument, XFA_ELEMENT_SignaturePseudoModel) {
-  m_uScriptHash = XFA_HASHCODE_Signature;
-}
-CScript_SignaturePseudoModel::~CScript_SignaturePseudoModel() {}
-void CScript_SignaturePseudoModel::Script_SignaturePseudoModel_Verify(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 4) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"verify");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  CXFA_Node* pNode = NULL;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  int32_t bVerify = pNotify->GetDocProvider()->Verify(hDoc, pNode);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetInteger(hValue, bVerify);
-  }
-}
-void CScript_SignaturePseudoModel::Script_SignaturePseudoModel_Sign(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 3 || iLength > 7) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"sign");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  CXFA_NodeList* pNodeList = NULL;
-  CFX_WideString wsExpression;
-  CFX_WideString wsXMLIdent;
-  if (iLength >= 1) {
-    pNodeList = (CXFA_NodeList*)pArguments->GetObject(0);
-  }
-  if (iLength >= 2) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(1);
-    wsExpression =
-        CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
-  }
-  if (iLength >= 3) {
-    CFX_ByteString bsXMLIdent = pArguments->GetUTF8String(2);
-    wsXMLIdent = CFX_WideString::FromUTF8(bsXMLIdent, bsXMLIdent.GetLength());
-  }
-  FX_BOOL bSign = pNotify->GetDocProvider()->Sign(hDoc, pNodeList, wsExpression,
-                                                  wsXMLIdent);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetBoolean(hValue, bSign);
-  }
-}
-void CScript_SignaturePseudoModel::Script_SignaturePseudoModel_Enumerate(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength != 0) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"enumerate");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  CXFA_NodeList* pList = pNotify->GetDocProvider()->Enumerate(hDoc);
-  if (!pList)
-    return;
-  FXJSE_Value_Set(pArguments->GetReturnValue(),
-                  m_pDocument->GetScriptContext()->GetJSValueFromMap(pList));
-}
-void CScript_SignaturePseudoModel::Script_SignaturePseudoModel_Clear(
-    CFXJSE_Arguments* pArguments) {
-  int32_t iLength = pArguments->GetLength();
-  if (iLength < 1 || iLength > 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clear");
-    return;
-  }
-  IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
-  if (!pNotify) {
-    return;
-  }
-  IXFA_Doc* hDoc = pNotify->GetHDOC();
-  CXFA_Node* pNode = NULL;
-  FX_BOOL bClear = TRUE;
-  if (iLength >= 1) {
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  }
-  if (iLength >= 2) {
-    bClear = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
-  }
-  FX_BOOL bFlag = pNotify->GetDocProvider()->Clear(hDoc, pNode, bClear);
-  FXJSE_HVALUE hValue = pArguments->GetReturnValue();
-  if (hValue) {
-    FXJSE_Value_SetBoolean(hValue, bFlag);
-  }
-}
diff --git a/xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.h b/xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.h
deleted file mode 100644
index f7c64971d0..0000000000
--- a/xfa/src/fxfa/parser/xfa_script_signaturepseudomodel.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_SCRIPT_SIGNATUREPSEUDOMODEL_H_
-#define XFA_SRC_FXFA_PARSER_XFA_SCRIPT_SIGNATUREPSEUDOMODEL_H_
-
-#include "xfa/src/fxfa/parser/xfa_object.h"
-
-class CScript_SignaturePseudoModel : public CXFA_OrdinaryObject {
- public:
-  CScript_SignaturePseudoModel(CXFA_Document* pDocument);
-  ~CScript_SignaturePseudoModel();
-  void Script_SignaturePseudoModel_Verify(CFXJSE_Arguments* pArguments);
-  void Script_SignaturePseudoModel_Sign(CFXJSE_Arguments* pArguments);
-  void Script_SignaturePseudoModel_Enumerate(CFXJSE_Arguments* pArguments);
-  void Script_SignaturePseudoModel_Clear(CFXJSE_Arguments* pArguments);
-};
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_SCRIPT_SIGNATUREPSEUDOMODEL_H_
diff --git a/xfa/src/fxfa/parser/xfa_utils.h b/xfa/src/fxfa/parser/xfa_utils.h
deleted file mode 100644
index 497cb29cc4..0000000000
--- a/xfa/src/fxfa/parser/xfa_utils.h
+++ /dev/null
@@ -1,219 +0,0 @@
-// 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
-
-#ifndef XFA_SRC_FXFA_PARSER_XFA_UTILS_H_
-#define XFA_SRC_FXFA_PARSER_XFA_UTILS_H_
-
-#include "xfa/include/fxfa/fxfa_basic.h"
-#include "xfa/src/fde/xml/fde_xml.h"
-
-class CXFA_LocaleValue;
-
-FX_BOOL XFA_FDEExtension_ResolveNamespaceQualifier(
-    IFDE_XMLElement* pNode,
-    const CFX_WideStringC& wsQualifier,
-    CFX_WideString& wsNamespaceURI);
-template <class NodeType, class TraverseStrategy>
-class CXFA_NodeIteratorTemplate {
- public:
-  CXFA_NodeIteratorTemplate(NodeType* pRootNode = NULL) : m_pRoot(pRootNode) {
-    if (pRootNode) {
-      m_NodeStack.Push(pRootNode);
-    }
-  }
-  FX_BOOL Init(NodeType* pRootNode) {
-    if (!pRootNode) {
-      return FALSE;
-    }
-    m_pRoot = pRootNode;
-    m_NodeStack.RemoveAll();
-    m_NodeStack.Push(pRootNode);
-    return TRUE;
-  }
-  void Clear() { m_NodeStack.RemoveAll(); }
-  void Reset() {
-    Clear();
-    if (m_pRoot) {
-      m_NodeStack.Push(m_pRoot);
-    }
-  }
-  FX_BOOL SetCurrent(NodeType* pCurNode) {
-    m_NodeStack.RemoveAll();
-    if (pCurNode) {
-      CFX_StackTemplate<NodeType*> revStack;
-      NodeType* pNode;
-      for (pNode = pCurNode; pNode && pNode != m_pRoot;
-           pNode = TraverseStrategy::GetParent(pNode)) {
-        revStack.Push(pNode);
-      }
-      if (!pNode) {
-        return FALSE;
-      }
-      revStack.Push(m_pRoot);
-      while (revStack.GetSize()) {
-        m_NodeStack.Push(*revStack.GetTopElement());
-        revStack.Pop();
-      }
-    }
-    return TRUE;
-  }
-  NodeType* GetCurrent() const {
-    return m_NodeStack.GetSize() ? *m_NodeStack.GetTopElement() : NULL;
-  }
-  NodeType* GetRoot() const { return m_pRoot; }
-  NodeType* MoveToPrev() {
-    int32_t nStackLength = m_NodeStack.GetSize();
-    if (nStackLength == 1) {
-      return NULL;
-    } else if (nStackLength > 1) {
-      NodeType* pCurItem = *m_NodeStack.GetTopElement();
-      m_NodeStack.Pop();
-      NodeType* pParentItem = *m_NodeStack.GetTopElement();
-      NodeType* pParentFirstChildItem =
-          TraverseStrategy::GetFirstChild(pParentItem);
-      if (pCurItem == pParentFirstChildItem) {
-        return pParentItem;
-      }
-      NodeType *pPrevItem = pParentFirstChildItem, *pPrevItemNext = NULL;
-      for (; pPrevItem; pPrevItem = pPrevItemNext) {
-        pPrevItemNext = TraverseStrategy::GetNextSibling(pPrevItem);
-        if (!pPrevItemNext || pPrevItemNext == pCurItem) {
-          break;
-        }
-      }
-      m_NodeStack.Push(pPrevItem);
-    } else {
-      m_NodeStack.RemoveAll();
-      if (m_pRoot) {
-        m_NodeStack.Push(m_pRoot);
-      }
-    }
-    if (m_NodeStack.GetSize() > 0) {
-      NodeType* pChildItem = *m_NodeStack.GetTopElement();
-      while ((pChildItem = TraverseStrategy::GetFirstChild(pChildItem)) !=
-             NULL) {
-        while (NodeType* pNextItem =
-                   TraverseStrategy::GetNextSibling(pChildItem)) {
-          pChildItem = pNextItem;
-        }
-        m_NodeStack.Push(pChildItem);
-      }
-      return *m_NodeStack.GetTopElement();
-    }
-    return NULL;
-  }
-  NodeType* MoveToNext() {
-    NodeType** ppNode = NULL;
-    NodeType* pCurrent = GetCurrent();
-    while (m_NodeStack.GetSize() > 0) {
-      while ((ppNode = m_NodeStack.GetTopElement())) {
-        if (pCurrent != *ppNode) {
-          return *ppNode;
-        }
-        NodeType* pChild = TraverseStrategy::GetFirstChild(*ppNode);
-        if (pChild == NULL) {
-          break;
-        }
-        m_NodeStack.Push(pChild);
-      }
-      while ((ppNode = m_NodeStack.GetTopElement())) {
-        NodeType* pNext = TraverseStrategy::GetNextSibling(*ppNode);
-        m_NodeStack.Pop();
-        if (m_NodeStack.GetSize() == 0) {
-          break;
-        }
-        if (pNext) {
-          m_NodeStack.Push(pNext);
-          break;
-        }
-      }
-    }
-    return NULL;
-  }
-  NodeType* SkipChildrenAndMoveToNext() {
-    NodeType** ppNode = NULL;
-    while ((ppNode = m_NodeStack.GetTopElement())) {
-      NodeType* pNext = TraverseStrategy::GetNextSibling(*ppNode);
-      m_NodeStack.Pop();
-      if (m_NodeStack.GetSize() == 0) {
-        break;
-      }
-      if (pNext) {
-        m_NodeStack.Push(pNext);
-        break;
-      }
-    }
-    return GetCurrent();
-  }
-
- protected:
-  NodeType* m_pRoot;
-  CFX_StackTemplate<NodeType*> m_NodeStack;
-};
-template <class KeyType>
-class CXFA_PtrSetTemplate : private CFX_MapPtrToPtr {
- public:
-  CXFA_PtrSetTemplate() : CFX_MapPtrToPtr(10) {}
-
-  int GetCount() const { return CFX_MapPtrToPtr::GetCount(); }
-
-  FX_BOOL IsEmpty() const { return CFX_MapPtrToPtr::IsEmpty(); }
-
-  FX_BOOL Lookup(KeyType key) const {
-    void* pValue = NULL;
-    return CFX_MapPtrToPtr::Lookup((void*)key, pValue);
-  }
-
-  FX_BOOL operator[](KeyType key) { return Lookup(key); }
-
-  void Add(KeyType key) { CFX_MapPtrToPtr::SetAt((void*)key, (void*)key); }
-
-  FX_BOOL RemoveKey(KeyType key) {
-    return CFX_MapPtrToPtr::RemoveKey((void*)key);
-  }
-
-  void RemoveAll() { CFX_MapPtrToPtr::RemoveAll(); }
-
-  FX_POSITION GetStartPosition() const {
-    return CFX_MapPtrToPtr::GetStartPosition();
-  }
-
-  void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey) const {
-    void* pKey = NULL;
-    void* pValue = NULL;
-    CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
-    rKey = (KeyType)(uintptr_t)pKey;
-  }
-};
-class CXFA_Node;
-class CXFA_WidgetData;
-
-CXFA_Node* XFA_CreateUIChild(CXFA_Node* pNode, XFA_ELEMENT& eWidgetType);
-CXFA_LocaleValue XFA_GetLocaleValue(CXFA_WidgetData* pWidgetData);
-CFX_WideString XFA_NumericLimit(const CFX_WideString& wsValue,
-                                int32_t iLead,
-                                int32_t iTread);
-FX_DOUBLE XFA_WideStringToDouble(const CFX_WideString& wsStringVal);
-FX_DOUBLE XFA_ByteStringToDouble(const CFX_ByteStringC& szStringVal);
-int32_t XFA_MapRotation(int32_t nRotation);
-
-FX_BOOL XFA_RecognizeRichText(IFDE_XMLElement* pRichTextXMLNode);
-void XFA_GetPlainTextFromRichText(IFDE_XMLNode* pXMLNode,
-                                  CFX_WideString& wsPlainText);
-FX_BOOL XFA_FieldIsMultiListBox(CXFA_Node* pFieldNode);
-IFX_Stream* XFA_CreateWideTextRead(const CFX_WideString& wsBuffer);
-FX_BOOL XFA_IsLayoutElement(XFA_ELEMENT eElement,
-                            FX_BOOL bLayoutContainer = FALSE);
-FX_BOOL XFA_IsTakingupSpace(XFA_ATTRIBUTEENUM ePresence);
-FX_BOOL XFA_IsFlowingLayout(XFA_ATTRIBUTEENUM eLayout);
-FX_BOOL XFA_IsHorizontalFlow(XFA_ATTRIBUTEENUM eLayout);
-void XFA_DataExporter_DealWithDataGroupNode(CXFA_Node* pDataNode);
-void XFA_DataExporter_RegenerateFormFile(CXFA_Node* pNode,
-                                         IFX_Stream* pStream,
-                                         const FX_CHAR* pChecksum = NULL,
-                                         FX_BOOL bSaveXML = FALSE);
-
-#endif  // XFA_SRC_FXFA_PARSER_XFA_UTILS_H_
diff --git a/xfa/src/fxfa/parser/xfa_utils_imp.cpp b/xfa/src/fxfa/parser/xfa_utils_imp.cpp
deleted file mode 100644
index 32f5ce125f..0000000000
--- a/xfa/src/fxfa/parser/xfa_utils_imp.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-// 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/src/fxfa/parser/xfa_utils.h"
-
-#include "core/include/fxcrt/fx_ext.h"
-#include "xfa/src/fxfa/fm2js/xfa_fm2jsapi.h"
-#include "xfa/src/fxfa/parser/xfa_docdata.h"
-#include "xfa/src/fxfa/parser/xfa_doclayout.h"
-#include "xfa/src/fxfa/parser/xfa_document.h"
-#include "xfa/src/fxfa/parser/xfa_localemgr.h"
-#include "xfa/src/fxfa/parser/xfa_localevalue.h"
-#include "xfa/src/fxfa/parser/xfa_object.h"
-#include "xfa/src/fxfa/parser/xfa_parser.h"
-#include "xfa/src/fxfa/parser/xfa_script.h"
-
-CXFA_Node* XFA_CreateUIChild(CXFA_Node* pNode, XFA_ELEMENT& eWidgetType) {
-  XFA_ELEMENT eType = pNode->GetClassID();
-  eWidgetType = eType;
-  if (eType != XFA_ELEMENT_Field && eType != XFA_ELEMENT_Draw) {
-    return NULL;
-  }
-  eWidgetType = XFA_ELEMENT_UNKNOWN;
-  XFA_ELEMENT eUIType = XFA_ELEMENT_UNKNOWN;
-  CXFA_Value defValue(pNode->GetProperty(0, XFA_ELEMENT_Value, TRUE));
-  XFA_ELEMENT eValueType = (XFA_ELEMENT)defValue.GetChildValueClassID();
-  switch (eValueType) {
-    case XFA_ELEMENT_Boolean:
-      eUIType = XFA_ELEMENT_CheckButton;
-      break;
-    case XFA_ELEMENT_Integer:
-    case XFA_ELEMENT_Decimal:
-    case XFA_ELEMENT_Float:
-      eUIType = XFA_ELEMENT_NumericEdit;
-      break;
-    case XFA_ELEMENT_ExData:
-    case XFA_ELEMENT_Text:
-      eUIType = XFA_ELEMENT_TextEdit;
-      eWidgetType = XFA_ELEMENT_Text;
-      break;
-    case XFA_ELEMENT_Date:
-    case XFA_ELEMENT_Time:
-    case XFA_ELEMENT_DateTime:
-      eUIType = XFA_ELEMENT_DateTimeEdit;
-      break;
-    case XFA_ELEMENT_Image:
-      eUIType = XFA_ELEMENT_ImageEdit;
-      eWidgetType = XFA_ELEMENT_Image;
-      break;
-    case XFA_ELEMENT_Arc:
-    case XFA_ELEMENT_Line:
-    case XFA_ELEMENT_Rectangle:
-      eUIType = XFA_ELEMENT_DefaultUi;
-      eWidgetType = eValueType;
-      break;
-    default:
-      break;
-  }
-  CXFA_Node* pUIChild = NULL;
-  CXFA_Node* pUI = pNode->GetProperty(0, XFA_ELEMENT_Ui, TRUE);
-  CXFA_Node* pChild = pUI->GetNodeItem(XFA_NODEITEM_FirstChild);
-  for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_ELEMENT eChild = pChild->GetClassID();
-    if (eChild == XFA_ELEMENT_Extras || eChild == XFA_ELEMENT_Picture) {
-      continue;
-    }
-    const XFA_PROPERTY* pProperty =
-        XFA_GetPropertyOfElement(XFA_ELEMENT_Ui, eChild, XFA_XDPPACKET_Form);
-    if (pProperty && (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
-      pUIChild = pChild;
-      break;
-    }
-  }
-  if (eType == XFA_ELEMENT_Draw) {
-    XFA_ELEMENT eDraw = pUIChild ? pUIChild->GetClassID() : XFA_ELEMENT_UNKNOWN;
-    switch (eDraw) {
-      case XFA_ELEMENT_TextEdit:
-        eWidgetType = XFA_ELEMENT_Text;
-        break;
-      case XFA_ELEMENT_ImageEdit:
-        eWidgetType = XFA_ELEMENT_Image;
-        break;
-      default:
-        eWidgetType =
-            eWidgetType == XFA_ELEMENT_UNKNOWN ? XFA_ELEMENT_Text : eWidgetType;
-        break;
-    }
-  } else {
-    if (pUIChild && pUIChild->GetClassID() == XFA_ELEMENT_DefaultUi) {
-      eWidgetType = XFA_ELEMENT_TextEdit;
-    } else {
-      eWidgetType = pUIChild
-                        ? pUIChild->GetClassID()
-                        : (eUIType == XFA_ELEMENT_UNKNOWN ? XFA_ELEMENT_TextEdit
-                                                          : eUIType);
-    }
-  }
-  if (!pUIChild) {
-    if (eUIType == XFA_ELEMENT_UNKNOWN) {
-      eUIType = XFA_ELEMENT_TextEdit;
-      defValue.GetNode()->GetProperty(0, XFA_ELEMENT_Text, TRUE);
-    }
-    pUIChild = pUI->GetProperty(0, eUIType, TRUE);
-  } else if (eUIType == XFA_ELEMENT_UNKNOWN) {
-    switch (pUIChild->GetClassID()) {
-      case XFA_ELEMENT_CheckButton: {
-        eValueType = XFA_ELEMENT_Text;
-        if (CXFA_Node* pItems = pNode->GetChild(0, XFA_ELEMENT_Items)) {
-          if (CXFA_Node* pItem = pItems->GetChild(0, XFA_ELEMENT_UNKNOWN)) {
-            eValueType = pItem->GetClassID();
-          }
-        }
-      } break;
-      case XFA_ELEMENT_DateTimeEdit:
-        eValueType = XFA_ELEMENT_DateTime;
-        break;
-      case XFA_ELEMENT_ImageEdit:
-        eValueType = XFA_ELEMENT_Image;
-        break;
-      case XFA_ELEMENT_NumericEdit:
-        eValueType = XFA_ELEMENT_Float;
-        break;
-      case XFA_ELEMENT_ChoiceList: {
-        eValueType = (pUIChild->GetEnum(XFA_ATTRIBUTE_Open) ==
-                      XFA_ATTRIBUTEENUM_MultiSelect)
-                         ? XFA_ELEMENT_ExData
-                         : XFA_ELEMENT_Text;
-      } break;
-      case XFA_ELEMENT_Barcode:
-      case XFA_ELEMENT_Button:
-      case XFA_ELEMENT_PasswordEdit:
-      case XFA_ELEMENT_Signature:
-      case XFA_ELEMENT_TextEdit:
-      default:
-        eValueType = XFA_ELEMENT_Text;
-        break;
-    }
-    defValue.GetNode()->GetProperty(0, eValueType, TRUE);
-  }
-  return pUIChild;
-}
-CXFA_LocaleValue XFA_GetLocaleValue(CXFA_WidgetData* pWidgetData) {
-  CXFA_Node* pNodeValue =
-      pWidgetData->GetNode()->GetChild(0, XFA_ELEMENT_Value);
-  if (!pNodeValue) {
-    return CXFA_LocaleValue();
-  }
-  CXFA_Node* pValueChild = pNodeValue->GetNodeItem(XFA_NODEITEM_FirstChild);
-  if (!pValueChild) {
-    return CXFA_LocaleValue();
-  }
-  int32_t iVTType = XFA_VT_NULL;
-  XFA_ELEMENT eType = pValueChild->GetClassID();
-  switch (eType) {
-    case XFA_ELEMENT_Decimal:
-      iVTType = XFA_VT_DECIMAL;
-      break;
-    case XFA_ELEMENT_Float:
-      iVTType = XFA_VT_FLOAT;
-      break;
-    case XFA_ELEMENT_Date:
-      iVTType = XFA_VT_DATE;
-      break;
-    case XFA_ELEMENT_Time:
-      iVTType = XFA_VT_TIME;
-      break;
-    case XFA_ELEMENT_DateTime:
-      iVTType = XFA_VT_DATETIME;
-      break;
-    case XFA_ELEMENT_Boolean:
-      iVTType = XFA_VT_BOOLEAN;
-      break;
-    case XFA_ELEMENT_Integer:
-      iVTType = XFA_VT_INTEGER;
-      break;
-    case XFA_ELEMENT_Text:
-      iVTType = XFA_VT_TEXT;
-      break;
-    default:
-      iVTType = XFA_VT_NULL;
-      break;
-  }
-  return CXFA_LocaleValue(iVTType, pWidgetData->GetRawValue(),
-                          pWidgetData->GetNode()->GetDocument()->GetLocalMgr());
-}
-void XFA_GetPlainTextFromRichText(IFDE_XMLNode* pXMLNode,
-                                  CFX_WideString& wsPlainText) {
-  if (pXMLNode == NULL) {
-    return;
-  }
-  switch (pXMLNode->GetType()) {
-    case FDE_XMLNODE_Element: {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
-      CFX_WideString wsTag;
-      pXMLElement->GetLocalTagName(wsTag);
-      uint32_t uTag = FX_HashCode_String_GetW(wsTag, wsTag.GetLength(), TRUE);
-      if (uTag == 0x0001f714) {
-        wsPlainText += L"\n";
-      } else if (uTag == 0x00000070) {
-        if (!wsPlainText.IsEmpty()) {
-          wsPlainText += L"\n";
-        }
-      } else if (uTag == 0xa48ac63) {
-        if (!wsPlainText.IsEmpty() &&
-            wsPlainText[wsPlainText.GetLength() - 1] != '\n') {
-          wsPlainText += L"\n";
-        }
-      }
-    } break;
-    case FDE_XMLNODE_Text: {
-      CFX_WideString wsContent;
-      ((IFDE_XMLText*)pXMLNode)->GetText(wsContent);
-      wsPlainText += wsContent;
-    } break;
-    case FDE_XMLNODE_CharData: {
-      CFX_WideString wsCharData;
-      ((IFDE_XMLCharData*)pXMLNode)->GetCharData(wsCharData);
-      wsPlainText += wsCharData;
-    } break;
-    default:
-      break;
-  }
-  for (IFDE_XMLNode* pChildXML =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pChildXML;
-       pChildXML = pChildXML->GetNodeItem(IFDE_XMLNode::NextSibling)) {
-    XFA_GetPlainTextFromRichText(pChildXML, wsPlainText);
-  }
-}
-FX_BOOL XFA_FieldIsMultiListBox(CXFA_Node* pFieldNode) {
-  FX_BOOL bRet = FALSE;
-  if (!pFieldNode) {
-    return bRet;
-  }
-  CXFA_Node* pUIChild = pFieldNode->GetChild(0, XFA_ELEMENT_Ui);
-  if (pUIChild) {
-    CXFA_Node* pFirstChild = pUIChild->GetNodeItem(XFA_NODEITEM_FirstChild);
-    if (pFirstChild && pFirstChild->GetClassID() == XFA_ELEMENT_ChoiceList) {
-      bRet = pFirstChild->GetEnum(XFA_ATTRIBUTE_Open) ==
-             XFA_ATTRIBUTEENUM_MultiSelect;
-    }
-  }
-  return bRet;
-}
-FX_BOOL XFA_IsLayoutElement(XFA_ELEMENT eElement, FX_BOOL bLayoutContainer) {
-  switch (eElement) {
-    case XFA_ELEMENT_Draw:
-    case XFA_ELEMENT_Field:
-    case XFA_ELEMENT_InstanceManager:
-      return !bLayoutContainer;
-    case XFA_ELEMENT_Area:
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_ExclGroup:
-    case XFA_ELEMENT_SubformSet:
-      return TRUE;
-    case XFA_ELEMENT_PageArea:
-    case XFA_ELEMENT_Form:
-      return TRUE;
-    default:
-      return FALSE;
-  }
-  return FALSE;
-}
-FX_BOOL XFA_IsTakingupSpace(XFA_ATTRIBUTEENUM ePresence) {
-  switch (ePresence) {
-    case XFA_ATTRIBUTEENUM_Visible:
-    case XFA_ATTRIBUTEENUM_Invisible:
-      return TRUE;
-    default:
-      return FALSE;
-  }
-  return FALSE;
-}
-FX_BOOL XFA_IsFlowingLayout(XFA_ATTRIBUTEENUM eLayout) {
-  switch (eLayout) {
-    case XFA_ATTRIBUTEENUM_Tb:
-    case XFA_ATTRIBUTEENUM_Lr_tb:
-    case XFA_ATTRIBUTEENUM_Rl_tb:
-      return TRUE;
-    default:
-      return FALSE;
-  }
-  return FALSE;
-}
-FX_BOOL XFA_IsHorizontalFlow(XFA_ATTRIBUTEENUM eLayout) {
-  switch (eLayout) {
-    case XFA_ATTRIBUTEENUM_Lr_tb:
-    case XFA_ATTRIBUTEENUM_Rl_tb:
-      return TRUE;
-    default:
-      return FALSE;
-  }
-  return FALSE;
-}
-static const FX_DOUBLE fraction_scales[] = {0.1,
-                                            0.01,
-                                            0.001,
-                                            0.0001,
-                                            0.00001,
-                                            0.000001,
-                                            0.0000001,
-                                            0.00000001,
-                                            0.000000001,
-                                            0.0000000001,
-                                            0.00000000001,
-                                            0.000000000001,
-                                            0.0000000000001,
-                                            0.00000000000001,
-                                            0.000000000000001,
-                                            0.0000000000000001};
-FX_DOUBLE XFA_WideStringToDouble(const CFX_WideString& wsStringVal) {
-  CFX_WideString wsValue = wsStringVal;
-  wsValue.TrimLeft();
-  wsValue.TrimRight();
-  int64_t nIntegral = 0;
-  FX_DWORD dwFractional = 0;
-  int32_t nExponent = 0;
-  int32_t cc = 0;
-  FX_BOOL bNegative = FALSE, bExpSign = FALSE;
-  const FX_WCHAR* str = (const FX_WCHAR*)wsValue;
-  int32_t len = wsValue.GetLength();
-  if (str[0] == '+') {
-    cc++;
-  } else if (str[0] == '-') {
-    bNegative = TRUE;
-    cc++;
-  }
-  int32_t nIntegralLen = 0;
-  while (cc < len) {
-    if (str[cc] == '.' || str[cc] == 'E' || str[cc] == 'e' ||
-        nIntegralLen > 17) {
-      break;
-    }
-    if (!XFA_IsDigit(str[cc])) {
-      return 0;
-    }
-    nIntegral = nIntegral * 10 + str[cc] - '0';
-    cc++;
-    nIntegralLen++;
-  }
-  nIntegral = bNegative ? -nIntegral : nIntegral;
-  int32_t scale = 0;
-  FX_DOUBLE fraction = 0.0;
-  if (cc < len && str[cc] == '.') {
-    cc++;
-    while (cc < len) {
-      fraction += fraction_scales[scale] * (str[cc] - '0');
-      scale++;
-      cc++;
-      if (cc == len) {
-        break;
-      }
-      if (scale == sizeof(fraction_scales) / sizeof(FX_DOUBLE) ||
-          str[cc] == 'E' || str[cc] == 'e') {
-        break;
-      }
-      if (!XFA_IsDigit(str[cc])) {
-        return 0;
-      }
-    }
-    dwFractional = (FX_DWORD)(fraction * 4294967296.0);
-  }
-  if (cc < len && (str[cc] == 'E' || str[cc] == 'e')) {
-    cc++;
-    if (cc < len) {
-      if (str[cc] == '+') {
-        cc++;
-      } else if (str[cc] == '-') {
-        bExpSign = TRUE;
-        cc++;
-      }
-    }
-    while (cc < len) {
-      if (str[cc] == '.' || !XFA_IsDigit(str[cc])) {
-        return 0;
-      }
-      nExponent = nExponent * 10 + str[cc] - '0';
-      cc++;
-    }
-    nExponent = bExpSign ? -nExponent : nExponent;
-  }
-  FX_DOUBLE dValue = (dwFractional / 4294967296.0);
-  dValue = nIntegral + (nIntegral >= 0 ? dValue : -dValue);
-  if (nExponent != 0) {
-    dValue *= FXSYS_pow(10, (FX_FLOAT)nExponent);
-  }
-  return dValue;
-}
-
-FX_DOUBLE XFA_ByteStringToDouble(const CFX_ByteStringC& szStringVal) {
-  CFX_WideString wsValue =
-      CFX_WideString::FromUTF8(szStringVal.GetCStr(), szStringVal.GetLength());
-  return XFA_WideStringToDouble(wsValue);
-}
-
-int32_t XFA_MapRotation(int32_t nRotation) {
-  nRotation = nRotation % 360;
-  nRotation = nRotation < 0 ? nRotation + 360 : nRotation;
-  return nRotation;
-}
diff --git a/xfa/src/fxfa/parser/xfa_utils_imp_unittest.cpp b/xfa/src/fxfa/parser/xfa_utils_imp_unittest.cpp
deleted file mode 100644
index d5f0e4a923..0000000000
--- a/xfa/src/fxfa/parser/xfa_utils_imp_unittest.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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.
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "xfa/src/fxfa/parser/xfa_utils.h"
-
-TEST(XfaUtilsImp, XFA_MapRotation) {
-  struct TestCase {
-    int input;
-    int expected_output;
-  } TestCases[] = {{-1000000, 80}, {-361, 359}, {-360, 0},  {-359, 1},
-                   {-91, 269},     {-90, 270},  {-89, 271}, {-1, 359},
-                   {0, 0},         {1, 1},      {89, 89},   {90, 90},
-                   {91, 91},       {359, 359},  {360, 0},   {361, 1},
-                   {100000, 280}};
-
-  for (size_t i = 0; i < FX_ArraySize(TestCases); ++i) {
-    EXPECT_EQ(TestCases[i].expected_output,
-              XFA_MapRotation(TestCases[i].input));
-  }
-}