From 5110c4743751145c4ae1934cd1d83bc6c55bb43f Mon Sep 17 00:00:00 2001 From: John Abd-El-Malek Date: Sat, 17 May 2014 22:33:34 -0700 Subject: Initial commit. --- fpdfsdk/src/javascript/PublicMethods.cpp | 2335 ++++++++++++++++++++++++++++++ 1 file changed, 2335 insertions(+) create mode 100644 fpdfsdk/src/javascript/PublicMethods.cpp (limited to 'fpdfsdk/src/javascript/PublicMethods.cpp') diff --git a/fpdfsdk/src/javascript/PublicMethods.cpp b/fpdfsdk/src/javascript/PublicMethods.cpp new file mode 100644 index 0000000000..c39c8a00dd --- /dev/null +++ b/fpdfsdk/src/javascript/PublicMethods.cpp @@ -0,0 +1,2335 @@ +// 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 "../../include/javascript/JavaScript.h" +#include "../../include/javascript/IJavaScript.h" +#include "../../include/javascript/JS_Define.h" +#include "../../include/javascript/JS_Object.h" +#include "../../include/javascript/JS_Value.h" +#include "../../include/javascript/PublicMethods.h" +#include "../../include/javascript/JS_EventHandler.h" +#include "../../include/javascript/resource.h" +#include "../../include/javascript/JS_Context.h" +#include "../../include/javascript/JS_Value.h" +#include "../../include/javascript/util.h" +#include "../../include/javascript/Field.h" +#include "../../include/javascript/color.h" +#include "../../include/javascript/JS_Runtime.h" + +static v8::Isolate* GetIsolate(IFXJS_Context* cc) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + + CJS_Runtime* pRuntime = pContext->GetJSRuntime(); + ASSERT(pRuntime != NULL); + + return pRuntime->GetIsolate(); +} + + +/* -------------------------------- CJS_PublicMethods -------------------------------- */ + +#define DOUBLE_CORRECT 0.000000000000001 + +BEGIN_JS_STATIC_GLOBAL_FUN(CJS_PublicMethods) + JS_STATIC_GLOBAL_FUN_ENTRY(AFNumber_Format,6) + JS_STATIC_GLOBAL_FUN_ENTRY(AFNumber_Keystroke,6) + JS_STATIC_GLOBAL_FUN_ENTRY(AFPercent_Format,2) + JS_STATIC_GLOBAL_FUN_ENTRY(AFPercent_Keystroke,2) + JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_FormatEx,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_KeystrokeEx,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_Format,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_Keystroke,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_FormatEx,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_KeystrokeEx,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_Format,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_Keystroke,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_Format,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_Keystroke,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_KeystrokeEx,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFSimple,3) + JS_STATIC_GLOBAL_FUN_ENTRY(AFMakeNumber,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFSimple_Calculate,2) + JS_STATIC_GLOBAL_FUN_ENTRY(AFRange_Validate,4) + JS_STATIC_GLOBAL_FUN_ENTRY(AFMergeChange,1) + JS_STATIC_GLOBAL_FUN_ENTRY(AFParseDateEx,2) + JS_STATIC_GLOBAL_FUN_ENTRY(AFExtractNums,1) +END_JS_STATIC_GLOBAL_FUN() + +IMPLEMENT_JS_STATIC_GLOBAL_FUN(CJS_PublicMethods) + +struct stru_TbConvert +{ + FX_LPCSTR lpszJSMark; + FX_LPCSTR lpszCppMark; +}; + +static const stru_TbConvert fcTable[] = {"mmmm","%B", + "mmm", "%b", + "mm", "%m", + //"m" + "dddd","%A", + "ddd", "%a", + "dd", "%d", + //"d", "%w", + "yyyy","%Y", + "yy", "%y", + "HH", "%H", + //"H" + "hh", "%I", + //"h" + "MM", "%M", + //"M" + "ss", "%S", + //"s + "tt", "%p" + //"t" +}; + +static FX_LPCWSTR months[] = +{ + (FX_LPCWSTR)L"Jan", (FX_LPCWSTR)L"Feb", (FX_LPCWSTR)L"Mar", (FX_LPCWSTR)L"Apr", (FX_LPCWSTR)L"May", (FX_LPCWSTR)L"Jun", (FX_LPCWSTR)L"Jul", (FX_LPCWSTR)L"Aug", (FX_LPCWSTR)L"Sep", (FX_LPCWSTR)L"Oct", (FX_LPCWSTR)L"Nov", (FX_LPCWSTR)L"Dec" +}; + +static FX_LPCWSTR fullmonths[] = +{ + (FX_LPCWSTR)L"January", (FX_LPCWSTR)L"February", (FX_LPCWSTR)L"March", (FX_LPCWSTR)L"April", (FX_LPCWSTR)L"May", (FX_LPCWSTR)L"June", (FX_LPCWSTR)L"July", (FX_LPCWSTR)L"August", (FX_LPCWSTR)L"September", (FX_LPCWSTR)L"October", (FX_LPCWSTR)L"November", (FX_LPCWSTR)L"December" +}; + +FX_BOOL CJS_PublicMethods::IsNumber(FX_LPCWSTR string) +{ + CFX_WideString sTrim = StrTrim(string); + FX_LPCWSTR pTrim = sTrim; + FX_LPCWSTR p = pTrim; + + + FX_BOOL bDot = FALSE; + FX_BOOL bKXJS = FALSE; + + wchar_t c; + while ((c = *p)) + { + if (c == '.' || c == ',') + { + if (bDot) return FALSE; + bDot = TRUE; + } + else if (c == '-' || c == '+') + { + if (p != pTrim) + return FALSE; + } + else if (c == 'e' || c == 'E') + { + if (bKXJS) return FALSE; + + p++; + c = *p; + if (c == '+' || c == '-') + { + bKXJS = TRUE; + } + else + { + return FALSE; + } + } + else if (!IsDigit(c)) + { + return FALSE; + } + p++; + } + + return TRUE; +} + +FX_BOOL CJS_PublicMethods::IsDigit(wchar_t ch) +{ + return (ch >= L'0' && ch <= L'9'); +} + +FX_BOOL CJS_PublicMethods::IsDigit(char ch) +{ + return (ch >= '0' && ch <= '9'); +} + +FX_BOOL CJS_PublicMethods::IsAlphabetic(wchar_t ch) +{ + return ((ch >= L'a' && ch <= L'z') || (ch >= L'A' && ch <= L'Z')); +} + +FX_BOOL CJS_PublicMethods::IsAlphaNumeric(wchar_t ch) +{ + return (IsDigit(ch) || IsAlphabetic(ch)); +} + +FX_BOOL CJS_PublicMethods::maskSatisfied(wchar_t c_Change,wchar_t c_Mask) +{ + switch (c_Mask) + { + case L'9': + return IsDigit(c_Change); + case L'A': + return IsAlphabetic(c_Change); + case L'O': + return IsAlphaNumeric(c_Change); + case L'X': + return TRUE; + default: + return (c_Change == c_Mask); + } +} + +FX_BOOL CJS_PublicMethods::isReservedMaskChar(wchar_t ch) +{ + return ch == L'9' || ch == L'A' || ch == L'O' || ch == L'X'; +} + +double CJS_PublicMethods::AF_Simple(FX_LPCWSTR sFuction, double dValue1, double dValue2) +{ + if (FXSYS_wcsicmp(sFuction,(FX_LPCWSTR)L"AVG") == 0 || FXSYS_wcsicmp(sFuction,(FX_LPCWSTR)L"SUM") == 0) + { + return dValue1 + dValue2; + } + else if (FXSYS_wcsicmp(sFuction, (FX_LPCWSTR)L"PRD") == 0) + { + return dValue1 * dValue2; + } + else if (FXSYS_wcsicmp(sFuction,(FX_LPCWSTR)L"MIN") == 0) + { + return FX_MIN(dValue1, dValue2); + } + else if (FXSYS_wcsicmp(sFuction,(FX_LPCWSTR)L"MAX") == 0) + { + return FX_MAX(dValue1, dValue2); + } + + return dValue1; +} + +CFX_WideString CJS_PublicMethods::StrLTrim(FX_LPCWSTR pStr) +{ + while (*pStr && *pStr == L' ') pStr++; + + return pStr; +} + +CFX_WideString CJS_PublicMethods::StrRTrim(FX_LPCWSTR pStr) +{ + FX_LPCWSTR p = pStr; + + while (*p) p++; + p--; + if (p >= pStr) + { + while (*p && *p == L' ') p--; + p++; + return CFX_WideString(pStr,p-pStr); + } + return L""; +} + +CFX_WideString CJS_PublicMethods::StrTrim(FX_LPCWSTR pStr) +{ + return StrRTrim(StrLTrim(pStr)); +} + +CFX_ByteString CJS_PublicMethods::StrLTrim(FX_LPCSTR pStr) +{ + while (*pStr && *pStr == ' ') pStr++; + + return pStr; +} + +CFX_ByteString CJS_PublicMethods::StrRTrim(FX_LPCSTR pStr) +{ + FX_LPCSTR p = pStr; + + while (*p) p++; + p--; + if (p >= pStr) + { + while (*p && *p == ' ') p--; + p++; + return CFX_ByteString(pStr,p-pStr); + } + return ""; +} + +CFX_ByteString CJS_PublicMethods::StrTrim(FX_LPCSTR pStr) +{ + return StrRTrim(StrLTrim(pStr)); +} + +double CJS_PublicMethods::ParseNumber(FX_LPCWSTR swSource, FX_BOOL& bAllDigits, FX_BOOL& bDot, FX_BOOL& bSign, FX_BOOL& bKXJS) +{ + bDot = FALSE; + bSign = FALSE; + bKXJS = FALSE; + + FX_BOOL bDigitExist = FALSE; + + FX_LPCWSTR p = swSource; + wchar_t c; + + FX_LPCWSTR pStart = NULL; + FX_LPCWSTR pEnd = NULL; + + while ((c = *p)) + { + if (!pStart && c != L' ') + { + pStart = p; + } + + pEnd = p; + p++; + } + + if (!pStart) + { + bAllDigits = FALSE; + return 0; + } + + while (pEnd != pStart) + { + if (*pEnd == L' ') + pEnd --; + else + break; + } + + double dRet = 0; + p = pStart; + bAllDigits = TRUE; + CFX_WideString swDigits; + + while (p <= pEnd) + { + c = *p; + + if (IsDigit(c)) + { + swDigits += c; + bDigitExist = TRUE; + } + else + { + switch (c) + { + case L' ': + bAllDigits = FALSE; + break; + case L'.': + case L',': + if (!bDot) + { + if (bDigitExist) + { + swDigits += L'.'; + } + else + { + swDigits += L'0'; + swDigits += L'.'; + bDigitExist = TRUE; + } + + bDot = TRUE; + break; + } + case 'e': + case 'E': + if (!bKXJS) + { + p++; + c = *p; + if (c == '+' || c == '-') + { + bKXJS = TRUE; + swDigits += 'e'; + swDigits += c; + } + break; + } + case L'-': + if (!bDigitExist && !bSign) + { + swDigits += c; + bSign = TRUE; + break; + } + default: + bAllDigits = FALSE; + + if (p != pStart && !bDot && bDigitExist) + { + swDigits += L'.'; + bDot = TRUE; + } + else + { + bDot = FALSE; + bDigitExist = FALSE; + swDigits = L""; + } + break; + } + } + + p++; + } + + if (swDigits.GetLength() > 0 && swDigits.GetLength() < 17) + { + CFX_ByteString sDigits = swDigits.UTF8Encode(); + + if (bKXJS) + { + dRet = atof(sDigits); + } + else + { + if (bDot) + { + char* pStopString; + dRet = ::strtod(sDigits, &pStopString); + } + else + { + dRet = atol(sDigits); + } + } + + } + + return dRet; +} + +double CJS_PublicMethods::ParseStringToNumber(FX_LPCWSTR swSource) +{ + FX_BOOL bAllDigits = FALSE; + FX_BOOL bDot = FALSE; + FX_BOOL bSign = FALSE; + FX_BOOL bKXJS = FALSE; + + return ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS); +} + +FX_BOOL CJS_PublicMethods::ConvertStringToNumber(FX_LPCWSTR swSource, double & dRet, FX_BOOL & bDot) +{ + FX_BOOL bAllDigits = FALSE; + FX_BOOL bSign = FALSE; + FX_BOOL bKXJS = FALSE; + + dRet = ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS); + + return bAllDigits; +} + +CJS_Array CJS_PublicMethods::AF_MakeArrayFromList(v8::Isolate* isolate, CJS_Value val) +{ + CJS_Array StrArray(isolate); + if(val.IsArrayObject()) + { + val.ConvertToArray(StrArray); + return StrArray; + } + CFX_WideString wsStr = val.operator CFX_WideString(); + CFX_ByteString t = CFX_ByteString::FromUnicode(wsStr); + const char * p = (const char *)t; + + + int ch = ',' ; + int nIndex = 0; + + while (*p) + { + const char * pTemp = strchr(p, ch); + if (pTemp == NULL) + { + StrArray.SetElement(nIndex, CJS_Value(isolate,(FX_LPCSTR)StrTrim(p))); + break; + } + else + { + char * pSub = new char[pTemp - p + 1]; + strncpy(pSub, p, pTemp - p); + *(pSub + (pTemp - p)) = '\0'; + + StrArray.SetElement(nIndex, CJS_Value(isolate,(FX_LPCSTR)StrTrim(pSub))); + delete []pSub; + + nIndex ++; + p = ++pTemp; + } + + } + return StrArray; +} + +int CJS_PublicMethods::ParseStringInteger(const CFX_WideString& string,int nStart,int& nSkip, int nMaxStep) +{ + int nRet = 0; + nSkip = 0; + for (int i=nStart, sz=string.GetLength(); i < sz; i++) + { + if (i-nStart > 10) + break; + + FX_WCHAR c = string.GetAt(i); + if (IsDigit((wchar_t)c)) + { + nRet = nRet * 10 + (c - '0'); + nSkip = i - nStart + 1; + if (nSkip >= nMaxStep) + break; + } + else + break; + } + + return nRet; +} + +CFX_WideString CJS_PublicMethods::ParseStringString(const CFX_WideString& string, int nStart, int& nSkip) +{ + CFX_WideString swRet; + nSkip = 0; + for (int i=nStart, sz=string.GetLength(); i < sz; i++) + { + FX_WCHAR c = string.GetAt(i); + if ((c >= L'a' && c <= L'z') || (c >= L'A' && c <= L'Z')) + { + swRet += c; + nSkip = i - nStart + 1; + } + else + break; + } + + return swRet; +} + +double CJS_PublicMethods::ParseNormalDate(const CFX_WideString & value, FX_BOOL& bWrongFormat) +{ + double dt = JS_GetDateTime(); + + int nYear = JS_GetYearFromTime(dt); + int nMonth = JS_GetMonthFromTime(dt) + 1; + int nDay = JS_GetDayFromTime(dt); + int nHour = JS_GetHourFromTime(dt); + int nMin = JS_GetMinFromTime(dt); + int nSec = JS_GetSecFromTime(dt); + + int number[3]; + + int nSkip = 0; + int nLen = value.GetLength(); + int nIndex = 0; + int i = 0; + while (i < nLen) + { + if (nIndex > 2) break; + + FX_WCHAR c = value.GetAt(i); + if (IsDigit((wchar_t)c)) + { + number[nIndex++] = ParseStringInteger(value, i, nSkip, 4); + i += nSkip; + } + else + { + i ++; + } + } + + if (nIndex == 2) + { + // case2: month/day + // case3: day/month + if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && number[1] <= 31)) + { + nMonth = number[0]; + nDay = number[1]; + } + else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && number[1] <= 12)) + { + nDay = number[0]; + nMonth = number[1]; + } + + bWrongFormat = FALSE; + } + else if (nIndex == 3) + { + // case1: year/month/day + // case2: month/day/year + // case3: day/month/year + + if (number[0] > 12 && (number[1] >= 1 && number[1] <= 12) && (number[2] >= 1 && number[2] <= 31)) + { + nYear = number[0]; + nMonth = number[1]; + nDay = number[2]; + } + else if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && number[1] <= 31) && number[2] > 31) + { + nMonth = number[0]; + nDay = number[1]; + nYear = number[2]; + } + else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && number[1] <= 12) && number[2] > 31) + { + nDay = number[0]; + nMonth = number[1]; + nYear = number[2]; + } + + bWrongFormat = FALSE; + } + else + { + bWrongFormat = TRUE; + return dt; + } + + CFX_WideString swTemp; + swTemp.Format((FX_LPCWSTR)L"%d/%d/%d %d:%d:%d",nMonth,nDay,nYear,nHour,nMin,nSec); + return JS_DateParse(swTemp); +} + +double CJS_PublicMethods::MakeRegularDate(const CFX_WideString & value, const CFX_WideString & format, FX_BOOL& bWrongFormat) +{ + double dt = JS_GetDateTime(); + + if (format.IsEmpty() || value.IsEmpty()) + return dt; + + int nYear = JS_GetYearFromTime(dt); + int nMonth = JS_GetMonthFromTime(dt) + 1; + int nDay = JS_GetDayFromTime(dt); + int nHour = JS_GetHourFromTime(dt); + int nMin = JS_GetMinFromTime(dt); + int nSec = JS_GetSecFromTime(dt); + + int nYearSub = 99; //nYear - 2000; + + FX_BOOL bPm = FALSE; + FX_BOOL bExit = FALSE; + bWrongFormat = FALSE; + + int i=0; + int j=0; + + while (i < format.GetLength()) + { + if (bExit) break; + + FX_WCHAR c = format.GetAt(i); + switch (c) + { + case ':': + case '.': + case '-': + case '\\': + case '/': + i++; + j++; + break; + + case 'y': + case 'm': + case 'd': + case 'H': + case 'h': + case 'M': + case 's': + case 't': + { + int oldj = j; + int nSkip = 0; + + if (format.GetAt(i+1) != c) + { + switch (c) + { + case 'y': + i++; + j++; + break; + case 'm': + nMonth = ParseStringInteger(value, j, nSkip, 2); + i++; + j += nSkip; + break; + case 'd': + nDay = ParseStringInteger(value, j, nSkip, 2); + i++; + j += nSkip; + break; + case 'H': + nHour = ParseStringInteger(value, j, nSkip, 2); + i++; + j += nSkip; + break; + case 'h': + nHour = ParseStringInteger(value, j, nSkip, 2); + i++; + j += nSkip; + break; + case 'M': + nMin = ParseStringInteger(value, j, nSkip, 2); + i++; + j += nSkip; + break; + case 's': + nSec = ParseStringInteger(value, j, nSkip, 2); + i++; + j += nSkip; + break; + case 't': + bPm = value.GetAt(i) == 'p'; + i++; + j++; + break; + } + } + else if (format.GetAt(i+1) == c && format.GetAt(i+2) != c) + { + switch (c) + { + case 'y': + nYear = ParseStringInteger(value, j, nSkip, 4); + i += 2; + j += nSkip; + break; + case 'm': + nMonth = ParseStringInteger(value, j, nSkip, 2); + i += 2; + j += nSkip; + break; + case 'd': + nDay = ParseStringInteger(value, j, nSkip, 2); + i += 2; + j += nSkip; + break; + case 'H': + nHour = ParseStringInteger(value, j, nSkip, 2); + i += 2; + j += nSkip; + break; + case 'h': + nHour = ParseStringInteger(value, j, nSkip, 2); + i += 2; + j += nSkip; + break; + case 'M': + nMin = ParseStringInteger(value, j, nSkip, 2); + i += 2; + j += nSkip; + break; + case 's': + nSec = ParseStringInteger(value, j, nSkip, 2); + i += 2; + j += nSkip; + break; + case 't': + bPm = (value.GetAt(j) == 'p' && value.GetAt(j+1) == 'm'); + i += 2; + j += 2; + break; + } + } + else if (format.GetAt(i+1) == c && format.GetAt(i+2) == c && format.GetAt(i+3) != c) + { + switch (c) + { + case 'm': + { + CFX_WideString sMonth = ParseStringString(value, j, nSkip); + FX_BOOL bFind = FALSE; + for (int m = 0; m < 12; m++) + { + if (sMonth.CompareNoCase(months[m]) == 0) + { + nMonth = m + 1; + i+=3; + j+=nSkip; + bFind = TRUE; + break; + } + } + + if (!bFind) + { + nMonth = ParseStringInteger(value, j, nSkip, 3); + i+=3; + j += nSkip; + } + } + break; + case 'y': + break; + default: + i+=3; + j+=3; + break; + } + } + else if (format.GetAt(i+1) == c && format.GetAt(i+2) == c && format.GetAt(i+3) == c && format.GetAt(i+4) != c) + { + switch (c) + { + + + case 'y': + nYear = ParseStringInteger(value, j, nSkip, 4); + j += nSkip; + i += 4; + break; + case 'm': + { + FX_BOOL bFind = FALSE; + + CFX_WideString sMonth = ParseStringString(value, j, nSkip); + sMonth.MakeLower(); + + for (int m = 0; m < 12; m++) + { + CFX_WideString sFullMonths = fullmonths[m]; + sFullMonths.MakeLower(); + + if (sFullMonths.Find(sMonth, 0) != -1) + { + nMonth = m + 1; + i += 4; + j += nSkip; + bFind = TRUE; + break; + } + } + + if (!bFind) + { + nMonth = ParseStringInteger(value, j, nSkip, 4); + i+=4; + j += nSkip; + } + } + break; + default: + i += 4; + j += 4; + break; + } + } + else + { + if (format.GetAt(i) != value.GetAt(j)) + { + bWrongFormat = TRUE; + bExit = TRUE; + } + i++; + j++; + } + + if (oldj == j) + { + bWrongFormat = TRUE; + bExit = TRUE; + } + } + + break; + default: + if (value.GetLength() <= j) + { + bExit = TRUE; + } + else if (format.GetAt(i) != value.GetAt(j)) + { + bWrongFormat = TRUE; + bExit = TRUE; + } + + i++; + j++; + break; + } + } + + if (bPm) nHour += 12; + + if (nYear >= 0 && nYear <= nYearSub) + nYear += 2000; + + if (nMonth < 1 || nMonth > 12) + bWrongFormat = TRUE; + + if (nDay < 1 || nDay > 31) + bWrongFormat = TRUE; + + if (nHour < 0 || nHour > 24) + bWrongFormat = TRUE; + + if (nMin < 0 || nMin > 60) + bWrongFormat = TRUE; + + if (nSec < 0 || nSec > 60) + bWrongFormat = TRUE; + + double dRet = 0; + + if (bWrongFormat) + { + dRet = ParseNormalDate(value, bWrongFormat); + } + else + { + dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime(nHour, nMin, nSec, 0)); + + if (JS_PortIsNan(dRet)) + { + dRet = JS_DateParse(value); + } + } + + if (JS_PortIsNan(dRet)) + { + dRet = ParseNormalDate(value, bWrongFormat); + } + + return dRet; + +} + +CFX_WideString CJS_PublicMethods::MakeFormatDate(double dDate, const CFX_WideString & format) +{ + CFX_WideString sRet = L"",sPart = L""; + + int nYear = JS_GetYearFromTime(dDate); + int nMonth = JS_GetMonthFromTime(dDate) + 1; + int nDay = JS_GetDayFromTime(dDate); + int nHour = JS_GetHourFromTime(dDate); + int nMin = JS_GetMinFromTime(dDate); + int nSec = JS_GetSecFromTime(dDate); + + int i = 0; + FX_WCHAR c; + while (i < format.GetLength()) + { + c = format.GetAt(i); + sPart = L""; + switch (c) + { + case 'y': + case 'm': + case 'd': + case 'H': + case 'h': + case 'M': + case 's': + case 't': + if (format.GetAt(i+1) != c) + { + switch (c) + { + case 'y': + sPart += c; + break; + case 'm': + sPart.Format((FX_LPCWSTR)L"%d",nMonth); + break; + case 'd': + sPart.Format((FX_LPCWSTR)L"%d",nDay); + break; + case 'H': + sPart.Format((FX_LPCWSTR)L"%d",nHour); + break; + case 'h': + sPart.Format((FX_LPCWSTR)L"%d",nHour>12?nHour - 12:nHour); + break; + case 'M': + sPart.Format((FX_LPCWSTR)L"%d",nMin); + break; + case 's': + sPart.Format((FX_LPCWSTR)L"%d",nSec); + break; + case 't': + sPart += nHour>12?'p':'a'; + break; + } + i++; + } + else if (format.GetAt(i+1) == c && format.GetAt(i+2) != c) + { + switch (c) + { + case 'y': + sPart.Format((FX_LPCWSTR)L"%02d",nYear - (nYear / 100) * 100); + break; + case 'm': + sPart.Format((FX_LPCWSTR)L"%02d",nMonth); + break; + case 'd': + sPart.Format((FX_LPCWSTR)L"%02d",nDay); + break; + case 'H': + sPart.Format((FX_LPCWSTR)L"%02d",nHour); + break; + case 'h': + sPart.Format((FX_LPCWSTR)L"%02d",nHour>12?nHour - 12:nHour); + break; + case 'M': + sPart.Format((FX_LPCWSTR)L"%02d",nMin); + break; + case 's': + sPart.Format((FX_LPCWSTR)L"%02d",nSec); + break; + case 't': + sPart = nHour>12? (FX_LPCWSTR)L"pm": (FX_LPCWSTR)L"am"; + break; + } + i+=2; + } + else if (format.GetAt(i+1) == c && format.GetAt(i+2) == c && format.GetAt(i+3) != c) + { + switch (c) + { + case 'm': + i+=3; + if (nMonth > 0&&nMonth <= 12) + sPart += months[nMonth - 1]; + break; + default: + i+=3; + sPart += c; + sPart += c; + sPart += c; + break; + } + } + else if (format.GetAt(i+1) == c && format.GetAt(i+2) == c && format.GetAt(i+3) == c && format.GetAt(i+4) != c) + { + switch (c) + { + case 'y': + sPart.Format((FX_LPCWSTR)L"%04d",nYear); + i += 4; + break; + case 'm': + i+=4; + if (nMonth > 0&&nMonth <= 12) + sPart += fullmonths[nMonth - 1]; + break; + default: + i += 4; + sPart += c; + sPart += c; + sPart += c; + sPart += c; + break; + } + } + else + { + i++; + sPart += c; + } + break; + default: + i++; + sPart += c; + break; + } + + sRet += sPart; + } + + return sRet; +} + +/* -------------------------------------------------------------------------- */ + +//function AFNumber_Format(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend) +FX_BOOL CJS_PublicMethods::AFNumber_Format(OBJ_METHOD_PARAMS) +{ +#if _FX_OS_ != _FX_ANDROID_ + v8::Isolate* isolate = ::GetIsolate(cc); + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if (params.size() != 6) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString& Value = pEvent->Value(); + CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value)); + + if (strValue.IsEmpty()) return TRUE; + + int iDec = params[0]; + int iSepStyle = params[1]; + int iNegStyle = params[2]; + int icurrStyle = params[3]; //it's no use! + std::wstring wstrCurrency(params[4].operator CFX_WideString()); + FX_BOOL bCurrencyPrepend = params[5]; + + if (iDec < 0) iDec = -iDec; + + if (iSepStyle < 0 || iSepStyle > 3) + iSepStyle = 0; + + if (iNegStyle < 0 || iNegStyle > 3) + iNegStyle = 0; + + + ////////////////////////////////////////////////////// + //for processing decimal places + strValue.Replace(",", "."); + double dValue = atof(strValue); + if (iDec > 0) + dValue += DOUBLE_CORRECT;// + + int iDec2; + FX_BOOL bNagative = FALSE; + + strValue = fcvt(dValue,iDec,&iDec2,&bNagative); + if (strValue.IsEmpty()) + { + dValue = 0; + strValue = fcvt(dValue,iDec,&iDec2,&bNagative); + if (strValue.IsEmpty()) + { + strValue = "0"; + iDec2 = 1; + } + + } + + if (iDec2 < 0) + { + for (int iNum = 0;iNum < abs(iDec2);iNum++) + { + strValue = "0" + strValue; + } + iDec2 = 0; + + } + int iMax = strValue.GetLength(); + if (iDec2 > iMax) + { + for (int iNum = 0;iNum <= iDec2 - iMax ;iNum++) + { + strValue += "0"; + } + iMax = iDec2+1; + } + /////////////////////////////////////////////////////// + //for processing seperator style + if (iDec2 < iMax) + { + if (iSepStyle == 0 || iSepStyle == 1) + { + strValue.Insert(iDec2, '.'); + iMax++; + } + else if (iSepStyle == 2 || iSepStyle == 3) + { + strValue.Insert(iDec2, ','); + iMax++; + } + + if (iDec2 == 0) + strValue.Insert(iDec2, '0'); + } + if (iSepStyle == 0 || iSepStyle == 2) + { + char cSeperator; + if (iSepStyle == 0) + cSeperator = ','; + else + cSeperator = '.'; + + int iDecPositive,iDecNagative; + iDecPositive = iDec2; + iDecNagative = iDec2; + + for (iDecPositive = iDec2 -3; iDecPositive > 0;iDecPositive -= 3) + { + strValue.Insert(iDecPositive, cSeperator); + iMax++; + } + } + + ////////////////////////////////////////////////////////////////////// + //for processing currency string + + Value = CFX_WideString::FromLocal(strValue); + + std::wstring strValue2(Value); + + if (bCurrencyPrepend) + strValue2 = wstrCurrency + strValue2; + else + strValue2 = strValue2 + wstrCurrency; + + + + ///////////////////////////////////////////////////////////////////////// + //for processing negative style + if (bNagative) + { + if (iNegStyle == 0) + { + strValue2.insert(0,L"-"); + } + if (iNegStyle == 2 || iNegStyle == 3) + { + strValue2.insert(0,L"("); + strValue2.insert(strValue2.length(),L")"); + } + if (iNegStyle == 1 || iNegStyle == 3) + { + if (Field * fTarget = pEvent->Target_Field()) + { + CJS_Array arColor(isolate); + CJS_Value vColElm(isolate); + vColElm = L"RGB"; + arColor.SetElement(0,vColElm); + vColElm = 1; + arColor.SetElement(1,vColElm); + vColElm = 0; + arColor.SetElement(2,vColElm); + + arColor.SetElement(3,vColElm); + + CJS_PropValue vProp(isolate); + vProp.StartGetting(); + vProp<textColor(cc,vProp,sError);// red + } + } + } + else + { + if (iNegStyle == 1 || iNegStyle == 3) + { + if (Field *fTarget = pEvent->Target_Field()) + { + CJS_Array arColor(isolate); + CJS_Value vColElm(isolate); + vColElm = L"RGB"; + arColor.SetElement(0,vColElm); + vColElm = 0; + arColor.SetElement(1,vColElm); + arColor.SetElement(2,vColElm); + arColor.SetElement(3,vColElm); + + CJS_PropValue vProp(isolate); + vProp.StartGetting(); + fTarget->textColor(cc,vProp,sError); + + CJS_Array aProp(isolate); + vProp.ConvertToArray(aProp); + + CPWL_Color crProp; + CPWL_Color crColor; + color::ConvertArrayToPWLColor(aProp, crProp); + color::ConvertArrayToPWLColor(arColor, crColor); + + if (crColor != crProp) + { + CJS_PropValue vProp2(isolate); + vProp2.StartGetting(); + vProp2<textColor(cc,vProp2,sError); + } + } + } + } + Value = strValue2.c_str(); +#endif + return TRUE; +} + +//function AFNumber_Keystroke(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend) +FX_BOOL CJS_PublicMethods::AFNumber_Keystroke(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if(params.size() < 2) + return FALSE; + int iSepStyle = params[1]; + + if (iSepStyle < 0 || iSepStyle > 3) + iSepStyle = 0; + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString & val = pEvent->Value(); + CFX_WideString & w_strChange = pEvent->Change(); + CFX_WideString w_strValue = val; + + if (pEvent->WillCommit()) + { + CFX_WideString wstrChange = w_strChange; + CFX_WideString wstrValue = StrLTrim(w_strValue); + if (wstrValue.IsEmpty()) + return TRUE; + + CFX_WideString swTemp = wstrValue; + swTemp.Replace((FX_LPCWSTR)L",", (FX_LPCWSTR)L"."); + if (!IsNumber(swTemp)) //!(IsNumber(wstrChange) && + { + pEvent->Rc() = FALSE; + sError = JSGetStringFromID(pContext, IDS_STRING_JSAFNUMBER_KEYSTROKE); + Alert(pContext, sError); + return TRUE; + } + return TRUE; // it happens after the last keystroke and before validating, + } + + std::wstring w_strValue2 (w_strValue); + std::wstring w_strChange2(w_strChange); + + std::wstring w_strSelected; + if(-1 != pEvent->SelStart()) + w_strSelected = w_strValue2.substr(pEvent->SelStart(),(pEvent->SelEnd() - pEvent->SelStart())); + FX_BOOL bHasSign = (w_strValue2.find('-') != -1) && (w_strSelected.find('-') == -1); + if (bHasSign) + { + //can't insert "change" in front to sign postion. + if (pEvent->SelStart() == 0) + { + FX_BOOL &bRc = pEvent->Rc(); + bRc = FALSE; + return TRUE; + } + } + + char cSep = L'.'; + + switch (iSepStyle) + { + case 0: + case 1: + cSep = L'.'; + break; + case 2: + case 3: + cSep = L','; + break; + } + + FX_BOOL bHasSep = (w_strValue2.find(cSep) != -1); + for (std::wstring::iterator it = w_strChange2.begin(); it != w_strChange2.end(); it++) + { + if (*it == cSep) + { + if (bHasSep) + { + FX_BOOL &bRc = pEvent->Rc(); + bRc = FALSE; + return TRUE; + } + else + { + bHasSep = TRUE; + continue; + } + } + if (*it == L'-') + { + if (bHasSign) + { + FX_BOOL &bRc = pEvent->Rc(); + bRc = FALSE; + return TRUE; + } + else if (it != w_strChange2.begin()) //sign's position is not correct + { + FX_BOOL &bRc = pEvent->Rc(); + bRc = FALSE; + return TRUE; + } + else if (pEvent->SelStart() != 0) + { + FX_BOOL &bRc = pEvent->Rc(); + bRc = FALSE; + return TRUE; + } + bHasSign = TRUE; + continue; + } + + if (!IsDigit(*it)) + { + FX_BOOL &bRc = pEvent->Rc(); + bRc = FALSE; + return TRUE; + } + } + + + std::wstring w_prefix = w_strValue2.substr(0,pEvent->SelStart()); + std::wstring w_postfix; + if (pEvent->SelEnd()<(int)w_strValue2.length()) + w_postfix = w_strValue2.substr(pEvent->SelEnd()); + w_strValue2 = w_prefix + w_strChange2 + w_postfix; + w_strValue = w_strValue2.c_str(); + val = w_strValue; + return TRUE; + +} + +//function AFPercent_Format(nDec, sepStyle) +FX_BOOL CJS_PublicMethods::AFPercent_Format(OBJ_METHOD_PARAMS) +{ +#if _FX_OS_ != _FX_ANDROID_ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if (params.size() != 2) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString& Value = pEvent->Value(); + +// HWND hMainFrame = NULL; +// +// CPDFSDK_FormFillApp *pApp = pContext->GetReaderApp(); +// ASSERT(pApp); +// hMainFrame = pApp->GetMainFrameWnd(); + + CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value)); + + if (strValue.IsEmpty()) + return TRUE; + + int iDec = params[0]; + int iSepStyle = params[1]; + + //ASSERT(iDec > 0); + if (iDec < 0) + iDec = -iDec; + + if (iSepStyle < 0 || iSepStyle > 3) + iSepStyle = 0; + + + ////////////////////////////////////////////////////// + //for processing decimal places + double dValue = atof(strValue); + dValue *= 100; + if (iDec > 0) + dValue += DOUBLE_CORRECT;//УÕý + + int iDec2; + FX_BOOL bNagative = FALSE; + strValue = fcvt(dValue,iDec,&iDec2,&bNagative); + if (strValue.IsEmpty()) + { + dValue = 0; + strValue = fcvt(dValue,iDec,&iDec2,&bNagative); + } + + if (iDec2 < 0) + { + for (int iNum = 0; iNum < abs(iDec2); iNum++) + { + strValue = "0" + strValue; + } + iDec2 = 0; + + } + int iMax = strValue.GetLength(); + if (iDec2 > iMax) + { + for (int iNum = 0; iNum <= iDec2 - iMax; iNum++) + { + strValue += "0"; + } + iMax = iDec2+1; + } + /////////////////////////////////////////////////////// + //for processing seperator style + if (iDec2 < iMax) + { + if (iSepStyle == 0 || iSepStyle == 1) + { + strValue.Insert(iDec2, '.'); + iMax++; + } + else if (iSepStyle == 2 || iSepStyle == 3) + { + strValue.Insert(iDec2, ','); + iMax++; + } + + if (iDec2 == 0) + strValue.Insert(iDec2, '0'); + } + if (iSepStyle == 0 || iSepStyle == 2) + { + char cSeperator; + if (iSepStyle == 0) + cSeperator = ','; + else + cSeperator = '.'; + + int iDecPositive,iDecNagative; + iDecPositive = iDec2; + iDecNagative = iDec2; + + for (iDecPositive = iDec2 -3; iDecPositive > 0; iDecPositive -= 3) + { + strValue.Insert(iDecPositive,cSeperator); + iMax++; + } + } + //////////////////////////////////////////////////////////////////// + //nagative mark + if(bNagative) + strValue = "-" + strValue; + strValue += "%"; + Value = CFX_WideString::FromLocal(strValue); +#endif + return TRUE; +} +//AFPercent_Keystroke(nDec, sepStyle) +FX_BOOL CJS_PublicMethods::AFPercent_Keystroke(OBJ_METHOD_PARAMS) +{ + return AFNumber_Keystroke(cc,params,vRet,sError); +} + +//function AFDate_FormatEx(cFormat) +FX_BOOL CJS_PublicMethods::AFDate_FormatEx(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if (params.size() != 1) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString& val = pEvent->Value(); + + CFX_WideString strValue = val; + if (strValue.IsEmpty()) return TRUE; + + CFX_WideString sFormat = params[0].operator CFX_WideString(); + + FX_BOOL bWrongFormat = FALSE; + double dDate = 0.0f; + + if(strValue.Find(L"GMT") != -1) + { + //for GMT format time + //such as "Tue Aug 11 14:24:16 GMT+08002009" + dDate = MakeInterDate(strValue); + } + else + { + dDate = MakeRegularDate(strValue,sFormat,bWrongFormat); + } + + if (JS_PortIsNan(dDate)) + { + CFX_WideString swMsg; + swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE), (FX_LPCWSTR)sFormat); + Alert(pContext, swMsg); + return FALSE; + } + + val = MakeFormatDate(dDate,sFormat); + + return TRUE; +} + +double CJS_PublicMethods::MakeInterDate(CFX_WideString strValue) +{ + int nHour; + int nMin; + int nSec; + int nYear; + int nMonth; + int nDay; + + CFX_WideStringArray wsArray; + CFX_WideString sMonth = L""; + CFX_WideString sTemp = L""; + int nSize = strValue.GetLength(); + + for(int i = 0; i < nSize; i++) + { + FX_WCHAR c = strValue.GetAt(i); + if(c == L' ' || c == L':') + { + wsArray.Add(sTemp); + sTemp = L""; + continue; + } + + sTemp += c; + } + + wsArray.Add(sTemp); + if(wsArray.GetSize() != 8)return 0; + + sTemp = wsArray[1]; + if(sTemp.Compare(L"Jan") == 0) nMonth = 1; + if(sTemp.Compare(L"Feb") == 0) nMonth = 2; + if(sTemp.Compare(L"Mar") == 0) nMonth = 3; + if(sTemp.Compare(L"Apr") == 0) nMonth = 4; + if(sTemp.Compare(L"May") == 0) nMonth = 5; + if(sTemp.Compare(L"Jun") == 0) nMonth = 6; + if(sTemp.Compare(L"Jul") == 0) nMonth = 7; + if(sTemp.Compare(L"Aug") == 0) nMonth = 8; + if(sTemp.Compare(L"Sep") == 0) nMonth = 9; + if(sTemp.Compare(L"Oct") == 0) nMonth = 10; + if(sTemp.Compare(L"Nov") == 0) nMonth = 11; + if(sTemp.Compare(L"Dec") == 0) nMonth = 12; + + nDay = (int)ParseStringToNumber(wsArray[2]); + nHour = (int)ParseStringToNumber(wsArray[3]); + nMin = (int)ParseStringToNumber(wsArray[4]); + nSec = (int)ParseStringToNumber(wsArray[5]); + nYear = (int)ParseStringToNumber(wsArray[7]); + + double dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime(nHour, nMin, nSec, 0)); + + if (JS_PortIsNan(dRet)) + { + dRet = JS_DateParse(strValue); + } + + return dRet; +} + +//AFDate_KeystrokeEx(cFormat) +FX_BOOL CJS_PublicMethods::AFDate_KeystrokeEx(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if (params.size() != 1) + { + sError = L"AFDate_KeystrokeEx's parameters' size r not correct"; + return FALSE; + } + + if (pEvent->WillCommit()) + { + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString strValue = pEvent->Value(); + if (strValue.IsEmpty()) return TRUE; + + CFX_WideString sFormat = params[0].operator CFX_WideString(); + + FX_BOOL bWrongFormat = FALSE; + double dRet = MakeRegularDate(strValue,sFormat,bWrongFormat); + if (bWrongFormat || JS_PortIsNan(dRet)) + { + CFX_WideString swMsg; + swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE), (FX_LPCWSTR)sFormat); + Alert(pContext, swMsg); + pEvent->Rc() = FALSE; + return TRUE; + } + } + return TRUE; +} + +FX_BOOL CJS_PublicMethods::AFDate_Format(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + + if (params.size() != 1) + { + CJS_Context* pContext = (CJS_Context*)cc; + ASSERT(pContext != NULL); + + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + int iIndex = params[0]; + FX_LPCWSTR cFormats[] = {(FX_LPCWSTR)L"m/d", (FX_LPCWSTR)L"m/d/yy", (FX_LPCWSTR)L"mm/dd/yy", (FX_LPCWSTR)L"mm/yy", (FX_LPCWSTR)L"d-mmm", (FX_LPCWSTR)L"d-mmm-yy", (FX_LPCWSTR)L"dd-mmm-yy", + (FX_LPCWSTR)L"yy-mm-dd", (FX_LPCWSTR)L"mmm-yy", (FX_LPCWSTR)L"mmmm-yy", (FX_LPCWSTR)L"mmm d, yyyy", (FX_LPCWSTR)L"mmmm d, yyyy", + (FX_LPCWSTR)L"m/d/yy h:MM tt", (FX_LPCWSTR)L"m/d/yy HH:MM" }; + + ASSERT(iIndex < sizeof(cFormats)/sizeof(FX_LPCWSTR)); + + if (iIndex < 0) + iIndex = 0; + if (iIndex >= sizeof(cFormats)/sizeof(FX_LPCWSTR)) + iIndex = 0; + CJS_Parameters newParams; + CJS_Value val(isolate,cFormats[iIndex]); + newParams.push_back(val); + return AFDate_FormatEx(cc,newParams,vRet,sError); +} + +//AFDate_KeystrokeEx(cFormat) +FX_BOOL CJS_PublicMethods::AFDate_Keystroke(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + + if (params.size() != 1) + { + CJS_Context* pContext = (CJS_Context*)cc; + ASSERT(pContext != NULL); + + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + int iIndex = params[0]; + FX_LPCWSTR cFormats[] = {(FX_LPCWSTR)L"m/d", (FX_LPCWSTR)L"m/d/yy", (FX_LPCWSTR)L"mm/dd/yy", (FX_LPCWSTR)L"mm/yy", (FX_LPCWSTR)L"d-mmm", (FX_LPCWSTR)L"d-mmm-yy", (FX_LPCWSTR)L"dd-mmm-yy", + (FX_LPCWSTR)L"yy-mm-dd", (FX_LPCWSTR)L"mmm-yy", (FX_LPCWSTR)L"mmmm-yy", (FX_LPCWSTR)L"mmm d, yyyy", (FX_LPCWSTR)L"mmmm d, yyyy", + (FX_LPCWSTR)L"m/d/yy h:MM tt", (FX_LPCWSTR)L"m/d/yy HH:MM" }; + + ASSERT(iIndex= sizeof(cFormats)/sizeof(FX_LPCWSTR)) + iIndex = 0; + CJS_Parameters newParams; + CJS_Value val(isolate,cFormats[iIndex]); + newParams.push_back(val); + return AFDate_KeystrokeEx(cc,newParams,vRet,sError); +} + +//function AFTime_Format(ptf) +FX_BOOL CJS_PublicMethods::AFTime_Format(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + + if (params.size() != 1) + { + CJS_Context* pContext = (CJS_Context*)cc; + ASSERT(pContext != NULL); + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + int iIndex = params[0]; + FX_LPCWSTR cFormats[] = {(FX_LPCWSTR)L"HH:MM", (FX_LPCWSTR)L"h:MM tt", (FX_LPCWSTR)L"HH:MM:ss", (FX_LPCWSTR)L"h:MM:ss tt"}; + + ASSERT(iIndex= sizeof(cFormats)/sizeof(FX_LPCWSTR)) + iIndex = 0; + CJS_Parameters newParams; + CJS_Value val(isolate,cFormats[iIndex]); + newParams.push_back(val); + return AFDate_FormatEx(cc,newParams,vRet,sError); +} + +FX_BOOL CJS_PublicMethods::AFTime_Keystroke(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + if (params.size() != 1) + { + CJS_Context* pContext = (CJS_Context*)cc; + ASSERT(pContext != NULL); + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + int iIndex = params[0]; + FX_LPCWSTR cFormats[] = {(FX_LPCWSTR)L"HH:MM", (FX_LPCWSTR)L"h:MM tt", (FX_LPCWSTR)L"HH:MM:ss", (FX_LPCWSTR)L"h:MM:ss tt"}; + + ASSERT(iIndex= sizeof(cFormats)/sizeof(FX_LPCWSTR)) + iIndex = 0; + CJS_Parameters newParams; + CJS_Value val(isolate,cFormats[iIndex]); + newParams.push_back(val); + return AFDate_KeystrokeEx(cc,newParams,vRet,sError); +} + +FX_BOOL CJS_PublicMethods::AFTime_FormatEx(OBJ_METHOD_PARAMS) +{ + return AFDate_FormatEx(cc,params,vRet,sError); +} + +FX_BOOL CJS_PublicMethods::AFTime_KeystrokeEx(OBJ_METHOD_PARAMS) +{ + return AFDate_KeystrokeEx(cc,params,vRet,sError); +} + +//function AFSpecial_Format(psf) +FX_BOOL CJS_PublicMethods::AFSpecial_Format(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + + if (params.size() != 1) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + std::string cFormat; + int iIndex = params[0]; + + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString& Value = pEvent->Value(); + std::string strSrc = (FX_LPCSTR)CFX_ByteString::FromUnicode(Value); + + switch (iIndex) + { + case 0: + cFormat = "99999"; + break; + case 1: + cFormat = "99999-9999"; + break; + case 2: + { + std::string NumberStr; + util::printx("9999999999", strSrc,NumberStr); + if (NumberStr.length() >= 10 ) + cFormat = "(999) 999-9999"; + else + cFormat = "999-9999"; + break; + } + case 3: + cFormat = "999-99-9999"; + break; + } + + std::string strDes; + util::printx(cFormat,strSrc,strDes); + Value = CFX_WideString::FromLocal(strDes.c_str()); + return TRUE; +} + + +//function AFSpecial_KeystrokeEx(mask) +FX_BOOL CJS_PublicMethods::AFSpecial_KeystrokeEx(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + + ASSERT(pEvent != NULL); + + if (params.size() < 1) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + if(!pEvent->m_pValue) + return FALSE; + CFX_WideString& valEvent = pEvent->Value(); + + CFX_WideString wstrMask = params[0].operator CFX_WideString(); + if (wstrMask.IsEmpty()) return TRUE; + + std::wstring wstrValue(valEvent); + + if (pEvent->WillCommit()) + { + if (wstrValue.empty()) + return TRUE; + int iIndexMask = 0; + for (std::wstring::iterator it = wstrValue.begin(); it != wstrValue.end(); it++) + { + wchar_t w_Value = *it; + if (!maskSatisfied(w_Value,wstrMask[iIndexMask])) + break; + iIndexMask++; + } + + if (iIndexMask != wstrMask.GetLength() || (iIndexMask != wstrValue.size() && wstrMask.GetLength() != 0)) + { + Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSAFNUMBER_KEYSTROKE)); + pEvent->Rc() = FALSE; + } + return TRUE; + } + + + CFX_WideString &wideChange = pEvent->Change(); + std::wstring wChange(wideChange); + + if (wChange.empty()) + return TRUE; + int iIndexMask = pEvent->SelStart(); + //iIndexMask++; + + + if (wstrValue.length() - (pEvent->SelEnd()-pEvent->SelStart()) + wChange.length() > (FX_DWORD)wstrMask.GetLength()) + { + Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG)); + pEvent->Rc() = FALSE; + return TRUE; + } + + + if (iIndexMask >= wstrMask.GetLength() && (!wChange.empty())) + { + Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG)); + pEvent->Rc() = FALSE; + return TRUE; + } + + for (std::wstring::iterator it = wChange.begin(); it != wChange.end(); it++) + { + if (iIndexMask >= wstrMask.GetLength()) + { + Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG)); + pEvent->Rc() = FALSE; + return TRUE; + } + wchar_t w_Mask = wstrMask[iIndexMask]; + if (!isReservedMaskChar(w_Mask)) + { + //wChange.insert(it,w_Mask); + *it = w_Mask; + } + wchar_t w_Change = *it; + + if (!maskSatisfied(w_Change,w_Mask)) + { + pEvent->Rc() = FALSE; + return TRUE; + } + iIndexMask++; + } + + wideChange = wChange.c_str(); + + return TRUE; +} + + +//function AFSpecial_Keystroke(psf) +FX_BOOL CJS_PublicMethods::AFSpecial_Keystroke(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if (params.size() != 1) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + std::string cFormat; + int iIndex = (int)params[0]; + + if(!pEvent->m_pValue) + return FALSE; + //CJS_Value val = pEvent->Value(); + CFX_WideString& val = pEvent->Value(); + std::string strSrc = (FX_LPCSTR)CFX_ByteString::FromUnicode(val); + std::wstring wstrChange(pEvent->Change()); + + switch (iIndex) + { + case 0: + cFormat = "99999"; + break; + case 1: + //cFormat = "99999-9999"; + cFormat = "999999999"; + break; + case 2: + { + std::string NumberStr; + util::printx("9999999999", strSrc,NumberStr); + if (strSrc.length() + wstrChange.length() > 7 ) + //cFormat = "(999) 999-9999"; + cFormat = "9999999999"; + else + //cFormat = "999-9999"; + cFormat = "9999999"; + break; + } + case 3: + //cFormat = "999-99-9999"; + cFormat = "999999999"; + break; + } + + CJS_Parameters params2; + CJS_Value vMask(isolate, cFormat.c_str()); + params2.push_back(vMask); + + return AFSpecial_KeystrokeEx(cc,params2,vRet,sError); +} + +FX_BOOL CJS_PublicMethods::AFMergeChange(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEventHandler = pContext->GetEventHandler(); + ASSERT(pEventHandler != NULL); + + if (params.size() != 1) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + CFX_WideString swValue; + if (pEventHandler->m_pValue != NULL) + swValue = pEventHandler->Value(); + + if (pEventHandler->WillCommit()) + { + vRet = swValue; + return TRUE; + } + + CFX_WideString prefix,postfix; + + if (pEventHandler->SelStart() >= 0) + prefix = swValue.Mid(0,pEventHandler->SelStart()); + else + prefix = L""; + + + if (pEventHandler->SelEnd() >= 0 && pEventHandler->SelEnd() <= swValue.GetLength()) + postfix = swValue.Mid(pEventHandler->SelEnd(), swValue.GetLength() - pEventHandler->SelEnd()); + else postfix = L""; + + vRet = prefix + pEventHandler->Change() + postfix; + + return TRUE; +} + +FX_BOOL CJS_PublicMethods::AFParseDateEx(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + + if (params.size() != 2) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + CFX_WideString sValue = params[0].operator CFX_WideString(); + CFX_WideString sFormat = params[1].operator CFX_WideString(); + + FX_BOOL bWrongFormat = FALSE; + double dDate = MakeRegularDate(sValue,sFormat,bWrongFormat); + + if (JS_PortIsNan(dDate)) + { + CFX_WideString swMsg; + swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE), (FX_LPCWSTR)sFormat); + Alert((CJS_Context *)cc, swMsg); + return FALSE; + } + + vRet = dDate; + + return TRUE; +} + +FX_BOOL CJS_PublicMethods::AFSimple(OBJ_METHOD_PARAMS) +{ + if (params.size() != 3) + { + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + vRet = (double)AF_Simple(params[0].operator CFX_WideString(), (double)params[1], (double)params[2]); + return TRUE; +} + +FX_BOOL CJS_PublicMethods::AFMakeNumber(OBJ_METHOD_PARAMS) +{ + if (params.size() != 1) + { + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + vRet = ParseStringToNumber(params[0].operator CFX_WideString()); + return TRUE; +} + +FX_BOOL CJS_PublicMethods::AFSimple_Calculate(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + + if (params.size() != 2) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + CJS_Value params1 = params[1]; + + if (!params1.IsArrayObject() && params1.GetType() != VT_string) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + CPDFSDK_Document* pReaderDoc = pContext->GetReaderDocument(); + ASSERT(pReaderDoc != NULL); + + CPDFSDK_InterForm* pReaderInterForm = pReaderDoc->GetInterForm(); + ASSERT(pReaderInterForm != NULL); + + CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm(); + ASSERT(pInterForm != NULL); + + double dValue; + CFX_WideString sFunction = params[0].operator CFX_WideString(); + if (wcscmp(sFunction, L"PRD") == 0) + dValue = 1.0; + else + dValue = 0.0; + + CJS_Array FieldNameArray = AF_MakeArrayFromList(isolate,params1); + + int nFieldsCount = 0; + + for (int i=0,isz=FieldNameArray.GetLength(); iCountFields(wsFieldName); jGetField(j, wsFieldName)) + { + double dTemp = 0.0; + + switch (pFormField->GetFieldType()) + { + case FIELDTYPE_TEXTFIELD: + case FIELDTYPE_COMBOBOX: + { + dTemp = ParseStringToNumber(pFormField->GetValue()); + break; + } + case FIELDTYPE_PUSHBUTTON: + { + dTemp = 0.0; + break; + } + case FIELDTYPE_CHECKBOX: + case FIELDTYPE_RADIOBUTTON: + { + dTemp = 0.0; + for (int c=0,csz=pFormField->CountControls(); cGetControl(c)) + { + if (pFormCtrl->IsChecked()) + { + dTemp += ParseStringToNumber(pFormCtrl->GetExportValue()); + break; + } + else + continue; + } + } + break; + } + case FIELDTYPE_LISTBOX: + { + dTemp = 0.0; + if (pFormField->CountSelectedItems() > 1) + break; + else + { + dTemp = ParseStringToNumber(pFormField->GetValue()); + break; + } + } + default: + break; + } + + if (i == 0 && j == 0 && (wcscmp(sFunction,L"MIN") == 0 || wcscmp(sFunction, L"MAX") == 0)) + dValue = dTemp; + + dValue = AF_Simple(sFunction, dValue, dTemp); + + nFieldsCount++; + } + } + } + + if (wcscmp(sFunction, L"AVG") == 0 && nFieldsCount > 0) + dValue /= nFieldsCount; + + dValue = (double)floor(dValue * FXSYS_pow((double)10,(double)6) + 0.49) / FXSYS_pow((double)10,(double)6); + CJS_Value jsValue(isolate,dValue); + if((CJS_EventHandler*)pContext->GetEventHandler()->m_pValue) + ((CJS_EventHandler*)pContext->GetEventHandler())->Value() = jsValue; + + return TRUE; +} + +/* This function validates the current event to ensure that its value is +** within the specified range. */ + +FX_BOOL CJS_PublicMethods::AFRange_Validate(OBJ_METHOD_PARAMS) +{ + CJS_Context* pContext = (CJS_Context *)cc; + ASSERT(pContext != NULL); + CJS_EventHandler* pEvent = pContext->GetEventHandler(); + ASSERT(pEvent != NULL); + + if (params.size() != 4) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + if(!pEvent->m_pValue) + return FALSE; + if (pEvent->Value().IsEmpty() ) + return TRUE; + double dEentValue = atof(CFX_ByteString::FromUnicode(pEvent->Value())); + FX_BOOL bGreaterThan, bLessThan; + double dGreaterThan, dLessThan; + bGreaterThan = (FX_BOOL)params[0]; + CFX_WideString swMsg; + dGreaterThan = (double)params[1]; + bLessThan = (FX_BOOL)params[2]; + dLessThan = (double)params[3]; + + if (bGreaterThan && bLessThan) + { + if (dEentValue < dGreaterThan || dEentValue > dLessThan) + swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE1),(FX_LPCWSTR)params[1].operator CFX_WideString(), (FX_LPCWSTR)params[3].operator CFX_WideString()); + } + else if (bGreaterThan) + { + if (dEentValue < dGreaterThan) + swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE2), (FX_LPCWSTR)params[1].operator CFX_WideString()); + } + else if (bLessThan) + { + if (dEentValue > dLessThan) + swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE3), (FX_LPCWSTR)params[3].operator CFX_WideString()); + } + + if (!swMsg.IsEmpty()) + { + Alert(pContext, swMsg); + pEvent->Rc() = FALSE; + } + return TRUE; +} + +FX_BOOL CJS_PublicMethods::AFExtractNums(OBJ_METHOD_PARAMS) +{ + v8::Isolate* isolate = ::GetIsolate(cc); + CJS_Context* pContext = (CJS_Context*)cc; + ASSERT(pContext != NULL); + + if (params.size() != 1) + { + sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); + return FALSE; + } + + CJS_Array nums(isolate); + + CFX_WideString str = params[0].operator CFX_WideString(); + CFX_WideString sPart; + + if (str.GetAt(0) == L'.' || str.GetAt(0) == L',') + str = L"0" + str; + + int nIndex = 0; + for (int i=0, sz=str.GetLength(); i 0) + { + nums.SetElement(nIndex,CJS_Value(isolate,(FX_LPCWSTR)sPart)); + sPart = L""; + nIndex ++; + } + } + } + + if (sPart.GetLength() > 0) + { + nums.SetElement(nIndex,CJS_Value(isolate,(FX_LPCWSTR)sPart)); + } + + if (nums.GetLength() > 0) + vRet = nums; + else + vRet.SetNull(); + + return TRUE; +} -- cgit v1.2.3