summaryrefslogtreecommitdiff
path: root/xfa/fxfa/parser/cxfa_widgetdata.cpp
diff options
context:
space:
mode:
authordsinclair <dsinclair@chromium.org>2016-04-06 10:23:46 -0700
committerCommit bot <commit-bot@chromium.org>2016-04-06 10:23:46 -0700
commit44d054c6449edb63d9760ac6602b036ffec75a84 (patch)
tree846b0da4fb6d90fad87b97a3c938fe94f7c9243d /xfa/fxfa/parser/cxfa_widgetdata.cpp
parent48baa5f230a886b0579a9626711e7d71376b085e (diff)
downloadpdfium-44d054c6449edb63d9760ac6602b036ffec75a84.tar.xz
Split fxfa_objectacc.h into pieces.
This Cl splits apart the fxfa_objectacc.h file and moves the individual classes into the xfa/fxfa/parser directory. Review URL: https://codereview.chromium.org/1861353002
Diffstat (limited to 'xfa/fxfa/parser/cxfa_widgetdata.cpp')
-rw-r--r--xfa/fxfa/parser/cxfa_widgetdata.cpp1797
1 files changed, 1797 insertions, 0 deletions
diff --git a/xfa/fxfa/parser/cxfa_widgetdata.cpp b/xfa/fxfa/parser/cxfa_widgetdata.cpp
new file mode 100644
index 0000000000..af714fdd7a
--- /dev/null
+++ b/xfa/fxfa/parser/cxfa_widgetdata.cpp
@@ -0,0 +1,1797 @@
+// 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
+
+#include "xfa/fxfa/parser/cxfa_widgetdata.h"
+
+#include "xfa/fxfa/parser/xfa_object.h"
+#include "xfa/fxfa/parser/cxfa_event.h"
+#include "xfa/fxfa/parser/xfa_document.h"
+#include "core/fxcrt/include/fx_ext.h"
+#include "xfa/fxfa/app/xfa_ffnotify.h"
+#include "xfa/fxbarcode/include/BC_Library.h"
+#include "xfa/fxfa/parser/xfa_localevalue.h"
+
+namespace {
+
+FX_FLOAT 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;
+}
+
+FX_BOOL 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;
+}
+
+} // namespace
+
+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;
+}
+
+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));
+}
+
+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_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));
+}
+
+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_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 = GetEdgeThickness(strokes, bVisible, 0);
+ if (!bRight)
+ fRightInset = GetEdgeThickness(strokes, bVisible, 1);
+ if (!bBottom)
+ fBottomInset = GetEdgeThickness(strokes, bVisible, 2);
+ if (!bLeft)
+ fLeftInset = 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;
+ uint32_t nameHash =
+ FX_HashCode_String_GetW(wsName.c_str(), 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.AsWideStringC(), 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.AsWideStringC(), 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.AsWideStringC(), nIndex);
+ CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
+ m_pNode->InsertChild(-1, pSaveItems);
+ pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
+ InsertListTextItem(pSaveItems, wsNewValue.AsWideStringC(), 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.AsWideStringC(), nIndex);
+ else
+ InsertListTextItem(pNode, wsLabel.AsWideStringC(), 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.AsWideStringC(), i);
+ i++;
+ pListNode = pListNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+ }
+ InsertListTextItem(pNode, wsLabel.AsWideStringC(), nIndex);
+ InsertListTextItem(pSaveItems, wsNewValue.AsWideStringC(), 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;
+}
+
+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::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;
+}
+
+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 = 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 = 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;
+
+ uint32_t 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;
+ }
+ uint32_t 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 == FX_WSTRC(L"ambient")) {
+ pLocale = m_pNode->GetDocument()->GetLocalMgr()->GetDefLocale();
+ } else {
+ pLocale = m_pNode->GetDocument()->GetLocalMgr()->GetLocaleByName(
+ wsLocaleName.AsWideStringC());
+ }
+ }
+ return pLocale;
+}
+
+FX_BOOL CXFA_WidgetData::GetValue(CFX_WideString& wsValue,
+ XFA_VALUEPICTURE eValueType) {
+ wsValue = m_pNode->GetContent();
+
+ if (eValueType == XFA_VALUEPICTURE_Display)
+ GetItemLabel(wsValue.AsWideStringC(), 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 (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 (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 (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 (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.AsWideStringC(),
+ 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);
+}
+
+CFX_WideString CXFA_WidgetData::NumericLimit(const CFX_WideString& wsValue,
+ int32_t iLead,
+ int32_t iTread) const {
+ 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.AsWideStringC());
+ wsDeci.SetScale(iTread);
+ wsRet = wsDeci;
+ }
+ return wsRet;
+ }
+ }
+ } else if (wc == L'.') {
+ iTread_ = 0;
+ iLead = -1;
+ }
+ wsRet += wc;
+ }
+ return wsRet;
+}