summaryrefslogtreecommitdiff
path: root/xfa/fxfa/parser/xfa_utils.cpp
diff options
context:
space:
mode:
authordsinclair <dsinclair@chromium.org>2016-07-21 12:09:45 -0700
committerCommit bot <commit-bot@chromium.org>2016-07-21 12:09:45 -0700
commit39fdfc35fa32d7dc2e4aa8d2f0cb0a153037ce8d (patch)
tree687cf14119e313186514036c7f24824060210dcb /xfa/fxfa/parser/xfa_utils.cpp
parent3a7cc7382305e2d1f2793d9fea923f2428a87e64 (diff)
downloadpdfium-39fdfc35fa32d7dc2e4aa8d2f0cb0a153037ce8d.tar.xz
Rename xfa_utils_imp to xfa_utils
This makes the cpp and unittest files match the naming of the header file. Review-Url: https://codereview.chromium.org/2165833005
Diffstat (limited to 'xfa/fxfa/parser/xfa_utils.cpp')
-rw-r--r--xfa/fxfa/parser/xfa_utils.cpp486
1 files changed, 486 insertions, 0 deletions
diff --git a/xfa/fxfa/parser/xfa_utils.cpp b/xfa/fxfa/parser/xfa_utils.cpp
new file mode 100644
index 0000000000..da5b68516b
--- /dev/null
+++ b/xfa/fxfa/parser/xfa_utils.cpp
@@ -0,0 +1,486 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "xfa/fxfa/parser/xfa_utils.h"
+
+#include "core/fxcrt/include/fx_ext.h"
+#include "xfa/fde/xml/fde_xml_imp.h"
+#include "xfa/fxfa/parser/cxfa_document.h"
+#include "xfa/fxfa/parser/cxfa_measurement.h"
+#include "xfa/fxfa/parser/xfa_basic_data.h"
+#include "xfa/fxfa/parser/xfa_localemgr.h"
+#include "xfa/fxfa/parser/xfa_localevalue.h"
+#include "xfa/fxfa/parser/xfa_object.h"
+
+namespace {
+
+const FX_DOUBLE fraction_scales[] = {0.1,
+ 0.01,
+ 0.001,
+ 0.0001,
+ 0.00001,
+ 0.000001,
+ 0.0000001,
+ 0.00000001,
+ 0.000000001,
+ 0.0000000001,
+ 0.00000000001,
+ 0.000000000001,
+ 0.0000000000001,
+ 0.00000000000001,
+ 0.000000000000001,
+ 0.0000000000000001};
+
+FX_DOUBLE WideStringToDouble(const CFX_WideString& wsStringVal) {
+ CFX_WideString wsValue = wsStringVal;
+ wsValue.TrimLeft();
+ wsValue.TrimRight();
+ int64_t nIntegral = 0;
+ uint32_t dwFractional = 0;
+ int32_t nExponent = 0;
+ int32_t cc = 0;
+ bool bNegative = false;
+ bool bExpSign = false;
+ const FX_WCHAR* str = wsValue.c_str();
+ int32_t len = wsValue.GetLength();
+ if (str[0] == '+') {
+ cc++;
+ } else if (str[0] == '-') {
+ bNegative = true;
+ cc++;
+ }
+ int32_t nIntegralLen = 0;
+ while (cc < len) {
+ if (str[cc] == '.' || str[cc] == 'E' || str[cc] == 'e' ||
+ nIntegralLen > 17) {
+ break;
+ }
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return 0;
+ }
+ nIntegral = nIntegral * 10 + str[cc] - '0';
+ cc++;
+ nIntegralLen++;
+ }
+ nIntegral = bNegative ? -nIntegral : nIntegral;
+ int32_t scale = 0;
+ FX_DOUBLE fraction = 0.0;
+ if (cc < len && str[cc] == '.') {
+ cc++;
+ while (cc < len) {
+ fraction += fraction_scales[scale] * (str[cc] - '0');
+ scale++;
+ cc++;
+ if (cc == len) {
+ break;
+ }
+ if (scale == sizeof(fraction_scales) / sizeof(FX_DOUBLE) ||
+ str[cc] == 'E' || str[cc] == 'e') {
+ break;
+ }
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return 0;
+ }
+ }
+ dwFractional = (uint32_t)(fraction * 4294967296.0);
+ }
+ if (cc < len && (str[cc] == 'E' || str[cc] == 'e')) {
+ cc++;
+ if (cc < len) {
+ if (str[cc] == '+') {
+ cc++;
+ } else if (str[cc] == '-') {
+ bExpSign = true;
+ cc++;
+ }
+ }
+ while (cc < len) {
+ if (str[cc] == '.' || !FXSYS_isDecimalDigit(str[cc])) {
+ return 0;
+ }
+ nExponent = nExponent * 10 + str[cc] - '0';
+ cc++;
+ }
+ nExponent = bExpSign ? -nExponent : nExponent;
+ }
+ FX_DOUBLE dValue = (dwFractional / 4294967296.0);
+ dValue = nIntegral + (nIntegral >= 0 ? dValue : -dValue);
+ if (nExponent != 0) {
+ dValue *= FXSYS_pow(10, (FX_FLOAT)nExponent);
+ }
+ return dValue;
+}
+
+} // namespace
+
+CXFA_LocaleValue XFA_GetLocaleValue(CXFA_WidgetData* pWidgetData) {
+ CXFA_Node* pNodeValue =
+ pWidgetData->GetNode()->GetChild(0, XFA_Element::Value);
+ if (!pNodeValue) {
+ return CXFA_LocaleValue();
+ }
+ CXFA_Node* pValueChild = pNodeValue->GetNodeItem(XFA_NODEITEM_FirstChild);
+ if (!pValueChild) {
+ return CXFA_LocaleValue();
+ }
+ int32_t iVTType = XFA_VT_NULL;
+ switch (pValueChild->GetElementType()) {
+ case XFA_Element::Decimal:
+ iVTType = XFA_VT_DECIMAL;
+ break;
+ case XFA_Element::Float:
+ iVTType = XFA_VT_FLOAT;
+ break;
+ case XFA_Element::Date:
+ iVTType = XFA_VT_DATE;
+ break;
+ case XFA_Element::Time:
+ iVTType = XFA_VT_TIME;
+ break;
+ case XFA_Element::DateTime:
+ iVTType = XFA_VT_DATETIME;
+ break;
+ case XFA_Element::Boolean:
+ iVTType = XFA_VT_BOOLEAN;
+ break;
+ case XFA_Element::Integer:
+ iVTType = XFA_VT_INTEGER;
+ break;
+ case XFA_Element::Text:
+ iVTType = XFA_VT_TEXT;
+ break;
+ default:
+ iVTType = XFA_VT_NULL;
+ break;
+ }
+ return CXFA_LocaleValue(iVTType, pWidgetData->GetRawValue(),
+ pWidgetData->GetNode()->GetDocument()->GetLocalMgr());
+}
+void XFA_GetPlainTextFromRichText(CFDE_XMLNode* pXMLNode,
+ CFX_WideString& wsPlainText) {
+ if (!pXMLNode) {
+ return;
+ }
+ switch (pXMLNode->GetType()) {
+ case FDE_XMLNODE_Element: {
+ CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
+ CFX_WideString wsTag;
+ pXMLElement->GetLocalTagName(wsTag);
+ uint32_t uTag = FX_HashCode_GetW(wsTag.AsStringC(), true);
+ if (uTag == 0x0001f714) {
+ wsPlainText += L"\n";
+ } else if (uTag == 0x00000070) {
+ if (!wsPlainText.IsEmpty()) {
+ wsPlainText += L"\n";
+ }
+ } else if (uTag == 0xa48ac63) {
+ if (!wsPlainText.IsEmpty() &&
+ wsPlainText[wsPlainText.GetLength() - 1] != '\n') {
+ wsPlainText += L"\n";
+ }
+ }
+ } break;
+ case FDE_XMLNODE_Text: {
+ CFX_WideString wsContent;
+ static_cast<CFDE_XMLText*>(pXMLNode)->GetText(wsContent);
+ wsPlainText += wsContent;
+ } break;
+ case FDE_XMLNODE_CharData: {
+ CFX_WideString wsCharData;
+ static_cast<CFDE_XMLCharData*>(pXMLNode)->GetCharData(wsCharData);
+ wsPlainText += wsCharData;
+ } break;
+ default:
+ break;
+ }
+ for (CFDE_XMLNode* pChildXML =
+ pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
+ pChildXML;
+ pChildXML = pChildXML->GetNodeItem(CFDE_XMLNode::NextSibling)) {
+ XFA_GetPlainTextFromRichText(pChildXML, wsPlainText);
+ }
+}
+
+FX_BOOL XFA_FieldIsMultiListBox(CXFA_Node* pFieldNode) {
+ FX_BOOL bRet = FALSE;
+ if (!pFieldNode)
+ return bRet;
+
+ CXFA_Node* pUIChild = pFieldNode->GetChild(0, XFA_Element::Ui);
+ if (pUIChild) {
+ CXFA_Node* pFirstChild = pUIChild->GetNodeItem(XFA_NODEITEM_FirstChild);
+ if (pFirstChild &&
+ pFirstChild->GetElementType() == XFA_Element::ChoiceList) {
+ bRet = pFirstChild->GetEnum(XFA_ATTRIBUTE_Open) ==
+ XFA_ATTRIBUTEENUM_MultiSelect;
+ }
+ }
+ return bRet;
+}
+
+FX_DOUBLE XFA_ByteStringToDouble(const CFX_ByteStringC& szStringVal) {
+ CFX_WideString wsValue = CFX_WideString::FromUTF8(szStringVal);
+ return WideStringToDouble(wsValue);
+}
+
+int32_t XFA_MapRotation(int32_t nRotation) {
+ nRotation = nRotation % 360;
+ nRotation = nRotation < 0 ? nRotation + 360 : nRotation;
+ return nRotation;
+}
+
+const XFA_SCRIPTATTRIBUTEINFO* XFA_GetScriptAttributeByName(
+ XFA_Element eElement,
+ const CFX_WideStringC& wsAttributeName) {
+ if (wsAttributeName.IsEmpty())
+ return nullptr;
+
+ int32_t iElementIndex = static_cast<int32_t>(eElement);
+ while (iElementIndex != -1) {
+ const XFA_SCRIPTHIERARCHY* scriptIndex = g_XFAScriptIndex + iElementIndex;
+ int32_t icount = scriptIndex->wAttributeCount;
+ if (icount == 0) {
+ iElementIndex = scriptIndex->wParentIndex;
+ continue;
+ }
+ uint32_t uHash = FX_HashCode_GetW(wsAttributeName, false);
+ int32_t iStart = scriptIndex->wAttributeStart, iEnd = iStart + icount - 1;
+ do {
+ int32_t iMid = (iStart + iEnd) / 2;
+ const XFA_SCRIPTATTRIBUTEINFO* pInfo = g_SomAttributeData + iMid;
+ if (uHash == pInfo->uHash)
+ return pInfo;
+ if (uHash < pInfo->uHash)
+ iEnd = iMid - 1;
+ else
+ iStart = iMid + 1;
+ } while (iStart <= iEnd);
+ iElementIndex = scriptIndex->wParentIndex;
+ }
+ return nullptr;
+}
+
+const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(XFA_Element eElement,
+ XFA_ATTRIBUTE eAttribute,
+ XFA_ATTRIBUTETYPE eType) {
+ int32_t iStart = 0, iEnd = g_iXFANotsureCount - 1;
+ do {
+ int32_t iMid = (iStart + iEnd) / 2;
+ const XFA_NOTSUREATTRIBUTE* pAttr = g_XFANotsureAttributes + iMid;
+ if (eElement == pAttr->eElement) {
+ if (pAttr->eAttribute == eAttribute) {
+ if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType)
+ return pAttr;
+ return nullptr;
+ }
+ int32_t iBefore = iMid - 1;
+ if (iBefore >= 0) {
+ pAttr = g_XFANotsureAttributes + iBefore;
+ while (eElement == pAttr->eElement) {
+ if (pAttr->eAttribute == eAttribute) {
+ if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType)
+ return pAttr;
+ return nullptr;
+ }
+ iBefore--;
+ if (iBefore < 0)
+ break;
+
+ pAttr = g_XFANotsureAttributes + iBefore;
+ }
+ }
+
+ int32_t iAfter = iMid + 1;
+ if (iAfter <= g_iXFANotsureCount - 1) {
+ pAttr = g_XFANotsureAttributes + iAfter;
+ while (eElement == pAttr->eElement) {
+ if (pAttr->eAttribute == eAttribute) {
+ if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType)
+ return pAttr;
+ return nullptr;
+ }
+ iAfter++;
+ if (iAfter > g_iXFANotsureCount - 1)
+ break;
+
+ pAttr = g_XFANotsureAttributes + iAfter;
+ }
+ }
+ return nullptr;
+ }
+
+ if (eElement < pAttr->eElement)
+ iEnd = iMid - 1;
+ else
+ iStart = iMid + 1;
+ } while (iStart <= iEnd);
+ return nullptr;
+}
+
+const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_Element eElement,
+ XFA_Element eProperty,
+ uint32_t dwPacket) {
+ int32_t iCount = 0;
+ const XFA_PROPERTY* pProperties = XFA_GetElementProperties(eElement, iCount);
+ if (!pProperties || iCount < 1)
+ return nullptr;
+
+ auto it = std::find_if(pProperties, pProperties + iCount,
+ [eProperty](const XFA_PROPERTY& prop) {
+ return prop.eName == eProperty;
+ });
+ if (it == pProperties + iCount)
+ return nullptr;
+
+ const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eProperty);
+ ASSERT(pInfo);
+ if (dwPacket != XFA_XDPPACKET_UNKNOWN && !(dwPacket & pInfo->dwPackets))
+ return nullptr;
+ return it;
+}
+
+const XFA_PROPERTY* XFA_GetElementProperties(XFA_Element eElement,
+ int32_t& iCount) {
+ if (eElement == XFA_Element::Unknown)
+ return nullptr;
+
+ const XFA_ELEMENTHIERARCHY* pElement =
+ g_XFAElementPropertyIndex + static_cast<int32_t>(eElement);
+ iCount = pElement->wCount;
+ return g_XFAElementPropertyData + pElement->wStart;
+}
+
+const uint8_t* XFA_GetElementAttributes(XFA_Element eElement, int32_t& iCount) {
+ if (eElement == XFA_Element::Unknown)
+ return nullptr;
+
+ const XFA_ELEMENTHIERARCHY* pElement =
+ g_XFAElementAttributeIndex + static_cast<int32_t>(eElement);
+ iCount = pElement->wCount;
+ return g_XFAElementAttributeData + pElement->wStart;
+}
+
+const XFA_ELEMENTINFO* XFA_GetElementByID(XFA_Element eName) {
+ return eName != XFA_Element::Unknown
+ ? g_XFAElementData + static_cast<int32_t>(eName)
+ : nullptr;
+}
+
+XFA_Element XFA_GetElementTypeForName(const CFX_WideStringC& wsName) {
+ if (wsName.IsEmpty())
+ return XFA_Element::Unknown;
+
+ uint32_t uHash = FX_HashCode_GetW(wsName, false);
+ const XFA_ELEMENTINFO* pEnd = g_XFAElementData + g_iXFAElementCount;
+ auto pInfo = std::lower_bound(g_XFAElementData, pEnd, uHash,
+ [](const XFA_ELEMENTINFO& info, uint32_t hash) {
+ return info.uHash < hash;
+ });
+ if (pInfo < pEnd && pInfo->uHash == uHash)
+ return pInfo->eName;
+ return XFA_Element::Unknown;
+}
+
+CXFA_Measurement XFA_GetAttributeDefaultValue_Measure(XFA_Element eElement,
+ XFA_ATTRIBUTE eAttribute,
+ uint32_t dwPacket) {
+ void* pValue;
+ if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
+ XFA_ATTRIBUTETYPE_Measure, dwPacket)) {
+ return *(CXFA_Measurement*)pValue;
+ }
+ return CXFA_Measurement();
+}
+
+FX_BOOL XFA_GetAttributeDefaultValue(void*& pValue,
+ XFA_Element eElement,
+ XFA_ATTRIBUTE eAttribute,
+ XFA_ATTRIBUTETYPE eType,
+ uint32_t dwPacket) {
+ const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
+ if (!pInfo)
+ return FALSE;
+ if (dwPacket && (dwPacket & pInfo->dwPackets) == 0)
+ return FALSE;
+ if (pInfo->eType == eType) {
+ pValue = pInfo->pDefValue;
+ return TRUE;
+ }
+ if (pInfo->eType == XFA_ATTRIBUTETYPE_NOTSURE) {
+ const XFA_NOTSUREATTRIBUTE* pAttr =
+ XFA_GetNotsureAttribute(eElement, eAttribute, eType);
+ if (pAttr) {
+ pValue = pAttr->pValue;
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+const XFA_ATTRIBUTEINFO* XFA_GetAttributeByName(const CFX_WideStringC& wsName) {
+ if (wsName.IsEmpty())
+ return nullptr;
+
+ uint32_t uHash = FX_HashCode_GetW(wsName, false);
+ int32_t iStart = 0;
+ int32_t iEnd = g_iXFAAttributeCount - 1;
+ do {
+ int32_t iMid = (iStart + iEnd) / 2;
+ const XFA_ATTRIBUTEINFO* pInfo = g_XFAAttributeData + iMid;
+ if (uHash == pInfo->uHash)
+ return pInfo;
+ if (uHash < pInfo->uHash)
+ iEnd = iMid - 1;
+ else
+ iStart = iMid + 1;
+ } while (iStart <= iEnd);
+ return nullptr;
+}
+
+const XFA_ATTRIBUTEINFO* XFA_GetAttributeByID(XFA_ATTRIBUTE eName) {
+ return (eName < g_iXFAAttributeCount) ? (g_XFAAttributeData + eName)
+ : nullptr;
+}
+
+const XFA_ATTRIBUTEENUMINFO* XFA_GetAttributeEnumByName(
+ const CFX_WideStringC& wsName) {
+ if (wsName.IsEmpty())
+ return nullptr;
+
+ uint32_t uHash = FX_HashCode_GetW(wsName, false);
+ int32_t iStart = 0;
+ int32_t iEnd = g_iXFAEnumCount - 1;
+ do {
+ int32_t iMid = (iStart + iEnd) / 2;
+ const XFA_ATTRIBUTEENUMINFO* pInfo = g_XFAEnumData + iMid;
+ if (uHash == pInfo->uHash)
+ return pInfo;
+ if (uHash < pInfo->uHash)
+ iEnd = iMid - 1;
+ else
+ iStart = iMid + 1;
+ } while (iStart <= iEnd);
+ return nullptr;
+}
+
+const XFA_PACKETINFO* XFA_GetPacketByIndex(XFA_PACKET ePacket) {
+ return g_XFAPacketData + ePacket;
+}
+
+const XFA_PACKETINFO* XFA_GetPacketByID(uint32_t dwPacket) {
+ int32_t iStart = 0, iEnd = g_iXFAPacketCount - 1;
+ do {
+ int32_t iMid = (iStart + iEnd) / 2;
+ uint32_t dwFind = (g_XFAPacketData + iMid)->eName;
+ if (dwPacket == dwFind)
+ return g_XFAPacketData + iMid;
+ if (dwPacket < dwFind)
+ iEnd = iMid - 1;
+ else
+ iStart = iMid + 1;
+ } while (iStart <= iEnd);
+ return nullptr;
+}