diff options
Diffstat (limited to 'xfa/src/fxfa/parser/xfa_objectacc_imp.cpp')
| -rw-r--r-- | xfa/src/fxfa/parser/xfa_objectacc_imp.cpp | 3760 |
1 files changed, 3760 insertions, 0 deletions
diff --git a/xfa/src/fxfa/parser/xfa_objectacc_imp.cpp b/xfa/src/fxfa/parser/xfa_objectacc_imp.cpp new file mode 100644 index 0000000000..9515237683 --- /dev/null +++ b/xfa/src/fxfa/parser/xfa_objectacc_imp.cpp @@ -0,0 +1,3760 @@ +// 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; +} |