Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(602)

Side by Side Diff: fpdfsdk/src/javascript/PublicMethods.cpp

Issue 1243953004: Re-land else-after-returns (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: Created 5 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « fpdfsdk/src/javascript/JS_Runtime.cpp ('k') | fpdfsdk/src/javascript/global.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 6
7 #include "../../include/javascript/JavaScript.h" 7 #include "../../include/javascript/JavaScript.h"
8 #include "../../include/javascript/IJavaScript.h" 8 #include "../../include/javascript/IJavaScript.h"
9 #include "../../include/javascript/JS_Define.h" 9 #include "../../include/javascript/JS_Define.h"
10 #include "../../include/javascript/JS_Object.h" 10 #include "../../include/javascript/JS_Object.h"
11 #include "../../include/javascript/JS_Value.h" 11 #include "../../include/javascript/JS_Value.h"
12 #include "../../include/javascript/PublicMethods.h" 12 #include "../../include/javascript/PublicMethods.h"
13 #include "../../include/javascript/JS_EventHandler.h" 13 #include "../../include/javascript/JS_EventHandler.h"
14 #include "../../include/javascript/resource.h" 14 #include "../../include/javascript/resource.h"
15 #include "../../include/javascript/JS_Context.h" 15 #include "../../include/javascript/JS_Context.h"
16 #include "../../include/javascript/JS_Value.h" 16 #include "../../include/javascript/JS_Value.h"
17 #include "../../include/javascript/util.h" 17 #include "../../include/javascript/util.h"
18 #include "../../include/javascript/Field.h" 18 #include "../../include/javascript/Field.h"
19 #include "../../include/javascript/color.h" 19 #include "../../include/javascript/color.h"
20 #include "../../include/javascript/JS_Runtime.h" 20 #include "../../include/javascript/JS_Runtime.h"
21 21
22 static v8::Isolate* GetIsolate(IFXJS_Context* cc) 22 static v8::Isolate* GetIsolate(IFXJS_Context* cc)
23 { 23 {
24 » CJS_Context* pContext = (CJS_Context *)cc; 24 CJS_Context* pContext = (CJS_Context *)cc;
25 » ASSERT(pContext != NULL); 25 ASSERT(pContext != NULL);
26 26
27 » CJS_Runtime* pRuntime = pContext->GetJSRuntime(); 27 CJS_Runtime* pRuntime = pContext->GetJSRuntime();
28 » ASSERT(pRuntime != NULL); 28 ASSERT(pRuntime != NULL);
29 29
30 » return pRuntime->GetIsolate(); 30 return pRuntime->GetIsolate();
31 } 31 }
32 32
33 33
34 /* -------------------------------- CJS_PublicMethods -------------------------- ------ */ 34 /* -------------------------------- CJS_PublicMethods -------------------------- ------ */
35 35
36 #define DOUBLE_CORRECT» 0.000000000000001 36 #define DOUBLE_CORRECT 0.000000000000001
37 37
38 BEGIN_JS_STATIC_GLOBAL_FUN(CJS_PublicMethods) 38 BEGIN_JS_STATIC_GLOBAL_FUN(CJS_PublicMethods)
39 » JS_STATIC_GLOBAL_FUN_ENTRY(AFNumber_Format) 39 JS_STATIC_GLOBAL_FUN_ENTRY(AFNumber_Format)
40 » JS_STATIC_GLOBAL_FUN_ENTRY(AFNumber_Keystroke) 40 JS_STATIC_GLOBAL_FUN_ENTRY(AFNumber_Keystroke)
41 » JS_STATIC_GLOBAL_FUN_ENTRY(AFPercent_Format) 41 JS_STATIC_GLOBAL_FUN_ENTRY(AFPercent_Format)
42 » JS_STATIC_GLOBAL_FUN_ENTRY(AFPercent_Keystroke) 42 JS_STATIC_GLOBAL_FUN_ENTRY(AFPercent_Keystroke)
43 » JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_FormatEx) 43 JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_FormatEx)
44 » JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_KeystrokeEx) 44 JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_KeystrokeEx)
45 » JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_Format) 45 JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_Format)
46 » JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_Keystroke) 46 JS_STATIC_GLOBAL_FUN_ENTRY(AFDate_Keystroke)
47 » JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_FormatEx) 47 JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_FormatEx)
48 » JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_KeystrokeEx) 48 JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_KeystrokeEx)
49 » JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_Format) 49 JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_Format)
50 » JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_Keystroke) 50 JS_STATIC_GLOBAL_FUN_ENTRY(AFTime_Keystroke)
51 » JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_Format) 51 JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_Format)
52 » JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_Keystroke) 52 JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_Keystroke)
53 » JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_KeystrokeEx) 53 JS_STATIC_GLOBAL_FUN_ENTRY(AFSpecial_KeystrokeEx)
54 » JS_STATIC_GLOBAL_FUN_ENTRY(AFSimple) 54 JS_STATIC_GLOBAL_FUN_ENTRY(AFSimple)
55 » JS_STATIC_GLOBAL_FUN_ENTRY(AFMakeNumber) 55 JS_STATIC_GLOBAL_FUN_ENTRY(AFMakeNumber)
56 » JS_STATIC_GLOBAL_FUN_ENTRY(AFSimple_Calculate) 56 JS_STATIC_GLOBAL_FUN_ENTRY(AFSimple_Calculate)
57 » JS_STATIC_GLOBAL_FUN_ENTRY(AFRange_Validate) 57 JS_STATIC_GLOBAL_FUN_ENTRY(AFRange_Validate)
58 » JS_STATIC_GLOBAL_FUN_ENTRY(AFMergeChange) 58 JS_STATIC_GLOBAL_FUN_ENTRY(AFMergeChange)
59 » JS_STATIC_GLOBAL_FUN_ENTRY(AFParseDateEx) 59 JS_STATIC_GLOBAL_FUN_ENTRY(AFParseDateEx)
60 » JS_STATIC_GLOBAL_FUN_ENTRY(AFExtractNums) 60 JS_STATIC_GLOBAL_FUN_ENTRY(AFExtractNums)
61 END_JS_STATIC_GLOBAL_FUN() 61 END_JS_STATIC_GLOBAL_FUN()
62 62
63 IMPLEMENT_JS_STATIC_GLOBAL_FUN(CJS_PublicMethods) 63 IMPLEMENT_JS_STATIC_GLOBAL_FUN(CJS_PublicMethods)
64 64
65 static const FX_WCHAR* months[] = 65 static const FX_WCHAR* months[] =
66 { 66 {
67 » L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun", L"Jul", L"Aug", L"Sep", L"Oct", L"Nov", L"Dec" 67 L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun", L"Jul", L"Aug", L"Sep", L"Oc t", L"Nov", L"Dec"
68 }; 68 };
69 69
70 static const FX_WCHAR* fullmonths[] = 70 static const FX_WCHAR* fullmonths[] =
71 { 71 {
72 » L"January", L"February", L"March", L"April", L"May", L"June", L"July", L "August", L"September", L"October", L"November", L"December" 72 L"January", L"February", L"March", L"April", L"May", L"June", L"July", L"Aug ust", L"September", L"October", L"November", L"December"
73 }; 73 };
74 74
75 FX_BOOL CJS_PublicMethods::IsNumber(const FX_WCHAR* string) 75 FX_BOOL CJS_PublicMethods::IsNumber(const FX_WCHAR* string)
76 { 76 {
77 » CFX_WideString sTrim = StrTrim(string); 77 CFX_WideString sTrim = StrTrim(string);
78 » const FX_WCHAR* pTrim = sTrim.c_str(); 78 const FX_WCHAR* pTrim = sTrim.c_str();
79 » const FX_WCHAR* p = pTrim; 79 const FX_WCHAR* p = pTrim;
80 80
81 81
82 » FX_BOOL bDot = FALSE; 82 FX_BOOL bDot = FALSE;
83 » FX_BOOL bKXJS = FALSE; 83 FX_BOOL bKXJS = FALSE;
84 84
85 » wchar_t c; 85 wchar_t c;
86 » while ((c = *p)) 86 while ((c = *p))
87 » { 87 {
88 » » if (c == '.' || c == ',') 88 if (c == '.' || c == ',')
89 » » { 89 {
90 » » » if (bDot) return FALSE; 90 if (bDot) return FALSE;
91 » » » bDot = TRUE; 91 bDot = TRUE;
92 » » } 92 }
93 » » else if (c == '-' || c == '+') 93 else if (c == '-' || c == '+')
94 » » { 94 {
95 » » » if (p != pTrim) 95 if (p != pTrim)
96 » » » » return FALSE; 96 return FALSE;
97 » » } 97 }
98 » » else if (c == 'e' || c == 'E') 98 else if (c == 'e' || c == 'E')
99 » » { 99 {
100 » » » if (bKXJS) return FALSE; 100 if (bKXJS)
101 return FALSE;
101 102
102 » » » p++; 103 p++;
103 » » » c = *p; 104 c = *p;
104 » » » if (c == '+' || c == '-') 105 if (c == '+' || c == '-')
105 » » » { 106 {
106 » » » » bKXJS = TRUE; 107 bKXJS = TRUE;
107 » » » } 108 }
108 » » » else 109 else
109 » » » { 110 {
110 » » » » return FALSE; 111 return FALSE;
111 » » » } 112 }
112 » » } 113 }
113 » » else if (!IsDigit(c)) 114 else if (!IsDigit(c))
114 » » { 115 {
115 » » » return FALSE; 116 return FALSE;
116 » » } 117 }
117 » » p++; 118 p++;
118 » } 119 }
119 120
120 » return TRUE; 121 return TRUE;
121 } 122 }
122 123
123 FX_BOOL CJS_PublicMethods::IsDigit(wchar_t ch) 124 FX_BOOL CJS_PublicMethods::IsDigit(wchar_t ch)
124 { 125 {
125 » return (ch >= L'0' && ch <= L'9'); 126 return (ch >= L'0' && ch <= L'9');
126 } 127 }
127 128
128 FX_BOOL CJS_PublicMethods::IsDigit(char ch) 129 FX_BOOL CJS_PublicMethods::IsDigit(char ch)
129 { 130 {
130 » return (ch >= '0' && ch <= '9'); 131 return (ch >= '0' && ch <= '9');
131 } 132 }
132 133
133 FX_BOOL CJS_PublicMethods::IsAlphabetic(wchar_t ch) 134 FX_BOOL CJS_PublicMethods::IsAlphabetic(wchar_t ch)
134 { 135 {
135 » return ((ch >= L'a' && ch <= L'z') || (ch >= L'A' && ch <= L'Z')); 136 return ((ch >= L'a' && ch <= L'z') || (ch >= L'A' && ch <= L'Z'));
136 } 137 }
137 138
138 FX_BOOL CJS_PublicMethods::IsAlphaNumeric(wchar_t ch) 139 FX_BOOL CJS_PublicMethods::IsAlphaNumeric(wchar_t ch)
139 { 140 {
140 » return (IsDigit(ch) || IsAlphabetic(ch)); 141 return (IsDigit(ch) || IsAlphabetic(ch));
141 } 142 }
142 143
143 FX_BOOL CJS_PublicMethods::maskSatisfied(wchar_t c_Change,wchar_t c_Mask) 144 FX_BOOL CJS_PublicMethods::maskSatisfied(wchar_t c_Change,wchar_t c_Mask)
144 { 145 {
145 » switch (c_Mask) 146 switch (c_Mask)
146 » { 147 {
147 » case L'9': 148 case L'9':
148 return IsDigit(c_Change); 149 return IsDigit(c_Change);
149 case L'A': 150 case L'A':
150 return IsAlphabetic(c_Change); 151 return IsAlphabetic(c_Change);
151 case L'O': 152 case L'O':
152 return IsAlphaNumeric(c_Change); 153 return IsAlphaNumeric(c_Change);
153 case L'X': 154 case L'X':
154 return TRUE; 155 return TRUE;
155 » default: 156 default:
156 return (c_Change == c_Mask); 157 return (c_Change == c_Mask);
157 » } 158 }
158 } 159 }
159 160
160 FX_BOOL CJS_PublicMethods::isReservedMaskChar(wchar_t ch) 161 FX_BOOL CJS_PublicMethods::isReservedMaskChar(wchar_t ch)
161 { 162 {
162 » return ch == L'9' || ch == L'A' || ch == L'O' || ch == L'X'; 163 return ch == L'9' || ch == L'A' || ch == L'O' || ch == L'X';
163 } 164 }
164 165
165 double CJS_PublicMethods::AF_Simple(const FX_WCHAR* sFuction, double dValue1, do uble dValue2) 166 double CJS_PublicMethods::AF_Simple(const FX_WCHAR* sFuction, double dValue1, do uble dValue2)
166 { 167 {
167 » if (FXSYS_wcsicmp(sFuction,L"AVG") == 0 || FXSYS_wcsicmp(sFuction,L"SUM" ) == 0) 168 if (FXSYS_wcsicmp(sFuction,L"AVG") == 0 || FXSYS_wcsicmp(sFuction,L"SUM") == 0)
168 » { 169 {
169 » » return dValue1 + dValue2; 170 return dValue1 + dValue2;
170 » } 171 }
171 » else if (FXSYS_wcsicmp(sFuction, L"PRD") == 0) 172 if (FXSYS_wcsicmp(sFuction, L"PRD") == 0)
172 » { 173 {
173 » » return dValue1 * dValue2; 174 return dValue1 * dValue2;
174 » } 175 }
175 » else if (FXSYS_wcsicmp(sFuction,L"MIN") == 0) 176 if (FXSYS_wcsicmp(sFuction,L"MIN") == 0)
176 » { 177 {
177 » » return FX_MIN(dValue1, dValue2); 178 return FX_MIN(dValue1, dValue2);
178 » } 179 }
179 » else if (FXSYS_wcsicmp(sFuction,L"MAX") == 0) 180 if (FXSYS_wcsicmp(sFuction,L"MAX") == 0)
180 » { 181 {
181 » » return FX_MAX(dValue1, dValue2); 182 return FX_MAX(dValue1, dValue2);
182 » } 183 }
183 184 return dValue1;
184 » return dValue1;
185 } 185 }
186 186
187 CFX_WideString CJS_PublicMethods::StrLTrim(const FX_WCHAR* pStr) 187 CFX_WideString CJS_PublicMethods::StrLTrim(const FX_WCHAR* pStr)
188 { 188 {
189 » while (*pStr && *pStr == L' ') pStr++; 189 while (*pStr && *pStr == L' ') pStr++;
190 190
191 » return pStr; 191 return pStr;
192 } 192 }
193 193
194 CFX_WideString CJS_PublicMethods::StrRTrim(const FX_WCHAR* pStr) 194 CFX_WideString CJS_PublicMethods::StrRTrim(const FX_WCHAR* pStr)
195 { 195 {
196 » const FX_WCHAR* p = pStr; 196 const FX_WCHAR* p = pStr;
197 » while (*p) p++; 197 while (*p) p++;
198 » while (p > pStr && *(p - 1) == L' ') p--; 198 while (p > pStr && *(p - 1) == L' ') p--;
199 199
200 » return CFX_WideString(pStr, p - pStr); 200 return CFX_WideString(pStr, p - pStr);
201 } 201 }
202 202
203 CFX_WideString CJS_PublicMethods::StrTrim(const FX_WCHAR* pStr) 203 CFX_WideString CJS_PublicMethods::StrTrim(const FX_WCHAR* pStr)
204 { 204 {
205 » return StrRTrim(StrLTrim(pStr).c_str()); 205 return StrRTrim(StrLTrim(pStr).c_str());
206 } 206 }
207 207
208 CFX_ByteString CJS_PublicMethods::StrLTrim(const FX_CHAR* pStr) 208 CFX_ByteString CJS_PublicMethods::StrLTrim(const FX_CHAR* pStr)
209 { 209 {
210 » while (*pStr && *pStr == ' ') pStr++; 210 while (*pStr && *pStr == ' ') pStr++;
211 211
212 return pStr; 212 return pStr;
213 } 213 }
214 214
215 CFX_ByteString CJS_PublicMethods::StrRTrim(const FX_CHAR* pStr) 215 CFX_ByteString CJS_PublicMethods::StrRTrim(const FX_CHAR* pStr)
216 { 216 {
217 » const FX_CHAR* p = pStr; 217 const FX_CHAR* p = pStr;
218 » while (*p) p++; 218 while (*p) p++;
219 » while (p > pStr && *(p - 1) == L' ') p--; 219 while (p > pStr && *(p - 1) == L' ') p--;
220 220
221 » return CFX_ByteString(pStr,p-pStr); 221 return CFX_ByteString(pStr,p-pStr);
222 } 222 }
223 223
224 CFX_ByteString CJS_PublicMethods::StrTrim(const FX_CHAR* pStr) 224 CFX_ByteString CJS_PublicMethods::StrTrim(const FX_CHAR* pStr)
225 { 225 {
226 » return StrRTrim(StrLTrim(pStr)); 226 return StrRTrim(StrLTrim(pStr));
227 } 227 }
228 228
229 double CJS_PublicMethods::ParseNumber(const FX_WCHAR* swSource, FX_BOOL& bAllDig its, FX_BOOL& bDot, FX_BOOL& bSign, FX_BOOL& bKXJS) 229 double CJS_PublicMethods::ParseNumber(const FX_WCHAR* swSource, FX_BOOL& bAllDig its, FX_BOOL& bDot, FX_BOOL& bSign, FX_BOOL& bKXJS)
230 { 230 {
231 » bDot = FALSE; 231 bDot = FALSE;
232 » bSign = FALSE; 232 bSign = FALSE;
233 » bKXJS = FALSE; 233 bKXJS = FALSE;
234 234
235 » FX_BOOL bDigitExist = FALSE; 235 FX_BOOL bDigitExist = FALSE;
236 236
237 » const FX_WCHAR* p = swSource; 237 const FX_WCHAR* p = swSource;
238 » wchar_t c; 238 wchar_t c;
239 239
240 » const FX_WCHAR* pStart = NULL; 240 const FX_WCHAR* pStart = NULL;
241 » const FX_WCHAR* pEnd = NULL; 241 const FX_WCHAR* pEnd = NULL;
242 242
243 » while ((c = *p)) 243 while ((c = *p))
244 » { 244 {
245 » » if (!pStart && c != L' ') 245 if (!pStart && c != L' ')
246 » » { 246 {
247 » » » pStart = p; 247 pStart = p;
248 » » } 248 }
249 249
250 » » pEnd = p; 250 pEnd = p;
251 » » p++; 251 p++;
252 » } 252 }
253 253
254 » if (!pStart) 254 if (!pStart)
255 » { 255 {
256 » » bAllDigits = FALSE; 256 bAllDigits = FALSE;
257 » » return 0; 257 return 0;
258 » } 258 }
259 259
260 » while (pEnd != pStart) 260 while (pEnd != pStart)
261 » { 261 {
262 » » if (*pEnd == L' ') 262 if (*pEnd == L' ')
263 » » » pEnd --; 263 pEnd --;
264 » » else 264 else
265 » » » break; 265 break;
266 » } 266 }
267 267
268 » double dRet = 0; 268 double dRet = 0;
269 » p = pStart; 269 p = pStart;
270 » bAllDigits = TRUE; 270 bAllDigits = TRUE;
271 » CFX_WideString swDigits; 271 CFX_WideString swDigits;
272 272
273 » while (p <= pEnd) 273 while (p <= pEnd)
274 » { 274 {
275 » » c = *p; 275 c = *p;
276 276
277 » » if (IsDigit(c)) 277 if (IsDigit(c))
278 » » { 278 {
279 » » » swDigits += c; 279 swDigits += c;
280 » » » bDigitExist = TRUE; 280 bDigitExist = TRUE;
281 » » } 281 }
282 » » else 282 else
283 » » { 283 {
284 » » » switch (c) 284 switch (c)
285 » » » { 285 {
286 » » » case L' ': 286 case L' ':
287 » » » » bAllDigits = FALSE; 287 bAllDigits = FALSE;
288 » » » » break; 288 break;
289 » » » case L'.': 289 case L'.':
290 » » » case L',': 290 case L',':
291 » » » » if (!bDot) 291 if (!bDot)
292 » » » » { 292 {
293 » » » » » if (bDigitExist) 293 if (bDigitExist)
294 » » » » » { 294 {
295 » » » » » » swDigits += L'.'; 295 swDigits += L'.';
296 » » » » » } 296 }
297 » » » » » else 297 else
298 » » » » » { 298 {
299 » » » » » » swDigits += L'0'; 299 swDigits += L'0';
300 » » » » » » swDigits += L'.'; 300 swDigits += L'.';
301 » » » » » » bDigitExist = TRUE; 301 bDigitExist = TRUE;
302 » » » » » } 302 }
303 303
304 » » » » » bDot = TRUE; 304 bDot = TRUE;
305 » » » » » break; 305 break;
306 » » » » } 306 }
307 » » » case 'e': 307 case 'e':
308 » » » case 'E': 308 case 'E':
309 » » » » if (!bKXJS) 309 if (!bKXJS)
310 » » » » { 310 {
311 » » » » » p++; 311 p++;
312 » » » » » c = *p; 312 c = *p;
313 » » » » » if (c == '+' || c == '-') 313 if (c == '+' || c == '-')
314 » » » » » { 314 {
315 » » » » » » bKXJS = TRUE; 315 bKXJS = TRUE;
316 » » » » » » swDigits += 'e'; 316 swDigits += 'e';
317 » » » » » » swDigits += c; 317 swDigits += c;
318 » » » » » } 318 }
319 » » » » » break; 319 break;
320 » » » » } 320 }
321 » » » case L'-': 321 case L'-':
322 » » » » if (!bDigitExist && !bSign) 322 if (!bDigitExist && !bSign)
323 » » » » { 323 {
324 » » » » » swDigits += c; 324 swDigits += c;
325 » » » » » bSign = TRUE; 325 bSign = TRUE;
326 » » » » » break; 326 break;
327 » » » » } 327 }
328 » » » default: 328 default:
329 » » » » bAllDigits = FALSE; 329 bAllDigits = FALSE;
330 330
331 » » » » if (p != pStart && !bDot && bDigitExist) 331 if (p != pStart && !bDot && bDigitExist)
332 » » » » { 332 {
333 » » » » » swDigits += L'.'; 333 swDigits += L'.';
334 » » » » » bDot = TRUE; 334 bDot = TRUE;
335 » » » » } 335 }
336 » » » » else 336 else
337 » » » » { 337 {
338 » » » » » bDot = FALSE; 338 bDot = FALSE;
339 » » » » » bDigitExist = FALSE; 339 bDigitExist = FALSE;
340 » » » » » swDigits = L""; 340 swDigits = L"";
341 » » » » } 341 }
342 » » » » break; 342 break;
343 » » » } 343 }
344 » » } 344 }
345 345
346 » » p++; 346 p++;
347 » } 347 }
348 348
349 » if (swDigits.GetLength() > 0 && swDigits.GetLength() < 17) 349 if (swDigits.GetLength() > 0 && swDigits.GetLength() < 17)
350 » { 350 {
351 » » CFX_ByteString sDigits = swDigits.UTF8Encode(); 351 CFX_ByteString sDigits = swDigits.UTF8Encode();
352 352
353 » » if (bKXJS) 353 if (bKXJS)
354 » » { 354 {
355 » » » dRet = atof(sDigits); 355 dRet = atof(sDigits);
356 » » } 356 }
357 » » else 357 else
358 » » { 358 {
359 » » » if (bDot) 359 if (bDot)
360 » » » { 360 {
361 » » » » char* pStopString; 361 char* pStopString;
362 » » » » dRet = ::strtod(sDigits, &pStopString); 362 dRet = ::strtod(sDigits, &pStopString);
363 » » » } 363 }
364 » » » else 364 else
365 » » » { 365 {
366 » » » » dRet = atol(sDigits); 366 dRet = atol(sDigits);
367 » » » } 367 }
368 » » } 368 }
369 369
370 » } 370 }
371 371
372 » return dRet; 372 return dRet;
373 } 373 }
374 374
375 double CJS_PublicMethods::ParseStringToNumber(const FX_WCHAR* swSource) 375 double CJS_PublicMethods::ParseStringToNumber(const FX_WCHAR* swSource)
376 { 376 {
377 » FX_BOOL bAllDigits = FALSE; 377 FX_BOOL bAllDigits = FALSE;
378 » FX_BOOL bDot = FALSE; 378 FX_BOOL bDot = FALSE;
379 » FX_BOOL bSign = FALSE; 379 FX_BOOL bSign = FALSE;
380 » FX_BOOL bKXJS = FALSE; 380 FX_BOOL bKXJS = FALSE;
381 381
382 » return ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS); 382 return ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS);
383 } 383 }
384 384
385 FX_BOOL»CJS_PublicMethods::ConvertStringToNumber(const FX_WCHAR* swSource, doubl e & dRet, FX_BOOL & bDot) 385 FX_BOOL CJS_PublicMethods::ConvertStringToNumber(const FX_WCHAR* swSource, doubl e & dRet, FX_BOOL & bDot)
386 { 386 {
387 » FX_BOOL bAllDigits = FALSE; 387 FX_BOOL bAllDigits = FALSE;
388 » FX_BOOL bSign = FALSE; 388 FX_BOOL bSign = FALSE;
389 » FX_BOOL bKXJS = FALSE; 389 FX_BOOL bKXJS = FALSE;
390 390
391 » dRet = ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS); 391 dRet = ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS);
392 392
393 » return bAllDigits; 393 return bAllDigits;
394 } 394 }
395 395
396 CJS_Array CJS_PublicMethods::AF_MakeArrayFromList(v8::Isolate* isolate, CJS_Valu e val) 396 CJS_Array CJS_PublicMethods::AF_MakeArrayFromList(v8::Isolate* isolate, CJS_Valu e val)
397 { 397 {
398 » CJS_Array StrArray(isolate); 398 CJS_Array StrArray(isolate);
399 » if(val.IsArrayObject()) 399 if(val.IsArrayObject())
400 » { 400 {
401 » » val.ConvertToArray(StrArray); 401 val.ConvertToArray(StrArray);
402 » » return StrArray; 402 return StrArray;
403 » } 403 }
404 » CFX_WideString wsStr = val.ToCFXWideString(); 404 CFX_WideString wsStr = val.ToCFXWideString();
405 » CFX_ByteString t = CFX_ByteString::FromUnicode(wsStr); 405 CFX_ByteString t = CFX_ByteString::FromUnicode(wsStr);
406 » const char * p = (const char *)t; 406 const char * p = (const char *)t;
407 407
408 408
409 » int ch = ',' ; 409 int ch = ',' ;
410 » int nIndex = 0; 410 int nIndex = 0;
411 411
412 » while (*p) 412 while (*p)
413 » { 413 {
414 » » const char * pTemp = strchr(p, ch); 414 const char * pTemp = strchr(p, ch);
415 » » if (pTemp == NULL) 415 if (pTemp == NULL)
416 » » { 416 {
417 » » » StrArray.SetElement(nIndex, CJS_Value(isolate, StrTrim(p ).c_str())); 417 StrArray.SetElement(nIndex, CJS_Value(isolate, StrTrim(p).c_str()));
418 » » » break; 418 break;
419 » » } 419 }
420 » » else 420 else
421 » » { 421 {
422 » » » char * pSub = new char[pTemp - p + 1]; 422 char * pSub = new char[pTemp - p + 1];
423 » » » strncpy(pSub, p, pTemp - p); 423 strncpy(pSub, p, pTemp - p);
424 » » » *(pSub + (pTemp - p)) = '\0'; 424 *(pSub + (pTemp - p)) = '\0';
425 425
426 » » » StrArray.SetElement(nIndex, CJS_Value(isolate, StrTrim(p Sub).c_str())); 426 StrArray.SetElement(nIndex, CJS_Value(isolate, StrTrim(pSub).c_str() ));
427 » » » delete []pSub; 427 delete []pSub;
428 428
429 » » » nIndex ++; 429 nIndex ++;
430 » » » p = ++pTemp; 430 p = ++pTemp;
431 » » } 431 }
432 432
433 » } 433 }
434 » return StrArray; 434 return StrArray;
435 } 435 }
436 436
437 int CJS_PublicMethods::ParseStringInteger(const CFX_WideString& string,int nStar t,int& nSkip, int nMaxStep) 437 int CJS_PublicMethods::ParseStringInteger(const CFX_WideString& string,int nStar t,int& nSkip, int nMaxStep)
438 { 438 {
439 » int nRet = 0; 439 int nRet = 0;
440 » nSkip = 0; 440 nSkip = 0;
441 » for (int i=nStart, sz=string.GetLength(); i < sz; i++) 441 for (int i=nStart, sz=string.GetLength(); i < sz; i++)
442 » { 442 {
443 » » if (i-nStart > 10) 443 if (i-nStart > 10)
444 » » » break; 444 break;
445 445
446 » » FX_WCHAR c = string.GetAt(i); 446 FX_WCHAR c = string.GetAt(i);
447 » » if (IsDigit((wchar_t)c)) 447 if (IsDigit((wchar_t)c))
448 » » { 448 {
449 » » » nRet = nRet * 10 + (c - '0'); 449 nRet = nRet * 10 + (c - '0');
450 » » » nSkip = i - nStart + 1; 450 nSkip = i - nStart + 1;
451 » » » if (nSkip >= nMaxStep) 451 if (nSkip >= nMaxStep)
452 » » » » break; 452 break;
453 » » } 453 }
454 » » else 454 else
455 » » » break; 455 break;
456 » } 456 }
457 457
458 » return nRet; 458 return nRet;
459 } 459 }
460 460
461 CFX_WideString CJS_PublicMethods::ParseStringString(const CFX_WideString& string , int nStart, int& nSkip) 461 CFX_WideString CJS_PublicMethods::ParseStringString(const CFX_WideString& string , int nStart, int& nSkip)
462 { 462 {
463 » CFX_WideString swRet; 463 CFX_WideString swRet;
464 » nSkip = 0; 464 nSkip = 0;
465 » for (int i=nStart, sz=string.GetLength(); i < sz; i++) 465 for (int i=nStart, sz=string.GetLength(); i < sz; i++)
466 » { 466 {
467 » » FX_WCHAR c = string.GetAt(i); 467 FX_WCHAR c = string.GetAt(i);
468 » » if ((c >= L'a' && c <= L'z') || (c >= L'A' && c <= L'Z')) 468 if ((c >= L'a' && c <= L'z') || (c >= L'A' && c <= L'Z'))
469 » » { 469 {
470 » » » swRet += c; 470 swRet += c;
471 » » » nSkip = i - nStart + 1; 471 nSkip = i - nStart + 1;
472 » » } 472 }
473 » » else 473 else
474 » » » break; 474 break;
475 » } 475 }
476 476
477 » return swRet; 477 return swRet;
478 } 478 }
479 479
480 double CJS_PublicMethods::ParseNormalDate(const CFX_WideString & value, FX_BOOL& bWrongFormat) 480 double CJS_PublicMethods::ParseNormalDate(const CFX_WideString & value, FX_BOOL& bWrongFormat)
481 { 481 {
482 » double dt = JS_GetDateTime(); 482 double dt = JS_GetDateTime();
483 483
484 » int nYear = JS_GetYearFromTime(dt); 484 int nYear = JS_GetYearFromTime(dt);
485 » int nMonth = JS_GetMonthFromTime(dt) + 1; 485 int nMonth = JS_GetMonthFromTime(dt) + 1;
486 » int nDay = JS_GetDayFromTime(dt); 486 int nDay = JS_GetDayFromTime(dt);
487 » int nHour = JS_GetHourFromTime(dt); 487 int nHour = JS_GetHourFromTime(dt);
488 » int nMin = JS_GetMinFromTime(dt); 488 int nMin = JS_GetMinFromTime(dt);
489 » int nSec = JS_GetSecFromTime(dt); 489 int nSec = JS_GetSecFromTime(dt);
490 490
491 » int number[3]; 491 int number[3];
492 492
493 » int nSkip = 0; 493 int nSkip = 0;
494 » int nLen = value.GetLength(); 494 int nLen = value.GetLength();
495 » int nIndex = 0; 495 int nIndex = 0;
496 » int i = 0; 496 int i = 0;
497 » while (i < nLen) 497 while (i < nLen)
498 » { 498 {
499 » » if (nIndex > 2) break; 499 if (nIndex > 2) break;
500 500
501 » » FX_WCHAR c = value.GetAt(i); 501 FX_WCHAR c = value.GetAt(i);
502 » » if (IsDigit((wchar_t)c)) 502 if (IsDigit((wchar_t)c))
503 » » { 503 {
504 » » » number[nIndex++] = ParseStringInteger(value, i, nSkip, 4 ); 504 number[nIndex++] = ParseStringInteger(value, i, nSkip, 4);
505 » » » i += nSkip; 505 i += nSkip;
506 » » } 506 }
507 » » else 507 else
508 » » { 508 {
509 » » » i ++; 509 i ++;
510 » » } 510 }
511 » } 511 }
512 512
513 » if (nIndex == 2) 513 if (nIndex == 2)
514 » { 514 {
515 » » // case2: month/day 515 // case2: month/day
516 » » // case3: day/month 516 // case3: day/month
517 » » if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && nu mber[1] <= 31)) 517 if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && number[1] <= 31))
518 » » { 518 {
519 » » » nMonth = number[0]; 519 nMonth = number[0];
520 » » » nDay = number[1]; 520 nDay = number[1];
521 » » } 521 }
522 » » else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && number[1] <= 12)) 522 else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && numbe r[1] <= 12))
523 » » { 523 {
524 » » » nDay = number[0]; 524 nDay = number[0];
525 » » » nMonth = number[1]; 525 nMonth = number[1];
526 » » } 526 }
527 527
528 » » bWrongFormat = FALSE; 528 bWrongFormat = FALSE;
529 » } 529 }
530 » else if (nIndex == 3) 530 else if (nIndex == 3)
531 » { 531 {
532 » » // case1: year/month/day 532 // case1: year/month/day
533 » » // case2: month/day/year 533 // case2: month/day/year
534 » » // case3: day/month/year 534 // case3: day/month/year
535 535
536 » » if (number[0] > 12 && (number[1] >= 1 && number[1] <= 12) && (nu mber[2] >= 1 && number[2] <= 31)) 536 if (number[0] > 12 && (number[1] >= 1 && number[1] <= 12) && (number[2] >= 1 && number[2] <= 31))
537 » » { 537 {
538 » » » nYear = number[0]; 538 nYear = number[0];
539 » » » nMonth = number[1]; 539 nMonth = number[1];
540 » » » nDay = number[2]; 540 nDay = number[2];
541 » » } 541 }
542 » » else if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && number[1] <= 31) && number[2] > 31) 542 else if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && numbe r[1] <= 31) && number[2] > 31)
543 » » { 543 {
544 » » » nMonth = number[0]; 544 nMonth = number[0];
545 » » » nDay = number[1]; 545 nDay = number[1];
546 » » » nYear = number[2]; 546 nYear = number[2];
547 » » } 547 }
548 » » else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && number[1] <= 12) && number[2] > 31) 548 else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && numbe r[1] <= 12) && number[2] > 31)
549 » » { 549 {
550 » » » nDay = number[0]; 550 nDay = number[0];
551 » » » nMonth = number[1]; 551 nMonth = number[1];
552 » » » nYear = number[2]; 552 nYear = number[2];
553 » » } 553 }
554 554
555 » » bWrongFormat = FALSE; 555 bWrongFormat = FALSE;
556 » } 556 }
557 » else 557 else
558 » { 558 {
559 » » bWrongFormat = TRUE; 559 bWrongFormat = TRUE;
560 » » return dt; 560 return dt;
561 » } 561 }
562 562
563 » CFX_WideString swTemp; 563 CFX_WideString swTemp;
564 » swTemp.Format(L"%d/%d/%d %d:%d:%d",nMonth,nDay,nYear,nHour,nMin,nSec); 564 swTemp.Format(L"%d/%d/%d %d:%d:%d",nMonth,nDay,nYear,nHour,nMin,nSec);
565 » return JS_DateParse(swTemp.c_str()); 565 return JS_DateParse(swTemp.c_str());
566 } 566 }
567 567
568 double CJS_PublicMethods::MakeRegularDate(const CFX_WideString & value, const CF X_WideString & format, FX_BOOL& bWrongFormat) 568 double CJS_PublicMethods::MakeRegularDate(const CFX_WideString & value, const CF X_WideString & format, FX_BOOL& bWrongFormat)
569 { 569 {
570 double dt = JS_GetDateTime(); 570 double dt = JS_GetDateTime();
571 571
572 if (format.IsEmpty() || value.IsEmpty()) 572 if (format.IsEmpty() || value.IsEmpty())
573 return dt; 573 return dt;
574 574
575 int nYear = JS_GetYearFromTime(dt); 575 int nYear = JS_GetYearFromTime(dt);
576 int nMonth = JS_GetMonthFromTime(dt) + 1; 576 int nMonth = JS_GetMonthFromTime(dt) + 1;
577 int nDay = JS_GetDayFromTime(dt); 577 int nDay = JS_GetDayFromTime(dt);
578 int nHour = JS_GetHourFromTime(dt); 578 int nHour = JS_GetHourFromTime(dt);
579 int nMin = JS_GetMinFromTime(dt); 579 int nMin = JS_GetMinFromTime(dt);
580 int nSec = JS_GetSecFromTime(dt); 580 int nSec = JS_GetSecFromTime(dt);
581 581
582 int nYearSub = 99; //nYear - 2000; 582 int nYearSub = 99; //nYear - 2000;
583 583
584 FX_BOOL bPm = FALSE; 584 FX_BOOL bPm = FALSE;
585 FX_BOOL bExit = FALSE; 585 FX_BOOL bExit = FALSE;
586 bWrongFormat = FALSE; 586 bWrongFormat = FALSE;
587 587
588 int i=0; 588 int i=0;
589 int j=0; 589 int j=0;
590 590
591 while (i < format.GetLength()) 591 while (i < format.GetLength())
592 { 592 {
593 if (bExit) break; 593 if (bExit) break;
594 594
595 FX_WCHAR c = format.GetAt(i); 595 FX_WCHAR c = format.GetAt(i);
596 switch (c) 596 switch (c)
597 { 597 {
598 case ':': 598 case ':':
599 case '.': 599 case '.':
600 case '-': 600 case '-':
601 case '\\': 601 case '\\':
602 case '/': 602 case '/':
603 i++; 603 i++;
604 j++; 604 j++;
605 break; 605 break;
606 606
607 case 'y': 607 case 'y':
608 case 'm': 608 case 'm':
609 case 'd': 609 case 'd':
610 case 'H': 610 case 'H':
611 case 'h': 611 case 'h':
612 case 'M': 612 case 'M':
613 case 's': 613 case 's':
614 case 't': 614 case 't':
615 { 615 {
616 int oldj = j; 616 int oldj = j;
617 int nSkip = 0; 617 int nSkip = 0;
618 int remaining = format.GetLength() - i - 1; 618 int remaining = format.GetLength() - i - 1;
619 619
620 if (remaining == 0 || format.GetAt(i+1) != c) 620 if (remaining == 0 || format.GetAt(i+1) != c)
621 { 621 {
622 switch (c) 622 switch (c)
623 { 623 {
624 case 'y': 624 case 'y':
625 i++; 625 i++;
626 j++; 626 j++;
627 break; 627 break;
628 case 'm': 628 case 'm':
629 nMonth = ParseSt ringInteger(value, j, nSkip, 2); 629 nMonth = ParseStringInteger(value, j, nSkip, 2);
630 i++; 630 i++;
631 j += nSkip; 631 j += nSkip;
632 break; 632 break;
633 case 'd': 633 case 'd':
634 nDay = ParseStri ngInteger(value, j, nSkip, 2); 634 nDay = ParseStringInteger(value, j, nSkip, 2);
635 i++; 635 i++;
636 j += nSkip; 636 j += nSkip;
637 break; 637 break;
638 case 'H': 638 case 'H':
639 nHour = ParseStr ingInteger(value, j, nSkip, 2); 639 nHour = ParseStringInteger(value, j, nSkip, 2);
640 i++; 640 i++;
641 j += nSkip; 641 j += nSkip;
642 break; 642 break;
643 case 'h': 643 case 'h':
644 nHour = ParseStr ingInteger(value, j, nSkip, 2); 644 nHour = ParseStringInteger(value, j, nSkip, 2);
645 i++; 645 i++;
646 j += nSkip; 646 j += nSkip;
647 break; 647 break;
648 case 'M': 648 case 'M':
649 nMin = ParseStri ngInteger(value, j, nSkip, 2); 649 nMin = ParseStringInteger(value, j, nSkip, 2);
650 i++; 650 i++;
651 j += nSkip; 651 j += nSkip;
652 break; 652 break;
653 case 's': 653 case 's':
654 nSec = ParseStri ngInteger(value, j, nSkip, 2); 654 nSec = ParseStringInteger(value, j, nSkip, 2);
655 i++; 655 i++;
656 j += nSkip; 656 j += nSkip;
657 break; 657 break;
658 case 't': 658 case 't':
659 bPm = (j < value .GetLength() && value.GetAt(j) == 'p'); 659 bPm = (j < value.GetLength() && value.GetAt(j) = = 'p');
660 i++; 660 i++;
661 j++; 661 j++;
662 break; 662 break;
663 } 663 }
664 } 664 }
665 else if (remaining == 1 || format.GetAt( i+2) != c) 665 else if (remaining == 1 || format.GetAt(i+2) != c)
666 { 666 {
667 switch (c) 667 switch (c)
668 { 668 {
669 case 'y': 669 case 'y':
670 nYear = ParseStr ingInteger(value, j, nSkip, 4); 670 nYear = ParseStringInteger(value, j, nSkip, 4);
671 i += 2; 671 i += 2;
672 j += nSkip; 672 j += nSkip;
673 break; 673 break;
674 case 'm': 674 case 'm':
675 nMonth = ParseSt ringInteger(value, j, nSkip, 2); 675 nMonth = ParseStringInteger(value, j, nSkip, 2);
676 i += 2; 676 i += 2;
677 j += nSkip; 677 j += nSkip;
678 break; 678 break;
679 case 'd': 679 case 'd':
680 nDay = ParseStri ngInteger(value, j, nSkip, 2); 680 nDay = ParseStringInteger(value, j, nSkip, 2);
681 i += 2; 681 i += 2;
682 j += nSkip; 682 j += nSkip;
683 break; 683 break;
684 case 'H': 684 case 'H':
685 nHour = ParseStr ingInteger(value, j, nSkip, 2); 685 nHour = ParseStringInteger(value, j, nSkip, 2);
686 i += 2; 686 i += 2;
687 j += nSkip; 687 j += nSkip;
688 break; 688 break;
689 case 'h': 689 case 'h':
690 nHour = ParseStr ingInteger(value, j, nSkip, 2); 690 nHour = ParseStringInteger(value, j, nSkip, 2);
691 i += 2; 691 i += 2;
692 j += nSkip; 692 j += nSkip;
693 break; 693 break;
694 case 'M': 694 case 'M':
695 nMin = ParseStri ngInteger(value, j, nSkip, 2); 695 nMin = ParseStringInteger(value, j, nSkip, 2);
696 i += 2; 696 i += 2;
697 j += nSkip; 697 j += nSkip;
698 break; 698 break;
699 case 's': 699 case 's':
700 nSec = ParseStri ngInteger(value, j, nSkip, 2); 700 nSec = ParseStringInteger(value, j, nSkip, 2);
701 i += 2; 701 i += 2;
702 j += nSkip; 702 j += nSkip;
703 break; 703 break;
704 case 't': 704 case 't':
705 bPm = (j + 1 < v alue.GetLength() && value.GetAt(j) == 'p' && value.GetAt(j+1) == 'm'); 705 bPm = (j + 1 < value.GetLength() && value.GetAt( j) == 'p' && value.GetAt(j+1) == 'm');
706 i += 2; 706 i += 2;
707 j += 2; 707 j += 2;
708 break; 708 break;
709 } 709 }
710 } 710 }
711 else if (remaining == 2 || format.GetAt( i+3) != c) 711 else if (remaining == 2 || format.GetAt(i+3) != c)
712 { 712 {
713 switch (c) 713 switch (c)
714 { 714 {
715 case 'm': 715 case 'm':
716 { 716 {
717 CFX_Wide String sMonth = ParseStringString(value, j, nSkip); 717 CFX_WideString sMonth = ParseStringString(va lue, j, nSkip);
718 FX_BOOL bFind = FALSE; 718 FX_BOOL bFind = FALSE;
719 for (int m = 0; m < 12; m++) 719 for (int m = 0; m < 12; m++)
720 { 720 {
721 if (sMonth.CompareNoCase(months[m]) == 0) 721 if (sMonth.CompareNoCase(months[m]) == 0 )
722 { 722 {
723 nMonth = m + 1; 723 nMonth = m + 1;
724 i+=3; 724 i+=3;
725 j+=nSkip; 725 j+=nSkip;
726 bFind = TRUE; 726 bFind = TRUE;
727 break; 727 break;
728 } 728 }
729 } 729 }
730 730
731 if (!bFi nd) 731 if (!bFind)
732 { 732 {
733 nMonth = ParseStringInteger(value, j, nSkip, 3); 733 nMonth = ParseStringInteger(value, j, nS kip, 3);
734 i+=3; 734 i+=3;
735 j += nSkip; 735 j += nSkip;
736 } 736 }
737 } 737 }
738 break; 738 break;
739 case 'y': 739 case 'y':
740 break; 740 break;
741 default: 741 default:
742 i+=3; 742 i+=3;
743 j+=3; 743 j+=3;
744 break; 744 break;
745 } 745 }
746 } 746 }
747 else if (remaining == 3 || format.GetAt( i+4) != c) 747 else if (remaining == 3 || format.GetAt(i+4) != c)
748 { 748 {
749 switch (c) 749 switch (c)
750 { 750 {
751 751
752 752
753 case 'y': 753 case 'y':
754 nYear = ParseStr ingInteger(value, j, nSkip, 4); 754 nYear = ParseStringInteger(value, j, nSkip, 4);
755 j += nSkip; 755 j += nSkip;
756 i += 4; 756 i += 4;
757 break; 757 break;
758 case 'm': 758 case 'm':
759 { 759 {
760 FX_BOOL bFind = FALSE; 760 FX_BOOL bFind = FALSE;
761 761
762 CFX_Wide String sMonth = ParseStringString(value, j, nSkip); 762 CFX_WideString sMonth = ParseStringString(va lue, j, nSkip);
763 sMonth.M akeLower(); 763 sMonth.MakeLower();
764 764
765 for (int m = 0; m < 12; m++) 765 for (int m = 0; m < 12; m++)
766 { 766 {
767 CFX_WideString sFullMonths = fullmonths[m]; 767 CFX_WideString sFullMonths = fullmonths[ m];
768 sFullMonths.MakeLower(); 768 sFullMonths.MakeLower();
769 769
770 if (sFullMonths.Find(sMonth.c_str(), 0) != -1) 770 if (sFullMonths.Find(sMonth.c_str(), 0) != -1)
771 { 771 {
772 nMonth = m + 1; 772 nMonth = m + 1;
773 i += 4; 773 i += 4;
774 j += nSkip; 774 j += nSkip;
775 bFind = TRUE; 775 bFind = TRUE;
776 break; 776 break;
777 } 777 }
778 } 778 }
779 779
780 if (!bFi nd) 780 if (!bFind)
781 { 781 {
782 nMonth = ParseStringInteger(value, j, nSkip, 4); 782 nMonth = ParseStringInteger(value, j, nS kip, 4);
783 i+=4; 783 i+=4;
784 j += nSkip; 784 j += nSkip;
785 } 785 }
786 } 786 }
787 break; 787 break;
788 default: 788 default:
789 i += 4; 789 i += 4;
790 j += 4; 790 j += 4;
791 break; 791 break;
792 } 792 }
793 } 793 }
794 else 794 else
795 { 795 {
796 if (j >= value.GetLength() || fo rmat.GetAt(i) != value.GetAt(j)) 796 if (j >= value.GetLength() || format.GetAt(i) != value.G etAt(j))
797 { 797 {
798 bWrongFormat = TRUE; 798 bWrongFormat = TRUE;
799 bExit = TRUE; 799 bExit = TRUE;
800 } 800 }
801 i++; 801 i++;
802 j++; 802 j++;
803 } 803 }
804 804
805 if (oldj == j) 805 if (oldj == j)
806 { 806 {
807 bWrongFormat = TRUE; 807 bWrongFormat = TRUE;
808 bExit = TRUE; 808 bExit = TRUE;
809 } 809 }
810 } 810 }
811 811
812 break; 812 break;
813 default: 813 default:
814 if (value.GetLength() <= j) 814 if (value.GetLength() <= j)
815 { 815 {
816 bExit = TRUE; 816 bExit = TRUE;
817 } 817 }
818 else if (format.GetAt(i) != value.GetAt(j)) 818 else if (format.GetAt(i) != value.GetAt(j))
819 { 819 {
820 bWrongFormat = TRUE; 820 bWrongFormat = TRUE;
821 bExit = TRUE; 821 bExit = TRUE;
822 } 822 }
823 823
824 i++; 824 i++;
825 j++; 825 j++;
826 break; 826 break;
827 } 827 }
828 } 828 }
829 829
830 if (bPm) nHour += 12; 830 if (bPm) nHour += 12;
831 831
832 if (nYear >= 0 && nYear <= nYearSub) 832 if (nYear >= 0 && nYear <= nYearSub)
833 nYear += 2000; 833 nYear += 2000;
834 834
835 if (nMonth < 1 || nMonth > 12) 835 if (nMonth < 1 || nMonth > 12)
836 bWrongFormat = TRUE; 836 bWrongFormat = TRUE;
837 837
838 if (nDay < 1 || nDay > 31) 838 if (nDay < 1 || nDay > 31)
839 bWrongFormat = TRUE; 839 bWrongFormat = TRUE;
840 840
841 if (nHour < 0 || nHour > 24) 841 if (nHour < 0 || nHour > 24)
842 bWrongFormat = TRUE; 842 bWrongFormat = TRUE;
843 843
844 if (nMin < 0 || nMin > 60) 844 if (nMin < 0 || nMin > 60)
845 bWrongFormat = TRUE; 845 bWrongFormat = TRUE;
846 846
847 if (nSec < 0 || nSec > 60) 847 if (nSec < 0 || nSec > 60)
848 bWrongFormat = TRUE; 848 bWrongFormat = TRUE;
849 849
850 double dRet = 0; 850 double dRet = 0;
851 851
852 if (bWrongFormat) 852 if (bWrongFormat)
853 { 853 {
854 dRet = ParseNormalDate(value, bWrongFormat); 854 dRet = ParseNormalDate(value, bWrongFormat);
855 } 855 }
856 else 856 else
857 { 857 {
858 dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime (nHour, nMin, nSec, 0)); 858 dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime(nHour, nMin, nSec, 0));
859 859
860 if (JS_PortIsNan(dRet)) 860 if (JS_PortIsNan(dRet))
861 { 861 {
862 dRet = JS_DateParse(value.c_str()); 862 dRet = JS_DateParse(value.c_str());
863 } 863 }
864 } 864 }
865 865
866 if (JS_PortIsNan(dRet)) 866 if (JS_PortIsNan(dRet))
867 { 867 {
868 dRet = ParseNormalDate(value, bWrongFormat); 868 dRet = ParseNormalDate(value, bWrongFormat);
869 } 869 }
870 870
871 return dRet; 871 return dRet;
872 872
873 } 873 }
874 874
875 CFX_WideString CJS_PublicMethods::MakeFormatDate(double dDate, const CFX_WideStr ing & format) 875 CFX_WideString CJS_PublicMethods::MakeFormatDate(double dDate, const CFX_WideStr ing & format)
876 { 876 {
877 » CFX_WideString sRet = L"",sPart = L""; 877 CFX_WideString sRet = L"",sPart = L"";
878 878
879 » int nYear = JS_GetYearFromTime(dDate); 879 int nYear = JS_GetYearFromTime(dDate);
880 » int nMonth = JS_GetMonthFromTime(dDate) + 1; 880 int nMonth = JS_GetMonthFromTime(dDate) + 1;
881 » int nDay = JS_GetDayFromTime(dDate); 881 int nDay = JS_GetDayFromTime(dDate);
882 » int nHour = JS_GetHourFromTime(dDate); 882 int nHour = JS_GetHourFromTime(dDate);
883 » int nMin = JS_GetMinFromTime(dDate); 883 int nMin = JS_GetMinFromTime(dDate);
884 » int nSec = JS_GetSecFromTime(dDate); 884 int nSec = JS_GetSecFromTime(dDate);
885 885
886 » int i = 0; 886 int i = 0;
887 » while (i < format.GetLength()) 887 while (i < format.GetLength())
888 » { 888 {
889 » FX_WCHAR c = format.GetAt(i); 889 FX_WCHAR c = format.GetAt(i);
890 int remaining = format.GetLength() - i - 1; 890 int remaining = format.GetLength() - i - 1;
891 » » sPart = L""; 891 sPart = L"";
892 » » switch (c) 892 switch (c)
893 » » { 893 {
894 » » » case 'y': 894 case 'y':
895 » » » case 'm': 895 case 'm':
896 » » » case 'd': 896 case 'd':
897 » » » case 'H': 897 case 'H':
898 » » » case 'h': 898 case 'h':
899 » » » case 'M': 899 case 'M':
900 » » » case 's': 900 case 's':
901 » » » case 't': 901 case 't':
902 » » » » if (remaining == 0 || format.GetAt(i+1) != c) 902 if (remaining == 0 || format.GetAt(i+1) != c)
903 » » » » { 903 {
904 » » » » » switch (c) 904 switch (c)
905 » » » » » { 905 {
906 » » » » » » case 'y': 906 case 'y':
907 » » » » » » » sPart += c; 907 sPart += c;
908 » » » » » » » break; 908 break;
909 » » » » » » case 'm': 909 case 'm':
910 » » » » » » » sPart.Format(L"%d",nMont h); 910 sPart.Format(L"%d",nMonth);
911 » » » » » » » break; 911 break;
912 » » » » » » case 'd': 912 case 'd':
913 » » » » » » » sPart.Format(L"%d",nDay) ; 913 sPart.Format(L"%d",nDay);
914 » » » » » » » break; 914 break;
915 » » » » » » case 'H': 915 case 'H':
916 » » » » » » » sPart.Format(L"%d",nHour ); 916 sPart.Format(L"%d",nHour);
917 » » » » » » » break; 917 break;
918 » » » » » » case 'h': 918 case 'h':
919 » » » » » » » sPart.Format(L"%d",nHour >12?nHour - 12:nHour); 919 sPart.Format(L"%d",nHour>12?nHour - 12:nHour);
920 » » » » » » » break; 920 break;
921 » » » » » » case 'M': 921 case 'M':
922 » » » » » » » sPart.Format(L"%d",nMin) ; 922 sPart.Format(L"%d",nMin);
923 » » » » » » » break; 923 break;
924 » » » » » » case 's': 924 case 's':
925 » » » » » » » sPart.Format(L"%d",nSec) ; 925 sPart.Format(L"%d",nSec);
926 » » » » » » » break; 926 break;
927 » » » » » » case 't': 927 case 't':
928 » » » » » » » sPart += nHour>12?'p':'a '; 928 sPart += nHour>12?'p':'a';
929 » » » » » » » break; 929 break;
930 » » » » » } 930 }
931 » » » » » i++; 931 i++;
932 » » » » } 932 }
933 » » » » else if (remaining == 1 || format.GetAt(i+2) != c) 933 else if (remaining == 1 || format.GetAt(i+2) != c)
934 » » » » { 934 {
935 » » » » » switch (c) 935 switch (c)
936 » » » » » { 936 {
937 » » » » » » case 'y': 937 case 'y':
938 » » » » » » » sPart.Format(L"%02d",nYe ar - (nYear / 100) * 100); 938 sPart.Format(L"%02d",nYear - (nYear / 100) * 100);
939 » » » » » » » break; 939 break;
940 » » » » » » case 'm': 940 case 'm':
941 » » » » » » » sPart.Format(L"%02d",nMo nth); 941 sPart.Format(L"%02d",nMonth);
942 » » » » » » » break; 942 break;
943 » » » » » » case 'd': 943 case 'd':
944 » » » » » » » sPart.Format(L"%02d",nDa y); 944 sPart.Format(L"%02d",nDay);
945 » » » » » » » break; 945 break;
946 » » » » » » case 'H': 946 case 'H':
947 » » » » » » » sPart.Format(L"%02d",nHo ur); 947 sPart.Format(L"%02d",nHour);
948 » » » » » » » break; 948 break;
949 » » » » » » case 'h': 949 case 'h':
950 » » » » » » » sPart.Format(L"%02d",nHo ur>12?nHour - 12:nHour); 950 sPart.Format(L"%02d",nHour>12?nHour - 12:nHour);
951 » » » » » » » break; 951 break;
952 » » » » » » case 'M': 952 case 'M':
953 » » » » » » » sPart.Format(L"%02d",nMi n); 953 sPart.Format(L"%02d",nMin);
954 » » » » » » » break; 954 break;
955 » » » » » » case 's': 955 case 's':
956 » » » » » » » sPart.Format(L"%02d",nSe c); 956 sPart.Format(L"%02d",nSec);
957 » » » » » » » break; 957 break;
958 » » » » » » case 't': 958 case 't':
959 » » » » » » » sPart = nHour>12? L"pm": L"am"; 959 sPart = nHour>12? L"pm": L"am";
960 » » » » » » » break; 960 break;
961 » » » » » } 961 }
962 » » » » » i+=2; 962 i+=2;
963 » » » » } 963 }
964 » » » » else if (remaining == 2 || format.GetAt(i+3) != c) 964 else if (remaining == 2 || format.GetAt(i+3) != c)
965 » » » » { 965 {
966 » » » » » switch (c) 966 switch (c)
967 » » » » » { 967 {
968 » » » » » » case 'm': 968 case 'm':
969 » » » » » » » i+=3; 969 i+=3;
970 » » » » » » » if (nMonth > 0&&nMonth < = 12) 970 if (nMonth > 0&&nMonth <= 12)
971 » » » » » » » » sPart += months[ nMonth - 1]; 971 sPart += months[nMonth - 1];
972 » » » » » » » break; 972 break;
973 » » » » » » default: 973 default:
974 » » » » » » » i+=3; 974 i+=3;
975 » » » » » » » sPart += c; 975 sPart += c;
976 » » » » » » » sPart += c; 976 sPart += c;
977 » » » » » » » sPart += c; 977 sPart += c;
978 » » » » » » » break; 978 break;
979 » » » » » } 979 }
980 » » » » } 980 }
981 » » » » else if (remaining == 3 || format.GetAt(i+4) != c) 981 else if (remaining == 3 || format.GetAt(i+4) != c)
982 » » » » { 982 {
983 » » » » » switch (c) 983 switch (c)
984 » » » » » { 984 {
985 » » » » » » case 'y': 985 case 'y':
986 » » » » » » » sPart.Format(L"%04d",nYe ar); 986 sPart.Format(L"%04d",nYear);
987 » » » » » » » i += 4; 987 i += 4;
988 » » » » » » » break; 988 break;
989 » » » » » » case 'm': 989 case 'm':
990 » » » » » » » i+=4; 990 i+=4;
991 » » » » » » » if (nMonth > 0&&nMonth < = 12) 991 if (nMonth > 0&&nMonth <= 12)
992 » » » » » » » » sPart += fullmon ths[nMonth - 1]; 992 sPart += fullmonths[nMonth - 1];
993 » » » » » » » break; 993 break;
994 » » » » » » default: 994 default:
995 » » » » » » » i += 4; 995 i += 4;
996 » » » » » » » sPart += c; 996 sPart += c;
997 » » » » » » » sPart += c; 997 sPart += c;
998 » » » » » » » sPart += c; 998 sPart += c;
999 » » » » » » » sPart += c; 999 sPart += c;
1000 » » » » » » » break; 1000 break;
1001 » » » » » } 1001 }
1002 » » » » } 1002 }
1003 » » » » else 1003 else
1004 » » » » { 1004 {
1005 » » » » » i++; 1005 i++;
1006 » » » » » sPart += c; 1006 sPart += c;
1007 » » » » } 1007 }
1008 » » » » break; 1008 break;
1009 » » » default: 1009 default:
1010 » » » » i++; 1010 i++;
1011 » » » » sPart += c; 1011 sPart += c;
1012 » » » » break; 1012 break;
1013 » » } 1013 }
1014 1014
1015 » » sRet += sPart; 1015 sRet += sPart;
1016 » } 1016 }
1017 1017
1018 » return sRet; 1018 return sRet;
1019 } 1019 }
1020 1020
1021 /* -------------------------------------------------------------------------- */ 1021 /* -------------------------------------------------------------------------- */
1022 1022
1023 //function AFNumber_Format(nDec, sepStyle, negStyle, currStyle, strCurrency, bCu rrencyPrepend) 1023 //function AFNumber_Format(nDec, sepStyle, negStyle, currStyle, strCurrency, bCu rrencyPrepend)
1024 FX_BOOL CJS_PublicMethods::AFNumber_Format(IFXJS_Context* cc, const CJS_Paramete rs& params, CJS_Value& vRet, CFX_WideString& sError) 1024 FX_BOOL CJS_PublicMethods::AFNumber_Format(IFXJS_Context* cc, const CJS_Paramete rs& params, CJS_Value& vRet, CFX_WideString& sError)
1025 { 1025 {
1026 #if _FX_OS_ != _FX_ANDROID_ 1026 #if _FX_OS_ != _FX_ANDROID_
1027 » v8::Isolate* isolate = ::GetIsolate(cc); 1027 v8::Isolate* isolate = ::GetIsolate(cc);
1028 » CJS_Context* pContext = (CJS_Context *)cc; 1028 CJS_Context* pContext = (CJS_Context *)cc;
1029 » ASSERT(pContext != NULL); 1029 ASSERT(pContext != NULL);
1030 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1030 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1031 » ASSERT(pEvent != NULL); 1031 ASSERT(pEvent != NULL);
1032 1032
1033 » if (params.size() != 6) 1033 if (params.size() != 6)
1034 » { 1034 {
1035 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1035 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1036 » » return FALSE; 1036 return FALSE;
1037 » } 1037 }
1038 » if(!pEvent->m_pValue) 1038 if(!pEvent->m_pValue)
1039 » » return FALSE; 1039 return FALSE;
1040 » CFX_WideString& Value = pEvent->Value(); 1040 CFX_WideString& Value = pEvent->Value();
1041 » CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value)); 1041 CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value));
1042 1042
1043 » if (strValue.IsEmpty()) return TRUE; 1043 if (strValue.IsEmpty()) return TRUE;
1044 1044
1045 » int iDec = params[0].ToInt(); 1045 int iDec = params[0].ToInt();
1046 » int iSepStyle = params[1].ToInt(); 1046 int iSepStyle = params[1].ToInt();
1047 » int iNegStyle = params[2].ToInt(); 1047 int iNegStyle = params[2].ToInt();
1048 » // params[3] is iCurrStyle, it's not used. 1048 // params[3] is iCurrStyle, it's not used.
1049 » std::wstring wstrCurrency(params[4].ToCFXWideString().c_str()); 1049 std::wstring wstrCurrency(params[4].ToCFXWideString().c_str());
1050 » FX_BOOL bCurrencyPrepend = params[5].ToBool(); 1050 FX_BOOL bCurrencyPrepend = params[5].ToBool();
1051 1051
1052 » if (iDec < 0) iDec = -iDec; 1052 if (iDec < 0) iDec = -iDec;
1053 1053
1054 » if (iSepStyle < 0 || iSepStyle > 3) 1054 if (iSepStyle < 0 || iSepStyle > 3)
1055 » » iSepStyle = 0; 1055 iSepStyle = 0;
1056 1056
1057 » if (iNegStyle < 0 || iNegStyle > 3) 1057 if (iNegStyle < 0 || iNegStyle > 3)
1058 » » iNegStyle = 0; 1058 iNegStyle = 0;
1059 1059
1060 1060
1061 » ////////////////////////////////////////////////////// 1061 //////////////////////////////////////////////////////
1062 » //for processing decimal places 1062 //for processing decimal places
1063 » strValue.Replace(",", "."); 1063 strValue.Replace(",", ".");
1064 » double dValue = atof(strValue); 1064 double dValue = atof(strValue);
1065 » if (iDec > 0) 1065 if (iDec > 0)
1066 » » dValue += DOUBLE_CORRECT; 1066 dValue += DOUBLE_CORRECT;
1067 1067
1068 » int iDec2; 1068 int iDec2;
1069 » FX_BOOL bNegative = FALSE; 1069 FX_BOOL bNegative = FALSE;
1070 1070
1071 » strValue = fcvt(dValue,iDec,&iDec2,&bNegative); 1071 strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
1072 » if (strValue.IsEmpty()) 1072 if (strValue.IsEmpty())
1073 » { 1073 {
1074 » » dValue = 0; 1074 dValue = 0;
1075 » » strValue = fcvt(dValue,iDec,&iDec2,&bNegative); 1075 strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
1076 » » if (strValue.IsEmpty()) 1076 if (strValue.IsEmpty())
1077 » » { 1077 {
1078 » » » strValue = "0"; 1078 strValue = "0";
1079 » » » iDec2 = 1; 1079 iDec2 = 1;
1080 » » } 1080 }
1081 1081
1082 » } 1082 }
1083 1083
1084 » if (iDec2 < 0) 1084 if (iDec2 < 0)
1085 » { 1085 {
1086 » » for (int iNum = 0;iNum < abs(iDec2);iNum++) 1086 for (int iNum = 0;iNum < abs(iDec2);iNum++)
1087 » » { 1087 {
1088 » » » strValue = "0" + strValue; 1088 strValue = "0" + strValue;
1089 » » } 1089 }
1090 » » iDec2 = 0; 1090 iDec2 = 0;
1091 1091
1092 » } 1092 }
1093 » int iMax = strValue.GetLength(); 1093 int iMax = strValue.GetLength();
1094 » if (iDec2 > iMax) 1094 if (iDec2 > iMax)
1095 » { 1095 {
1096 » » for (int iNum = 0;iNum <= iDec2 - iMax ;iNum++) 1096 for (int iNum = 0;iNum <= iDec2 - iMax ;iNum++)
1097 » » { 1097 {
1098 » » » strValue += "0"; 1098 strValue += "0";
1099 » » } 1099 }
1100 » » iMax = iDec2+1; 1100 iMax = iDec2+1;
1101 » } 1101 }
1102 » /////////////////////////////////////////////////////// 1102 ///////////////////////////////////////////////////////
1103 //for processing seperator style 1103 //for processing seperator style
1104 » if (iDec2 < iMax) 1104 if (iDec2 < iMax)
1105 » { 1105 {
1106 » » if (iSepStyle == 0 || iSepStyle == 1) 1106 if (iSepStyle == 0 || iSepStyle == 1)
1107 » » { 1107 {
1108 » » » strValue.Insert(iDec2, '.'); 1108 strValue.Insert(iDec2, '.');
1109 » » » iMax++; 1109 iMax++;
1110 » » } 1110 }
1111 » » else if (iSepStyle == 2 || iSepStyle == 3) 1111 else if (iSepStyle == 2 || iSepStyle == 3)
1112 » » { 1112 {
1113 » » » strValue.Insert(iDec2, ','); 1113 strValue.Insert(iDec2, ',');
1114 » » » iMax++; 1114 iMax++;
1115 » » } 1115 }
1116 1116
1117 » » if (iDec2 == 0) 1117 if (iDec2 == 0)
1118 » » » strValue.Insert(iDec2, '0'); 1118 strValue.Insert(iDec2, '0');
1119 » } 1119 }
1120 » if (iSepStyle == 0 || iSepStyle == 2) 1120 if (iSepStyle == 0 || iSepStyle == 2)
1121 » { 1121 {
1122 » » char cSeperator; 1122 char cSeperator;
1123 » » if (iSepStyle == 0) 1123 if (iSepStyle == 0)
1124 » » » cSeperator = ','; 1124 cSeperator = ',';
1125 » » else 1125 else
1126 » » » cSeperator = '.'; 1126 cSeperator = '.';
1127 1127
1128 » » int iDecPositive; 1128 int iDecPositive;
1129 » » iDecPositive = iDec2; 1129 iDecPositive = iDec2;
1130 1130
1131 » » for (iDecPositive = iDec2 -3; iDecPositive > 0;iDecPositive -= 3 ) 1131 for (iDecPositive = iDec2 -3; iDecPositive > 0;iDecPositive -= 3)
1132 » » { 1132 {
1133 » » » strValue.Insert(iDecPositive, cSeperator); 1133 strValue.Insert(iDecPositive, cSeperator);
1134 » » » iMax++; 1134 iMax++;
1135 » » } 1135 }
1136 » } 1136 }
1137 1137
1138 » ////////////////////////////////////////////////////////////////////// 1138 //////////////////////////////////////////////////////////////////////
1139 //for processing currency string 1139 //for processing currency string
1140 1140
1141 » Value = CFX_WideString::FromLocal(strValue); 1141 Value = CFX_WideString::FromLocal(strValue);
1142 » std::wstring strValue2 = Value.c_str(); 1142 std::wstring strValue2 = Value.c_str();
1143 1143
1144 » if (bCurrencyPrepend) 1144 if (bCurrencyPrepend)
1145 » » strValue2 = wstrCurrency + strValue2; 1145 strValue2 = wstrCurrency + strValue2;
1146 » else 1146 else
1147 » » strValue2 = strValue2 + wstrCurrency; 1147 strValue2 = strValue2 + wstrCurrency;
1148 1148
1149 1149
1150 1150
1151 » //////////////////////////////////////////////////////////////////////// / 1151 /////////////////////////////////////////////////////////////////////////
1152 » //for processing negative style 1152 //for processing negative style
1153 » if (bNegative) 1153 if (bNegative)
1154 » { 1154 {
1155 » » if (iNegStyle == 0) 1155 if (iNegStyle == 0)
1156 » » { 1156 {
1157 » » » strValue2.insert(0,L"-"); 1157 strValue2.insert(0,L"-");
1158 » » } 1158 }
1159 » » if (iNegStyle == 2 || iNegStyle == 3) 1159 if (iNegStyle == 2 || iNegStyle == 3)
1160 » » { 1160 {
1161 » » » strValue2.insert(0,L"("); 1161 strValue2.insert(0,L"(");
1162 » » » strValue2.insert(strValue2.length(),L")"); 1162 strValue2.insert(strValue2.length(),L")");
1163 » » } 1163 }
1164 » » if (iNegStyle == 1 || iNegStyle == 3) 1164 if (iNegStyle == 1 || iNegStyle == 3)
1165 » » { 1165 {
1166 » » » if (Field * fTarget = pEvent->Target_Field()) 1166 if (Field * fTarget = pEvent->Target_Field())
1167 » » » { 1167 {
1168 » » » » CJS_Array arColor(isolate); 1168 CJS_Array arColor(isolate);
1169 » » » » CJS_Value vColElm(isolate); 1169 CJS_Value vColElm(isolate);
1170 » » » » vColElm = L"RGB"; 1170 vColElm = L"RGB";
1171 » » » » arColor.SetElement(0,vColElm); 1171 arColor.SetElement(0,vColElm);
1172 » » » » vColElm = 1; 1172 vColElm = 1;
1173 » » » » arColor.SetElement(1,vColElm); 1173 arColor.SetElement(1,vColElm);
1174 » » » » vColElm = 0; 1174 vColElm = 0;
1175 » » » » arColor.SetElement(2,vColElm); 1175 arColor.SetElement(2,vColElm);
1176 1176
1177 » » » » arColor.SetElement(3,vColElm); 1177 arColor.SetElement(3,vColElm);
1178 1178
1179 » » » » CJS_PropValue vProp(isolate); 1179 CJS_PropValue vProp(isolate);
1180 » » » » vProp.StartGetting(); 1180 vProp.StartGetting();
1181 » » » » vProp<<arColor; 1181 vProp<<arColor;
1182 » » » » vProp.StartSetting(); 1182 vProp.StartSetting();
1183 » » » » fTarget->textColor(cc,vProp,sError);// red 1183 fTarget->textColor(cc,vProp,sError);// red
1184 » » » } 1184 }
1185 » » } 1185 }
1186 » } 1186 }
1187 » else 1187 else
1188 » { 1188 {
1189 » » if (iNegStyle == 1 || iNegStyle == 3) 1189 if (iNegStyle == 1 || iNegStyle == 3)
1190 » » { 1190 {
1191 » » » if (Field *fTarget = pEvent->Target_Field()) 1191 if (Field *fTarget = pEvent->Target_Field())
1192 » » » { 1192 {
1193 » » » » CJS_Array arColor(isolate); 1193 CJS_Array arColor(isolate);
1194 » » » » CJS_Value vColElm(isolate); 1194 CJS_Value vColElm(isolate);
1195 » » » » vColElm = L"RGB"; 1195 vColElm = L"RGB";
1196 » » » » arColor.SetElement(0,vColElm); 1196 arColor.SetElement(0,vColElm);
1197 » » » » vColElm = 0; 1197 vColElm = 0;
1198 » » » » arColor.SetElement(1,vColElm); 1198 arColor.SetElement(1,vColElm);
1199 » » » » arColor.SetElement(2,vColElm); 1199 arColor.SetElement(2,vColElm);
1200 » » » » arColor.SetElement(3,vColElm); 1200 arColor.SetElement(3,vColElm);
1201 1201
1202 » » » » CJS_PropValue vProp(isolate); 1202 CJS_PropValue vProp(isolate);
1203 » » » » vProp.StartGetting(); 1203 vProp.StartGetting();
1204 » » » » fTarget->textColor(cc,vProp,sError); 1204 fTarget->textColor(cc,vProp,sError);
1205 1205
1206 » » » » CJS_Array aProp(isolate); 1206 CJS_Array aProp(isolate);
1207 » » » » vProp.ConvertToArray(aProp); 1207 vProp.ConvertToArray(aProp);
1208 1208
1209 » » » » CPWL_Color crProp; 1209 CPWL_Color crProp;
1210 » » » » CPWL_Color crColor; 1210 CPWL_Color crColor;
1211 » » » » color::ConvertArrayToPWLColor(aProp, crProp); 1211 color::ConvertArrayToPWLColor(aProp, crProp);
1212 » » » » color::ConvertArrayToPWLColor(arColor, crColor); 1212 color::ConvertArrayToPWLColor(arColor, crColor);
1213 1213
1214 » » » » if (crColor != crProp) 1214 if (crColor != crProp)
1215 » » » » { 1215 {
1216 » » » » » CJS_PropValue vProp2(isolate); 1216 CJS_PropValue vProp2(isolate);
1217 » » » » » vProp2.StartGetting(); 1217 vProp2.StartGetting();
1218 » » » » » vProp2<<arColor; 1218 vProp2<<arColor;
1219 » » » » » vProp2.StartSetting(); 1219 vProp2.StartSetting();
1220 » » » » fTarget->textColor(cc,vProp2,sError); 1220 fTarget->textColor(cc,vProp2,sError);
1221 » » » » } 1221 }
1222 » » » } 1222 }
1223 » » } 1223 }
1224 » } 1224 }
1225 » Value = strValue2.c_str(); 1225 Value = strValue2.c_str();
1226 #endif 1226 #endif
1227 » return TRUE; 1227 return TRUE;
1228 } 1228 }
1229 1229
1230 //function AFNumber_Keystroke(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend) 1230 //function AFNumber_Keystroke(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend)
1231 FX_BOOL CJS_PublicMethods::AFNumber_Keystroke(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError) 1231 FX_BOOL CJS_PublicMethods::AFNumber_Keystroke(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError)
1232 { 1232 {
1233 » CJS_Context* pContext = (CJS_Context *)cc; 1233 CJS_Context* pContext = (CJS_Context *)cc;
1234 » ASSERT(pContext != NULL); 1234 ASSERT(pContext != NULL);
1235 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1235 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1236 » ASSERT(pEvent != NULL); 1236 ASSERT(pEvent != NULL);
1237 1237
1238 » if(params.size() < 2) 1238 if(params.size() < 2)
1239 » » return FALSE; 1239 return FALSE;
1240 » int iSepStyle = params[1].ToInt(); 1240 int iSepStyle = params[1].ToInt();
1241 1241
1242 » if (iSepStyle < 0 || iSepStyle > 3) 1242 if (iSepStyle < 0 || iSepStyle > 3)
1243 » » iSepStyle = 0; 1243 iSepStyle = 0;
1244 » if(!pEvent->m_pValue) 1244 if(!pEvent->m_pValue)
1245 » » return FALSE; 1245 return FALSE;
1246 » CFX_WideString & val = pEvent->Value(); 1246 CFX_WideString & val = pEvent->Value();
1247 » CFX_WideString & w_strChange = pEvent->Change(); 1247 CFX_WideString & w_strChange = pEvent->Change();
1248 CFX_WideString w_strValue = val; 1248 CFX_WideString w_strValue = val;
1249 1249
1250 » if (pEvent->WillCommit()) 1250 if (pEvent->WillCommit())
1251 » { 1251 {
1252 » » CFX_WideString wstrChange = w_strChange; 1252 CFX_WideString wstrChange = w_strChange;
1253 » » CFX_WideString wstrValue = StrLTrim(w_strValue.c_str()); 1253 CFX_WideString wstrValue = StrLTrim(w_strValue.c_str());
1254 » » if (wstrValue.IsEmpty()) 1254 if (wstrValue.IsEmpty())
1255 » » » return TRUE; 1255 return TRUE;
1256 1256
1257 » » CFX_WideString swTemp = wstrValue; 1257 CFX_WideString swTemp = wstrValue;
1258 » » swTemp.Replace(L",", L"."); 1258 swTemp.Replace(L",", L".");
1259 » » if (!IsNumber(swTemp.c_str())) 1259 if (!IsNumber(swTemp.c_str()))
1260 » » { 1260 {
1261 » » » pEvent->Rc() = FALSE; 1261 pEvent->Rc() = FALSE;
1262 » » » sError = JSGetStringFromID(pContext, IDS_STRING_JSAFNUMB ER_KEYSTROKE); 1262 sError = JSGetStringFromID(pContext, IDS_STRING_JSAFNUMBER_KEYSTROKE );
1263 » » » Alert(pContext, sError.c_str()); 1263 Alert(pContext, sError.c_str());
1264 » » » return TRUE; 1264 return TRUE;
1265 » » } 1265 }
1266 » » return TRUE; // it happens after the last keystroke and before v alidating, 1266 return TRUE; // it happens after the last keystroke and before validatin g,
1267 » } 1267 }
1268 1268
1269 » std::wstring w_strValue2 = w_strValue.c_str(); 1269 std::wstring w_strValue2 = w_strValue.c_str();
1270 » std::wstring w_strChange2 = w_strChange.c_str(); 1270 std::wstring w_strChange2 = w_strChange.c_str();
1271 » std::wstring w_strSelected; 1271 std::wstring w_strSelected;
1272 » if(-1 != pEvent->SelStart()) 1272 if(-1 != pEvent->SelStart())
1273 » » w_strSelected = w_strValue2.substr(pEvent->SelStart(),(pEvent->S elEnd() - pEvent->SelStart())); 1273 w_strSelected = w_strValue2.substr(pEvent->SelStart(),(pEvent->SelEnd() - pEvent->SelStart()));
1274 » FX_BOOL bHasSign = (w_strValue2.find('-') != -1) && (w_strSelected.find( '-') == -1); 1274 FX_BOOL bHasSign = (w_strValue2.find('-') != -1) && (w_strSelected.find('-') == -1);
1275 » if (bHasSign) 1275 if (bHasSign)
1276 » { 1276 {
1277 » » //can't insert "change" in front to sign postion. 1277 //can't insert "change" in front to sign postion.
1278 » » if (pEvent->SelStart() == 0) 1278 if (pEvent->SelStart() == 0)
1279 » » { 1279 {
1280 FX_BOOL &bRc = pEvent->Rc(); 1280 FX_BOOL &bRc = pEvent->Rc();
1281 » » » bRc = FALSE; 1281 bRc = FALSE;
1282 » » » return TRUE; 1282 return TRUE;
1283 » » } 1283 }
1284 » } 1284 }
1285 1285
1286 » char cSep = L'.'; 1286 char cSep = L'.';
1287 1287
1288 » switch (iSepStyle) 1288 switch (iSepStyle)
1289 » { 1289 {
1290 » case 0: 1290 case 0:
1291 » case 1: 1291 case 1:
1292 » » cSep = L'.'; 1292 cSep = L'.';
1293 » » break; 1293 break;
1294 » case 2: 1294 case 2:
1295 » case 3: 1295 case 3:
1296 » » cSep = L','; 1296 cSep = L',';
1297 » » break; 1297 break;
1298 » } 1298 }
1299 1299
1300 » FX_BOOL bHasSep = (w_strValue2.find(cSep) != -1); 1300 FX_BOOL bHasSep = (w_strValue2.find(cSep) != -1);
1301 » for (std::wstring::iterator it = w_strChange2.begin(); it != w_strChange 2.end(); it++) 1301 for (std::wstring::iterator it = w_strChange2.begin(); it != w_strChange2.en d(); it++)
1302 » { 1302 {
1303 » » if (*it == cSep) 1303 if (*it == cSep)
1304 » » { 1304 {
1305 » » » if (bHasSep) 1305 if (bHasSep)
1306 » » » { 1306 {
1307 » » » » FX_BOOL &bRc = pEvent->Rc(); 1307 FX_BOOL &bRc = pEvent->Rc();
1308 » » » » bRc = FALSE; 1308 bRc = FALSE;
1309 » » » » return TRUE; 1309 return TRUE;
1310 » » » } 1310 }
1311 » » » else 1311 bHasSep = TRUE;
1312 » » » { 1312 continue;
1313 » » » » bHasSep = TRUE; 1313 }
1314 » » » » continue; 1314 if (*it == L'-')
1315 » » » } 1315 {
1316 » » } 1316 if (bHasSign)
1317 » » if (*it == L'-') 1317 {
1318 » » { 1318 FX_BOOL &bRc = pEvent->Rc();
1319 » » » if (bHasSign) 1319 bRc = FALSE;
1320 » » » { 1320 return TRUE;
1321 » » » » FX_BOOL &bRc = pEvent->Rc(); 1321 }
1322 » » » » bRc = FALSE; 1322 if (it != w_strChange2.begin()) //sign's position is not correct
1323 » » » » return TRUE; 1323 {
1324 » » » } 1324 FX_BOOL &bRc = pEvent->Rc();
1325 » » » else if (it != w_strChange2.begin()) //sign's position i s not correct 1325 bRc = FALSE;
1326 » » » { 1326 return TRUE;
1327 » » » » FX_BOOL &bRc = pEvent->Rc(); 1327 }
1328 » » » » bRc = FALSE; 1328 if (pEvent->SelStart() != 0)
1329 » » » » return TRUE; 1329 {
1330 » » » } 1330 FX_BOOL &bRc = pEvent->Rc();
1331 » » » else if (pEvent->SelStart() != 0) 1331 bRc = FALSE;
1332 » » » { 1332 return TRUE;
1333 » » » » FX_BOOL &bRc = pEvent->Rc(); 1333 }
1334 » » » » bRc = FALSE; 1334 bHasSign = TRUE;
1335 » » » » return TRUE; 1335 continue;
1336 » » » } 1336 }
1337 » » » bHasSign = TRUE; 1337
1338 » » » continue; 1338 if (!IsDigit(*it))
1339 » » } 1339 {
1340 1340 FX_BOOL &bRc = pEvent->Rc();
1341 » » if (!IsDigit(*it)) 1341 bRc = FALSE;
1342 » » { 1342 return TRUE;
1343 » » » FX_BOOL &bRc = pEvent->Rc(); 1343 }
1344 » » » bRc = FALSE; 1344 }
1345 » » » return TRUE; 1345
1346 » » } 1346
1347 » } 1347 std::wstring w_prefix = w_strValue2.substr(0,pEvent->SelStart());
1348 1348 std::wstring w_postfix;
1349 1349 if (pEvent->SelEnd()<(int)w_strValue2.length())
1350 » std::wstring w_prefix = w_strValue2.substr(0,pEvent->SelStart()); 1350 w_postfix = w_strValue2.substr(pEvent->SelEnd());
1351 » std::wstring w_postfix; 1351 w_strValue2 = w_prefix + w_strChange2 + w_postfix;
1352 » if (pEvent->SelEnd()<(int)w_strValue2.length()) 1352 w_strValue = w_strValue2.c_str();
1353 » » w_postfix = w_strValue2.substr(pEvent->SelEnd()); 1353 val = w_strValue;
1354 » w_strValue2 = w_prefix + w_strChange2 + w_postfix; 1354 return TRUE;
1355 » w_strValue = w_strValue2.c_str();
1356 » val = w_strValue;
1357 » return TRUE;
1358 1355
1359 } 1356 }
1360 1357
1361 //function AFPercent_Format(nDec, sepStyle) 1358 //function AFPercent_Format(nDec, sepStyle)
1362 FX_BOOL CJS_PublicMethods::AFPercent_Format(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError) 1359 FX_BOOL CJS_PublicMethods::AFPercent_Format(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError)
1363 { 1360 {
1364 #if _FX_OS_ != _FX_ANDROID_ 1361 #if _FX_OS_ != _FX_ANDROID_
1365 » CJS_Context* pContext = (CJS_Context *)cc; 1362 CJS_Context* pContext = (CJS_Context *)cc;
1366 » ASSERT(pContext != NULL); 1363 ASSERT(pContext != NULL);
1367 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1364 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1368 » ASSERT(pEvent != NULL); 1365 ASSERT(pEvent != NULL);
1369 1366
1370 if (params.size() != 2) 1367 if (params.size() != 2)
1371 » { 1368 {
1372 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1369 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1373 » » return FALSE; 1370 return FALSE;
1374 » } 1371 }
1375 » if(!pEvent->m_pValue) 1372 if(!pEvent->m_pValue)
1376 » » return FALSE; 1373 return FALSE;
1377 1374
1378 » CFX_WideString& Value = pEvent->Value(); 1375 CFX_WideString& Value = pEvent->Value();
1379 » CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value)); 1376 CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value));
1380 » if (strValue.IsEmpty())
1381 » » return TRUE;
1382
1383 » int iDec = params[0].ToInt();
1384 » if (iDec < 0)
1385 » » iDec = -iDec;
1386
1387 » int iSepStyle = params[1].ToInt();
1388 » if (iSepStyle < 0 || iSepStyle > 3)
1389 » » iSepStyle = 0;
1390
1391 » //////////////////////////////////////////////////////
1392 » //for processing decimal places
1393 » double dValue = atof(strValue);
1394 » dValue *= 100;
1395 » if (iDec > 0)
1396 » » dValue += DOUBLE_CORRECT;//УÕý
1397
1398 » int iDec2;
1399 » FX_BOOL bNegative = FALSE;
1400 » strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
1401 if (strValue.IsEmpty()) 1377 if (strValue.IsEmpty())
1402 » { 1378 return TRUE;
1403 » » dValue = 0; 1379
1404 » » strValue = fcvt(dValue,iDec,&iDec2,&bNegative); 1380 int iDec = params[0].ToInt();
1405 » } 1381 if (iDec < 0)
1406 1382 iDec = -iDec;
1407 » if (iDec2 < 0) 1383
1408 » { 1384 int iSepStyle = params[1].ToInt();
1409 » » for (int iNum = 0; iNum < abs(iDec2); iNum++) 1385 if (iSepStyle < 0 || iSepStyle > 3)
1410 » » { 1386 iSepStyle = 0;
1411 » » » strValue = "0" + strValue; 1387
1412 » » } 1388 //////////////////////////////////////////////////////
1413 » » iDec2 = 0; 1389 //for processing decimal places
1414 1390 double dValue = atof(strValue);
1415 » } 1391 dValue *= 100;
1416 » int iMax = strValue.GetLength(); 1392 if (iDec > 0)
1417 » if (iDec2 > iMax) 1393 dValue += DOUBLE_CORRECT;//УÕý
1418 » { 1394
1419 » » for (int iNum = 0; iNum <= iDec2 - iMax; iNum++) 1395 int iDec2;
1420 » » { 1396 FX_BOOL bNegative = FALSE;
1421 » » » strValue += "0"; 1397 strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
1422 » » } 1398 if (strValue.IsEmpty())
1423 » » iMax = iDec2+1; 1399 {
1424 » } 1400 dValue = 0;
1425 » /////////////////////////////////////////////////////// 1401 strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
1402 }
1403
1404 if (iDec2 < 0)
1405 {
1406 for (int iNum = 0; iNum < abs(iDec2); iNum++)
1407 {
1408 strValue = "0" + strValue;
1409 }
1410 iDec2 = 0;
1411
1412 }
1413 int iMax = strValue.GetLength();
1414 if (iDec2 > iMax)
1415 {
1416 for (int iNum = 0; iNum <= iDec2 - iMax; iNum++)
1417 {
1418 strValue += "0";
1419 }
1420 iMax = iDec2+1;
1421 }
1422 ///////////////////////////////////////////////////////
1426 //for processing seperator style 1423 //for processing seperator style
1427 » if (iDec2 < iMax) 1424 if (iDec2 < iMax)
1428 » { 1425 {
1429 » » if (iSepStyle == 0 || iSepStyle == 1) 1426 if (iSepStyle == 0 || iSepStyle == 1)
1430 » » { 1427 {
1431 » » » strValue.Insert(iDec2, '.'); 1428 strValue.Insert(iDec2, '.');
1432 » » » iMax++; 1429 iMax++;
1433 » » } 1430 }
1434 » » else if (iSepStyle == 2 || iSepStyle == 3) 1431 else if (iSepStyle == 2 || iSepStyle == 3)
1435 » » { 1432 {
1436 » » » strValue.Insert(iDec2, ','); 1433 strValue.Insert(iDec2, ',');
1437 » » » iMax++; 1434 iMax++;
1438 » » } 1435 }
1439 1436
1440 » » if (iDec2 == 0) 1437 if (iDec2 == 0)
1441 » » » strValue.Insert(iDec2, '0'); 1438 strValue.Insert(iDec2, '0');
1442 » } 1439 }
1443 » if (iSepStyle == 0 || iSepStyle == 2) 1440 if (iSepStyle == 0 || iSepStyle == 2)
1444 » { 1441 {
1445 » » char cSeperator; 1442 char cSeperator;
1446 » » if (iSepStyle == 0) 1443 if (iSepStyle == 0)
1447 » » » cSeperator = ','; 1444 cSeperator = ',';
1448 » » else 1445 else
1449 » » » cSeperator = '.'; 1446 cSeperator = '.';
1450 1447
1451 » » int iDecPositive; 1448 int iDecPositive;
1452 » » iDecPositive = iDec2; 1449 iDecPositive = iDec2;
1453 1450
1454 » » for (iDecPositive = iDec2 -3; iDecPositive > 0; iDecPositive -= 3) 1451 for (iDecPositive = iDec2 -3; iDecPositive > 0; iDecPositive -= 3)
1455 » » { 1452 {
1456 » » » strValue.Insert(iDecPositive,cSeperator); 1453 strValue.Insert(iDecPositive,cSeperator);
1457 » » » iMax++; 1454 iMax++;
1458 » » } 1455 }
1459 » } 1456 }
1460 » //////////////////////////////////////////////////////////////////// 1457 ////////////////////////////////////////////////////////////////////
1461 » //negative mark 1458 //negative mark
1462 » if(bNegative) 1459 if(bNegative)
1463 » » strValue = "-" + strValue; 1460 strValue = "-" + strValue;
1464 » strValue += "%"; 1461 strValue += "%";
1465 » Value = CFX_WideString::FromLocal(strValue); 1462 Value = CFX_WideString::FromLocal(strValue);
1466 #endif 1463 #endif
1467 » return TRUE; 1464 return TRUE;
1468 } 1465 }
1469 //AFPercent_Keystroke(nDec, sepStyle) 1466 //AFPercent_Keystroke(nDec, sepStyle)
1470 FX_BOOL CJS_PublicMethods::AFPercent_Keystroke(IFXJS_Context* cc, const CJS_Para meters& params, CJS_Value& vRet, CFX_WideString& sError) 1467 FX_BOOL CJS_PublicMethods::AFPercent_Keystroke(IFXJS_Context* cc, const CJS_Para meters& params, CJS_Value& vRet, CFX_WideString& sError)
1471 { 1468 {
1472 » return AFNumber_Keystroke(cc,params,vRet,sError); 1469 return AFNumber_Keystroke(cc,params,vRet,sError);
1473 } 1470 }
1474 1471
1475 //function AFDate_FormatEx(cFormat) 1472 //function AFDate_FormatEx(cFormat)
1476 FX_BOOL CJS_PublicMethods::AFDate_FormatEx(IFXJS_Context* cc, const CJS_Paramete rs& params, CJS_Value& vRet, CFX_WideString& sError) 1473 FX_BOOL CJS_PublicMethods::AFDate_FormatEx(IFXJS_Context* cc, const CJS_Paramete rs& params, CJS_Value& vRet, CFX_WideString& sError)
1477 { 1474 {
1478 » CJS_Context* pContext = (CJS_Context *)cc; 1475 CJS_Context* pContext = (CJS_Context *)cc;
1479 » ASSERT(pContext != NULL); 1476 ASSERT(pContext != NULL);
1480 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1477 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1481 » ASSERT(pEvent != NULL); 1478 ASSERT(pEvent != NULL);
1482 1479
1483 » if (params.size() != 1) 1480 if (params.size() != 1)
1484 » { 1481 {
1485 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1482 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1486 » » return FALSE; 1483 return FALSE;
1487 » } 1484 }
1488 » if(!pEvent->m_pValue) 1485 if(!pEvent->m_pValue)
1489 » » return FALSE; 1486 return FALSE;
1490 1487
1491 » CFX_WideString& val = pEvent->Value(); 1488 CFX_WideString& val = pEvent->Value();
1492 » CFX_WideString strValue = val; 1489 CFX_WideString strValue = val;
1493 » if (strValue.IsEmpty()) 1490 if (strValue.IsEmpty())
1494 » » return TRUE; 1491 return TRUE;
1495 1492
1496 » CFX_WideString sFormat = params[0].ToCFXWideString(); 1493 CFX_WideString sFormat = params[0].ToCFXWideString();
1497 » FX_BOOL bWrongFormat = FALSE; 1494 FX_BOOL bWrongFormat = FALSE;
1498 » double dDate = 0.0f; 1495 double dDate = 0.0f;
1499 1496
1500 » if(strValue.Find(L"GMT") != -1) 1497 if(strValue.Find(L"GMT") != -1)
1501 » { 1498 {
1502 » » //for GMT format time 1499 //for GMT format time
1503 » » //such as "Tue Aug 11 14:24:16 GMT+08002009" 1500 //such as "Tue Aug 11 14:24:16 GMT+08002009"
1504 » » dDate = MakeInterDate(strValue); 1501 dDate = MakeInterDate(strValue);
1505 » } 1502 }
1506 » else 1503 else
1507 » { 1504 {
1508 » » dDate = MakeRegularDate(strValue,sFormat,bWrongFormat); 1505 dDate = MakeRegularDate(strValue,sFormat,bWrongFormat);
1509 » } 1506 }
1510 1507
1511 » if (JS_PortIsNan(dDate)) 1508 if (JS_PortIsNan(dDate))
1512 » { 1509 {
1513 » » CFX_WideString swMsg; 1510 CFX_WideString swMsg;
1514 » » swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE) .c_str(), sFormat.c_str()); 1511 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE).c_str() , sFormat.c_str());
1515 » » Alert(pContext, swMsg.c_str()); 1512 Alert(pContext, swMsg.c_str());
1516 » » return FALSE; 1513 return FALSE;
1517 » } 1514 }
1518 1515
1519 » val = MakeFormatDate(dDate,sFormat); 1516 val = MakeFormatDate(dDate,sFormat);
1520 » return TRUE; 1517 return TRUE;
1521 } 1518 }
1522 1519
1523 double CJS_PublicMethods::MakeInterDate(CFX_WideString strValue) 1520 double CJS_PublicMethods::MakeInterDate(CFX_WideString strValue)
1524 { 1521 {
1525 » int nHour; 1522 int nHour;
1526 » int nMin; 1523 int nMin;
1527 » int nSec; 1524 int nSec;
1528 » int nYear; 1525 int nYear;
1529 » int nMonth; 1526 int nMonth;
1530 » int nDay; 1527 int nDay;
1531 1528
1532 » CFX_WideStringArray wsArray; 1529 CFX_WideStringArray wsArray;
1533 » CFX_WideString sMonth = L""; 1530 CFX_WideString sMonth = L"";
1534 » CFX_WideString sTemp = L""; 1531 CFX_WideString sTemp = L"";
1535 » int nSize = strValue.GetLength(); 1532 int nSize = strValue.GetLength();
1536 1533
1537 » for(int i = 0; i < nSize; i++) 1534 for(int i = 0; i < nSize; i++)
1538 » { 1535 {
1539 » » FX_WCHAR c = strValue.GetAt(i); 1536 FX_WCHAR c = strValue.GetAt(i);
1540 » » if(c == L' ' || c == L':') 1537 if(c == L' ' || c == L':')
1541 » » { 1538 {
1542 » » » wsArray.Add(sTemp); 1539 wsArray.Add(sTemp);
1543 » » » sTemp = L""; 1540 sTemp = L"";
1544 » » » continue; 1541 continue;
1545 » » } 1542 }
1546 1543
1547 » » sTemp += c; 1544 sTemp += c;
1548 » } 1545 }
1549 1546
1550 » wsArray.Add(sTemp); 1547 wsArray.Add(sTemp);
1551 » if(wsArray.GetSize() != 8)return 0; 1548 if(wsArray.GetSize() != 8)return 0;
1552 1549
1553 » sTemp = wsArray[1]; 1550 sTemp = wsArray[1];
1554 » if(sTemp.Compare(L"Jan") == 0) nMonth = 1; 1551 if(sTemp.Compare(L"Jan") == 0) nMonth = 1;
1555 » if(sTemp.Compare(L"Feb") == 0) nMonth = 2; 1552 if(sTemp.Compare(L"Feb") == 0) nMonth = 2;
1556 » if(sTemp.Compare(L"Mar") == 0) nMonth = 3; 1553 if(sTemp.Compare(L"Mar") == 0) nMonth = 3;
1557 » if(sTemp.Compare(L"Apr") == 0) nMonth = 4; 1554 if(sTemp.Compare(L"Apr") == 0) nMonth = 4;
1558 » if(sTemp.Compare(L"May") == 0) nMonth = 5; 1555 if(sTemp.Compare(L"May") == 0) nMonth = 5;
1559 » if(sTemp.Compare(L"Jun") == 0) nMonth = 6; 1556 if(sTemp.Compare(L"Jun") == 0) nMonth = 6;
1560 » if(sTemp.Compare(L"Jul") == 0) nMonth = 7; 1557 if(sTemp.Compare(L"Jul") == 0) nMonth = 7;
1561 » if(sTemp.Compare(L"Aug") == 0) nMonth = 8; 1558 if(sTemp.Compare(L"Aug") == 0) nMonth = 8;
1562 » if(sTemp.Compare(L"Sep") == 0) nMonth = 9; 1559 if(sTemp.Compare(L"Sep") == 0) nMonth = 9;
1563 » if(sTemp.Compare(L"Oct") == 0) nMonth = 10; 1560 if(sTemp.Compare(L"Oct") == 0) nMonth = 10;
1564 » if(sTemp.Compare(L"Nov") == 0) nMonth = 11; 1561 if(sTemp.Compare(L"Nov") == 0) nMonth = 11;
1565 » if(sTemp.Compare(L"Dec") == 0) nMonth = 12; 1562 if(sTemp.Compare(L"Dec") == 0) nMonth = 12;
1566 1563
1567 » nDay = (int)ParseStringToNumber(wsArray[2].c_str()); 1564 nDay = (int)ParseStringToNumber(wsArray[2].c_str());
1568 » nHour = (int)ParseStringToNumber(wsArray[3].c_str()); 1565 nHour = (int)ParseStringToNumber(wsArray[3].c_str());
1569 » nMin = (int)ParseStringToNumber(wsArray[4].c_str()); 1566 nMin = (int)ParseStringToNumber(wsArray[4].c_str());
1570 » nSec = (int)ParseStringToNumber(wsArray[5].c_str()); 1567 nSec = (int)ParseStringToNumber(wsArray[5].c_str());
1571 » nYear = (int)ParseStringToNumber(wsArray[7].c_str()); 1568 nYear = (int)ParseStringToNumber(wsArray[7].c_str());
1572 1569
1573 » double dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime( nHour, nMin, nSec, 0)); 1570 double dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime(nHou r, nMin, nSec, 0));
1574 1571
1575 » if (JS_PortIsNan(dRet)) 1572 if (JS_PortIsNan(dRet))
1576 » { 1573 {
1577 » » dRet = JS_DateParse(strValue.c_str()); 1574 dRet = JS_DateParse(strValue.c_str());
1578 » } 1575 }
1579 1576
1580 » return dRet; 1577 return dRet;
1581 } 1578 }
1582 1579
1583 //AFDate_KeystrokeEx(cFormat) 1580 //AFDate_KeystrokeEx(cFormat)
1584 FX_BOOL CJS_PublicMethods::AFDate_KeystrokeEx(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError) 1581 FX_BOOL CJS_PublicMethods::AFDate_KeystrokeEx(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError)
1585 { 1582 {
1586 » CJS_Context* pContext = (CJS_Context *)cc; 1583 CJS_Context* pContext = (CJS_Context *)cc;
1587 » ASSERT(pContext != NULL); 1584 ASSERT(pContext != NULL);
1588 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1585 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1589 » ASSERT(pEvent != NULL); 1586 ASSERT(pEvent != NULL);
1590 1587
1591 » if (params.size() != 1) 1588 if (params.size() != 1)
1592 » { 1589 {
1593 » » sError = L"AFDate_KeystrokeEx's parameters' size r not correct"; 1590 sError = L"AFDate_KeystrokeEx's parameters' size r not correct";
1594 » » return FALSE; 1591 return FALSE;
1595 » } 1592 }
1596 1593
1597 » if (pEvent->WillCommit()) 1594 if (pEvent->WillCommit())
1598 » { 1595 {
1599 » » if(!pEvent->m_pValue) 1596 if(!pEvent->m_pValue)
1600 » » » return FALSE; 1597 return FALSE;
1601 » » CFX_WideString strValue = pEvent->Value(); 1598 CFX_WideString strValue = pEvent->Value();
1602 » » if (strValue.IsEmpty()) 1599 if (strValue.IsEmpty())
1603 » » » return TRUE; 1600 return TRUE;
1604 1601
1605 » » CFX_WideString sFormat = params[0].ToCFXWideString(); 1602 CFX_WideString sFormat = params[0].ToCFXWideString();
1606 » » FX_BOOL bWrongFormat = FALSE; 1603 FX_BOOL bWrongFormat = FALSE;
1607 » » double dRet = MakeRegularDate(strValue,sFormat,bWrongFormat); 1604 double dRet = MakeRegularDate(strValue,sFormat,bWrongFormat);
1608 » » if (bWrongFormat || JS_PortIsNan(dRet)) 1605 if (bWrongFormat || JS_PortIsNan(dRet))
1609 » » { 1606 {
1610 » » » CFX_WideString swMsg; 1607 CFX_WideString swMsg;
1611 » » » swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPA RSEDATE).c_str(), sFormat.c_str()); 1608 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE).c_s tr(), sFormat.c_str());
1612 » » » Alert(pContext, swMsg.c_str()); 1609 Alert(pContext, swMsg.c_str());
1613 » » » pEvent->Rc() = FALSE; 1610 pEvent->Rc() = FALSE;
1614 » » » return TRUE; 1611 return TRUE;
1615 » » } 1612 }
1616 » } 1613 }
1617 » return TRUE; 1614 return TRUE;
1618 } 1615 }
1619 1616
1620 FX_BOOL CJS_PublicMethods::AFDate_Format(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError) 1617 FX_BOOL CJS_PublicMethods::AFDate_Format(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError)
1621 { 1618 {
1622 » v8::Isolate* isolate = ::GetIsolate(cc); 1619 v8::Isolate* isolate = ::GetIsolate(cc);
1623 1620
1624 » if (params.size() != 1) 1621 if (params.size() != 1)
1625 » { 1622 {
1626 » » CJS_Context* pContext = (CJS_Context*)cc; 1623 CJS_Context* pContext = (CJS_Context*)cc;
1627 » » ASSERT(pContext != NULL); 1624 ASSERT(pContext != NULL);
1628 1625
1629 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1626 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1630 » » return FALSE; 1627 return FALSE;
1631 » } 1628 }
1632 1629
1633 » int iIndex = params[0].ToInt(); 1630 int iIndex = params[0].ToInt();
1634 » const FX_WCHAR* cFormats[] = {L"m/d", L"m/d/yy", L"mm/dd/yy", L"mm/yy", L"d-mmm", L"d-mmm-yy", L"dd-mmm-yy", 1631 const FX_WCHAR* cFormats[] = {L"m/d", L"m/d/yy", L"mm/dd/yy", L"mm/yy", L"d -mmm", L"d-mmm-yy", L"dd-mmm-yy",
1635 » » L"yy-mm-dd", L"mmm-yy", L"mmmm-yy", L"mmm d, yyyy", L"mmmm d, yy yy", 1632 L"yy-mm-dd", L"mmm-yy", L"mmmm-yy", L"mmm d, yyyy", L"mmmm d, yyyy",
1636 » » L"m/d/yy h:MM tt", L"m/d/yy HH:MM" }; 1633 L"m/d/yy h:MM tt", L"m/d/yy HH:MM" };
1637 1634
1638 » ASSERT(iIndex < FX_ArraySize(cFormats)); 1635 ASSERT(iIndex < FX_ArraySize(cFormats));
1639 1636
1640 » if (iIndex < 0) 1637 if (iIndex < 0)
1641 » » iIndex = 0; 1638 iIndex = 0;
1642 » if (iIndex >= FX_ArraySize(cFormats)) 1639 if (iIndex >= FX_ArraySize(cFormats))
1643 » » iIndex = 0; 1640 iIndex = 0;
1644 » CJS_Parameters newParams; 1641 CJS_Parameters newParams;
1645 » CJS_Value val(isolate,cFormats[iIndex]); 1642 CJS_Value val(isolate,cFormats[iIndex]);
1646 » newParams.push_back(val); 1643 newParams.push_back(val);
1647 » return AFDate_FormatEx(cc,newParams,vRet,sError); 1644 return AFDate_FormatEx(cc,newParams,vRet,sError);
1648 } 1645 }
1649 1646
1650 //AFDate_KeystrokeEx(cFormat) 1647 //AFDate_KeystrokeEx(cFormat)
1651 FX_BOOL CJS_PublicMethods::AFDate_Keystroke(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError) 1648 FX_BOOL CJS_PublicMethods::AFDate_Keystroke(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError)
1652 { 1649 {
1653 » v8::Isolate* isolate = ::GetIsolate(cc); 1650 v8::Isolate* isolate = ::GetIsolate(cc);
1654 1651
1655 » if (params.size() != 1) 1652 if (params.size() != 1)
1656 » { 1653 {
1657 » » CJS_Context* pContext = (CJS_Context*)cc; 1654 CJS_Context* pContext = (CJS_Context*)cc;
1658 » » ASSERT(pContext != NULL); 1655 ASSERT(pContext != NULL);
1659 1656
1660 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1657 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1661 » » return FALSE; 1658 return FALSE;
1662 » } 1659 }
1663 1660
1664 » int iIndex = params[0].ToInt(); 1661 int iIndex = params[0].ToInt();
1665 » const FX_WCHAR* cFormats[] = {L"m/d", L"m/d/yy", L"mm/dd/yy", L"mm/yy", L"d-mmm", L"d-mmm-yy", L"dd-mmm-yy", 1662 const FX_WCHAR* cFormats[] = {L"m/d", L"m/d/yy", L"mm/dd/yy", L"mm/yy", L"d -mmm", L"d-mmm-yy", L"dd-mmm-yy",
1666 » » L"yy-mm-dd", L"mmm-yy", L"mmmm-yy", L"mmm d, yyyy", L"mmmm d, yy yy", 1663 L"yy-mm-dd", L"mmm-yy", L"mmmm-yy", L"mmm d, yyyy", L"mmmm d, yyyy",
1667 » » L"m/d/yy h:MM tt", L"m/d/yy HH:MM" }; 1664 L"m/d/yy h:MM tt", L"m/d/yy HH:MM" };
1668 1665
1669 » ASSERT(iIndex<FX_ArraySize(cFormats)); 1666 ASSERT(iIndex<FX_ArraySize(cFormats));
1670 1667
1671 » if (iIndex < 0) 1668 if (iIndex < 0)
1672 » » iIndex = 0; 1669 iIndex = 0;
1673 » if (iIndex >= FX_ArraySize(cFormats)) 1670 if (iIndex >= FX_ArraySize(cFormats))
1674 » » iIndex = 0; 1671 iIndex = 0;
1675 » CJS_Parameters newParams; 1672 CJS_Parameters newParams;
1676 » CJS_Value val(isolate,cFormats[iIndex]); 1673 CJS_Value val(isolate,cFormats[iIndex]);
1677 » newParams.push_back(val); 1674 newParams.push_back(val);
1678 » return AFDate_KeystrokeEx(cc,newParams,vRet,sError); 1675 return AFDate_KeystrokeEx(cc,newParams,vRet,sError);
1679 } 1676 }
1680 1677
1681 //function AFTime_Format(ptf) 1678 //function AFTime_Format(ptf)
1682 FX_BOOL CJS_PublicMethods::AFTime_Format(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError) 1679 FX_BOOL CJS_PublicMethods::AFTime_Format(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError)
1683 { 1680 {
1684 » v8::Isolate* isolate = ::GetIsolate(cc); 1681 v8::Isolate* isolate = ::GetIsolate(cc);
1685 1682
1686 » if (params.size() != 1) 1683 if (params.size() != 1)
1687 » { 1684 {
1688 » » CJS_Context* pContext = (CJS_Context*)cc; 1685 CJS_Context* pContext = (CJS_Context*)cc;
1689 » » ASSERT(pContext != NULL); 1686 ASSERT(pContext != NULL);
1690 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1687 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1691 » » return FALSE; 1688 return FALSE;
1692 » } 1689 }
1693 1690
1694 » int iIndex = params[0].ToInt(); 1691 int iIndex = params[0].ToInt();
1695 » const FX_WCHAR* cFormats[] = {L"HH:MM", L"h:MM tt", L"HH:MM:ss", L"h:MM: ss tt"}; 1692 const FX_WCHAR* cFormats[] = {L"HH:MM", L"h:MM tt", L"HH:MM:ss", L"h:MM:ss t t"};
1696 1693
1697 » ASSERT(iIndex<FX_ArraySize(cFormats)); 1694 ASSERT(iIndex<FX_ArraySize(cFormats));
1698 1695
1699 » if (iIndex < 0) 1696 if (iIndex < 0)
1700 » » iIndex = 0; 1697 iIndex = 0;
1701 » if (iIndex >= FX_ArraySize(cFormats)) 1698 if (iIndex >= FX_ArraySize(cFormats))
1702 » » iIndex = 0; 1699 iIndex = 0;
1703 » CJS_Parameters newParams; 1700 CJS_Parameters newParams;
1704 » CJS_Value val(isolate,cFormats[iIndex]); 1701 CJS_Value val(isolate,cFormats[iIndex]);
1705 » newParams.push_back(val); 1702 newParams.push_back(val);
1706 » return AFDate_FormatEx(cc,newParams,vRet,sError); 1703 return AFDate_FormatEx(cc,newParams,vRet,sError);
1707 } 1704 }
1708 1705
1709 FX_BOOL CJS_PublicMethods::AFTime_Keystroke(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError) 1706 FX_BOOL CJS_PublicMethods::AFTime_Keystroke(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError)
1710 { 1707 {
1711 » v8::Isolate* isolate = ::GetIsolate(cc); 1708 v8::Isolate* isolate = ::GetIsolate(cc);
1712 » if (params.size() != 1) 1709 if (params.size() != 1)
1713 » { 1710 {
1714 » » CJS_Context* pContext = (CJS_Context*)cc; 1711 CJS_Context* pContext = (CJS_Context*)cc;
1715 » » ASSERT(pContext != NULL); 1712 ASSERT(pContext != NULL);
1716 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1713 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1717 » » return FALSE; 1714 return FALSE;
1718 » } 1715 }
1719 1716
1720 » int iIndex = params[0].ToInt(); 1717 int iIndex = params[0].ToInt();
1721 » const FX_WCHAR* cFormats[] = {L"HH:MM", L"h:MM tt", L"HH:MM:ss", L"h:MM: ss tt"}; 1718 const FX_WCHAR* cFormats[] = {L"HH:MM", L"h:MM tt", L"HH:MM:ss", L"h:MM:ss t t"};
1722 1719
1723 » ASSERT(iIndex<FX_ArraySize(cFormats)); 1720 ASSERT(iIndex<FX_ArraySize(cFormats));
1724 1721
1725 » if (iIndex < 0) 1722 if (iIndex < 0)
1726 » » iIndex = 0; 1723 iIndex = 0;
1727 » if (iIndex >= FX_ArraySize(cFormats)) 1724 if (iIndex >= FX_ArraySize(cFormats))
1728 » » iIndex = 0; 1725 iIndex = 0;
1729 » CJS_Parameters newParams; 1726 CJS_Parameters newParams;
1730 » CJS_Value val(isolate,cFormats[iIndex]); 1727 CJS_Value val(isolate,cFormats[iIndex]);
1731 » newParams.push_back(val); 1728 newParams.push_back(val);
1732 » return AFDate_KeystrokeEx(cc,newParams,vRet,sError); 1729 return AFDate_KeystrokeEx(cc,newParams,vRet,sError);
1733 } 1730 }
1734 1731
1735 FX_BOOL CJS_PublicMethods::AFTime_FormatEx(IFXJS_Context* cc, const CJS_Paramete rs& params, CJS_Value& vRet, CFX_WideString& sError) 1732 FX_BOOL CJS_PublicMethods::AFTime_FormatEx(IFXJS_Context* cc, const CJS_Paramete rs& params, CJS_Value& vRet, CFX_WideString& sError)
1736 { 1733 {
1737 » return AFDate_FormatEx(cc,params,vRet,sError); 1734 return AFDate_FormatEx(cc,params,vRet,sError);
1738 } 1735 }
1739 1736
1740 FX_BOOL CJS_PublicMethods::AFTime_KeystrokeEx(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError) 1737 FX_BOOL CJS_PublicMethods::AFTime_KeystrokeEx(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError)
1741 { 1738 {
1742 » return AFDate_KeystrokeEx(cc,params,vRet,sError); 1739 return AFDate_KeystrokeEx(cc,params,vRet,sError);
1743 } 1740 }
1744 1741
1745 //function AFSpecial_Format(psf) 1742 //function AFSpecial_Format(psf)
1746 FX_BOOL CJS_PublicMethods::AFSpecial_Format(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError) 1743 FX_BOOL CJS_PublicMethods::AFSpecial_Format(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError)
1747 { 1744 {
1748 » CJS_Context* pContext = (CJS_Context *)cc; 1745 CJS_Context* pContext = (CJS_Context *)cc;
1749 » ASSERT(pContext != NULL); 1746 ASSERT(pContext != NULL);
1750 1747
1751 » if (params.size() != 1) 1748 if (params.size() != 1)
1752 » { 1749 {
1753 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1750 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1754 » » return FALSE; 1751 return FALSE;
1755 » } 1752 }
1756 1753
1757 » std::string cFormat; 1754 std::string cFormat;
1758 » int iIndex = params[0].ToInt(); 1755 int iIndex = params[0].ToInt();
1759 1756
1760 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1757 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1761 » ASSERT(pEvent != NULL); 1758 ASSERT(pEvent != NULL);
1762 1759
1763 » if(!pEvent->m_pValue) 1760 if(!pEvent->m_pValue)
1764 » » return FALSE; 1761 return FALSE;
1765 » CFX_WideString& Value = pEvent->Value(); 1762 CFX_WideString& Value = pEvent->Value();
1766 » std::string strSrc = CFX_ByteString::FromUnicode(Value).c_str(); 1763 std::string strSrc = CFX_ByteString::FromUnicode(Value).c_str();
1767 1764
1768 » switch (iIndex) 1765 switch (iIndex)
1769 » { 1766 {
1770 » case 0: 1767 case 0:
1771 » » cFormat = "99999"; 1768 cFormat = "99999";
1772 » » break; 1769 break;
1773 » case 1: 1770 case 1:
1774 » » cFormat = "99999-9999"; 1771 cFormat = "99999-9999";
1775 » » break; 1772 break;
1776 » case 2: 1773 case 2:
1777 » » { 1774 {
1778 » » » std::string NumberStr; 1775 std::string NumberStr;
1779 » » » util::printx("9999999999", strSrc,NumberStr); 1776 util::printx("9999999999", strSrc,NumberStr);
1780 » » » if (NumberStr.length() >= 10 ) 1777 if (NumberStr.length() >= 10 )
1781 » » » » cFormat = "(999) 999-9999"; 1778 cFormat = "(999) 999-9999";
1782 » » » else 1779 else
1783 » » » » cFormat = "999-9999"; 1780 cFormat = "999-9999";
1784 » » » break; 1781 break;
1785 » » } 1782 }
1786 » case 3: 1783 case 3:
1787 » » cFormat = "999-99-9999"; 1784 cFormat = "999-99-9999";
1788 » » break; 1785 break;
1789 » } 1786 }
1790 1787
1791 » std::string strDes; 1788 std::string strDes;
1792 » util::printx(cFormat,strSrc,strDes); 1789 util::printx(cFormat,strSrc,strDes);
1793 » Value = CFX_WideString::FromLocal(strDes.c_str()); 1790 Value = CFX_WideString::FromLocal(strDes.c_str());
1794 » return TRUE; 1791 return TRUE;
1795 } 1792 }
1796 1793
1797 1794
1798 //function AFSpecial_KeystrokeEx(mask) 1795 //function AFSpecial_KeystrokeEx(mask)
1799 FX_BOOL CJS_PublicMethods::AFSpecial_KeystrokeEx(IFXJS_Context* cc, const CJS_Pa rameters& params, CJS_Value& vRet, CFX_WideString& sError) 1796 FX_BOOL CJS_PublicMethods::AFSpecial_KeystrokeEx(IFXJS_Context* cc, const CJS_Pa rameters& params, CJS_Value& vRet, CFX_WideString& sError)
1800 { 1797 {
1801 » CJS_Context* pContext = (CJS_Context *)cc; 1798 CJS_Context* pContext = (CJS_Context *)cc;
1802 » ASSERT(pContext != NULL); 1799 ASSERT(pContext != NULL);
1803 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1800 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1804 1801
1805 » ASSERT(pEvent != NULL); 1802 ASSERT(pEvent != NULL);
1806 1803
1807 » if (params.size() < 1) 1804 if (params.size() < 1)
1808 » { 1805 {
1809 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1806 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1810 » » return FALSE; 1807 return FALSE;
1811 » } 1808 }
1812 1809
1813 » if(!pEvent->m_pValue) 1810 if(!pEvent->m_pValue)
1814 » » return FALSE; 1811 return FALSE;
1815 » CFX_WideString& valEvent = pEvent->Value(); 1812 CFX_WideString& valEvent = pEvent->Value();
1816 1813
1817 » CFX_WideString wstrMask = params[0].ToCFXWideString(); 1814 CFX_WideString wstrMask = params[0].ToCFXWideString();
1818 » if (wstrMask.IsEmpty()) 1815 if (wstrMask.IsEmpty())
1819 » » return TRUE; 1816 return TRUE;
1820 1817
1821 » std::wstring wstrValue = valEvent.c_str(); 1818 std::wstring wstrValue = valEvent.c_str();
1822 1819
1823 » if (pEvent->WillCommit()) 1820 if (pEvent->WillCommit())
1824 » { 1821 {
1825 » » if (wstrValue.empty()) 1822 if (wstrValue.empty())
1826 » » » return TRUE; 1823 return TRUE;
1827 » » int iIndexMask = 0; 1824 int iIndexMask = 0;
1828 » » for (std::wstring::iterator it = wstrValue.begin(); it != wstrVa lue.end(); it++) 1825 for (std::wstring::iterator it = wstrValue.begin(); it != wstrValue.end( ); it++)
1829 » » { 1826 {
1830 » » » wchar_t w_Value = *it; 1827 wchar_t w_Value = *it;
1831 » » » if (!maskSatisfied(w_Value,wstrMask[iIndexMask])) 1828 if (!maskSatisfied(w_Value,wstrMask[iIndexMask]))
1832 » » » » break; 1829 break;
1833 » » » iIndexMask++; 1830 iIndexMask++;
1834 » » } 1831 }
1835 1832
1836 » » if (iIndexMask != wstrMask.GetLength() || (iIndexMask != wstrVal ue.size() && wstrMask.GetLength() != 0)) 1833 if (iIndexMask != wstrMask.GetLength() || (iIndexMask != wstrValue.size( ) && wstrMask.GetLength() != 0))
1837 » » { 1834 {
1838 » » » Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_J SAFNUMBER_KEYSTROKE).c_str()); 1835 Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSAFNUMBER_KE YSTROKE).c_str());
1839 » » » pEvent->Rc() = FALSE; 1836 pEvent->Rc() = FALSE;
1840 » » } 1837 }
1841 » » return TRUE; 1838 return TRUE;
1842 » } 1839 }
1843 1840
1844 » CFX_WideString &wideChange = pEvent->Change(); 1841 CFX_WideString &wideChange = pEvent->Change();
1845 » std::wstring wChange = wideChange.c_str(); 1842 std::wstring wChange = wideChange.c_str();
1846 » if (wChange.empty()) 1843 if (wChange.empty())
1847 » » return TRUE; 1844 return TRUE;
1848 1845
1849 » int iIndexMask = pEvent->SelStart(); 1846 int iIndexMask = pEvent->SelStart();
1850 1847
1851 » if (wstrValue.length() - (pEvent->SelEnd()-pEvent->SelStart()) + wChange .length() > (FX_DWORD)wstrMask.GetLength()) 1848 if (wstrValue.length() - (pEvent->SelEnd()-pEvent->SelStart()) + wChange.len gth() > (FX_DWORD)wstrMask.GetLength())
1852 » { 1849 {
1853 » » Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_T OOLONG).c_str()); 1850 Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG). c_str());
1854 » » pEvent->Rc() = FALSE; 1851 pEvent->Rc() = FALSE;
1855 » » return TRUE; 1852 return TRUE;
1856 » } 1853 }
1857 1854
1858 » if (iIndexMask >= wstrMask.GetLength() && (!wChange.empty())) 1855 if (iIndexMask >= wstrMask.GetLength() && (!wChange.empty()))
1859 » { 1856 {
1860 » » Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_T OOLONG).c_str()); 1857 Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG). c_str());
1861 » » pEvent->Rc() = FALSE; 1858 pEvent->Rc() = FALSE;
1862 » » return TRUE; 1859 return TRUE;
1863 » } 1860 }
1864 1861
1865 » for (std::wstring::iterator it = wChange.begin(); it != wChange.end(); i t++) 1862 for (std::wstring::iterator it = wChange.begin(); it != wChange.end(); it++)
1866 » { 1863 {
1867 » » if (iIndexMask >= wstrMask.GetLength()) 1864 if (iIndexMask >= wstrMask.GetLength())
1868 » » { 1865 {
1869 » » » Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_J SPARAM_TOOLONG).c_str()); 1866 Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLO NG).c_str());
1870 » » » pEvent->Rc() = FALSE; 1867 pEvent->Rc() = FALSE;
1871 » » » return TRUE; 1868 return TRUE;
1872 » » } 1869 }
1873 » » wchar_t w_Mask = wstrMask[iIndexMask]; 1870 wchar_t w_Mask = wstrMask[iIndexMask];
1874 » » if (!isReservedMaskChar(w_Mask)) 1871 if (!isReservedMaskChar(w_Mask))
1875 » » { 1872 {
1876 » » » *it = w_Mask; 1873 *it = w_Mask;
1877 » » } 1874 }
1878 » » wchar_t w_Change = *it; 1875 wchar_t w_Change = *it;
1879 » » if (!maskSatisfied(w_Change,w_Mask)) 1876 if (!maskSatisfied(w_Change,w_Mask))
1880 » » { 1877 {
1881 » » » pEvent->Rc() = FALSE; 1878 pEvent->Rc() = FALSE;
1882 » » » return TRUE; 1879 return TRUE;
1883 » » } 1880 }
1884 » » iIndexMask++; 1881 iIndexMask++;
1885 » } 1882 }
1886 1883
1887 » wideChange = wChange.c_str(); 1884 wideChange = wChange.c_str();
1888 » return TRUE; 1885 return TRUE;
1889 } 1886 }
1890 1887
1891 1888
1892 //function AFSpecial_Keystroke(psf) 1889 //function AFSpecial_Keystroke(psf)
1893 FX_BOOL CJS_PublicMethods::AFSpecial_Keystroke(IFXJS_Context* cc, const CJS_Para meters& params, CJS_Value& vRet, CFX_WideString& sError) 1890 FX_BOOL CJS_PublicMethods::AFSpecial_Keystroke(IFXJS_Context* cc, const CJS_Para meters& params, CJS_Value& vRet, CFX_WideString& sError)
1894 { 1891 {
1895 » v8::Isolate* isolate = ::GetIsolate(cc); 1892 v8::Isolate* isolate = ::GetIsolate(cc);
1896 1893
1897 » CJS_Context* pContext = (CJS_Context *)cc; 1894 CJS_Context* pContext = (CJS_Context *)cc;
1898 » ASSERT(pContext != NULL); 1895 ASSERT(pContext != NULL);
1899 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 1896 CJS_EventHandler* pEvent = pContext->GetEventHandler();
1900 » ASSERT(pEvent != NULL); 1897 ASSERT(pEvent != NULL);
1901 1898
1902 » if (params.size() != 1) 1899 if (params.size() != 1)
1903 » { 1900 {
1904 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1901 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1905 » » return FALSE; 1902 return FALSE;
1906 » } 1903 }
1907 1904
1908 » std::string cFormat; 1905 std::string cFormat;
1909 » int iIndex = params[0].ToInt(); 1906 int iIndex = params[0].ToInt();
1910 1907
1911 » if(!pEvent->m_pValue) 1908 if(!pEvent->m_pValue)
1912 » » return FALSE; 1909 return FALSE;
1913 » //CJS_Value val = pEvent->Value(); 1910 //CJS_Value val = pEvent->Value();
1914 » CFX_WideString& val = pEvent->Value(); 1911 CFX_WideString& val = pEvent->Value();
1915 » std::string strSrc = CFX_ByteString::FromUnicode(val).c_str(); 1912 std::string strSrc = CFX_ByteString::FromUnicode(val).c_str();
1916 » std::wstring wstrChange = pEvent->Change().c_str(); 1913 std::wstring wstrChange = pEvent->Change().c_str();
1917 1914
1918 » switch (iIndex) 1915 switch (iIndex)
1919 » { 1916 {
1920 » case 0: 1917 case 0:
1921 » » cFormat = "99999"; 1918 cFormat = "99999";
1922 » » break; 1919 break;
1923 » case 1: 1920 case 1:
1924 » » //cFormat = "99999-9999"; 1921 //cFormat = "99999-9999";
1925 » » cFormat = "999999999"; 1922 cFormat = "999999999";
1926 » » break; 1923 break;
1927 » case 2: 1924 case 2:
1928 » » { 1925 {
1929 » » » std::string NumberStr; 1926 std::string NumberStr;
1930 » » » util::printx("9999999999", strSrc,NumberStr); 1927 util::printx("9999999999", strSrc,NumberStr);
1931 » » » if (strSrc.length() + wstrChange.length() > 7 ) 1928 if (strSrc.length() + wstrChange.length() > 7 )
1932 » » » » //cFormat = "(999) 999-9999"; 1929 //cFormat = "(999) 999-9999";
1933 » » » » cFormat = "9999999999"; 1930 cFormat = "9999999999";
1934 » » » else 1931 else
1935 » » » » //cFormat = "999-9999"; 1932 //cFormat = "999-9999";
1936 » » » » cFormat = "9999999"; 1933 cFormat = "9999999";
1937 » » » break; 1934 break;
1938 » » } 1935 }
1939 » case 3: 1936 case 3:
1940 » » //cFormat = "999-99-9999"; 1937 //cFormat = "999-99-9999";
1941 » » cFormat = "999999999"; 1938 cFormat = "999999999";
1942 » » break; 1939 break;
1943 » } 1940 }
1944 1941
1945 » CJS_Parameters params2; 1942 CJS_Parameters params2;
1946 » CJS_Value vMask(isolate, cFormat.c_str()); 1943 CJS_Value vMask(isolate, cFormat.c_str());
1947 » params2.push_back(vMask); 1944 params2.push_back(vMask);
1948 1945
1949 return AFSpecial_KeystrokeEx(cc,params2,vRet,sError); 1946 return AFSpecial_KeystrokeEx(cc,params2,vRet,sError);
1950 } 1947 }
1951 1948
1952 FX_BOOL CJS_PublicMethods::AFMergeChange(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError) 1949 FX_BOOL CJS_PublicMethods::AFMergeChange(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError)
1953 { 1950 {
1954 » CJS_Context* pContext = (CJS_Context *)cc; 1951 CJS_Context* pContext = (CJS_Context *)cc;
1955 » ASSERT(pContext != NULL); 1952 ASSERT(pContext != NULL);
1956 » CJS_EventHandler* pEventHandler = pContext->GetEventHandler(); 1953 CJS_EventHandler* pEventHandler = pContext->GetEventHandler();
1957 » ASSERT(pEventHandler != NULL); 1954 ASSERT(pEventHandler != NULL);
1958 1955
1959 » if (params.size() != 1) 1956 if (params.size() != 1)
1960 » { 1957 {
1961 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1958 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
1962 » » return FALSE; 1959 return FALSE;
1963 » } 1960 }
1964 1961
1965 » CFX_WideString swValue; 1962 CFX_WideString swValue;
1966 » if (pEventHandler->m_pValue != NULL) 1963 if (pEventHandler->m_pValue != NULL)
1967 » » swValue = pEventHandler->Value(); 1964 swValue = pEventHandler->Value();
1968 1965
1969 » if (pEventHandler->WillCommit()) 1966 if (pEventHandler->WillCommit())
1970 » { 1967 {
1971 » » vRet = swValue.c_str(); 1968 vRet = swValue.c_str();
1972 » » return TRUE; 1969 return TRUE;
1973 » } 1970 }
1974 1971
1975 » CFX_WideString prefix,postfix; 1972 CFX_WideString prefix,postfix;
1976 1973
1977 » if (pEventHandler->SelStart() >= 0) 1974 if (pEventHandler->SelStart() >= 0)
1978 » » prefix = swValue.Mid(0,pEventHandler->SelStart()); 1975 prefix = swValue.Mid(0,pEventHandler->SelStart());
1979 » else 1976 else
1980 » » prefix = L""; 1977 prefix = L"";
1981 1978
1982 1979
1983 » if (pEventHandler->SelEnd() >= 0 && pEventHandler->SelEnd() <= swValue.G etLength()) 1980 if (pEventHandler->SelEnd() >= 0 && pEventHandler->SelEnd() <= swValue.GetLe ngth())
1984 » » postfix = swValue.Mid(pEventHandler->SelEnd(), swValue.GetLength () - pEventHandler->SelEnd()); 1981 postfix = swValue.Mid(pEventHandler->SelEnd(), swValue.GetLength() - pEv entHandler->SelEnd());
1985 » else postfix = L""; 1982 else postfix = L"";
1986 1983
1987 » vRet = (prefix + pEventHandler->Change() + postfix).c_str(); 1984 vRet = (prefix + pEventHandler->Change() + postfix).c_str();
1988 1985
1989 » return TRUE; 1986 return TRUE;
1990 } 1987 }
1991 1988
1992 FX_BOOL CJS_PublicMethods::AFParseDateEx(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError) 1989 FX_BOOL CJS_PublicMethods::AFParseDateEx(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError)
1993 { 1990 {
1994 » CJS_Context* pContext = (CJS_Context *)cc; 1991 CJS_Context* pContext = (CJS_Context *)cc;
1995 » ASSERT(pContext != NULL); 1992 ASSERT(pContext != NULL);
1996 1993
1997 » if (params.size() != 2) 1994 if (params.size() != 2)
1998 » { 1995 {
1999 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 1996 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2000 » » return FALSE; 1997 return FALSE;
2001 » } 1998 }
2002 1999
2003 » CFX_WideString sValue = params[0].ToCFXWideString(); 2000 CFX_WideString sValue = params[0].ToCFXWideString();
2004 » CFX_WideString sFormat = params[1].ToCFXWideString(); 2001 CFX_WideString sFormat = params[1].ToCFXWideString();
2005 2002
2006 » FX_BOOL bWrongFormat = FALSE; 2003 FX_BOOL bWrongFormat = FALSE;
2007 » double dDate = MakeRegularDate(sValue,sFormat,bWrongFormat); 2004 double dDate = MakeRegularDate(sValue,sFormat,bWrongFormat);
2008 2005
2009 » if (JS_PortIsNan(dDate)) 2006 if (JS_PortIsNan(dDate))
2010 » { 2007 {
2011 » » CFX_WideString swMsg; 2008 CFX_WideString swMsg;
2012 » » swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE) .c_str(), sFormat.c_str()); 2009 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE).c_str() , sFormat.c_str());
2013 » » Alert((CJS_Context *)cc, swMsg.c_str()); 2010 Alert((CJS_Context *)cc, swMsg.c_str());
2014 » » return FALSE; 2011 return FALSE;
2015 » } 2012 }
2016 2013
2017 » vRet = dDate; 2014 vRet = dDate;
2018 » return TRUE; 2015 return TRUE;
2019 } 2016 }
2020 2017
2021 FX_BOOL CJS_PublicMethods::AFSimple(IFXJS_Context* cc, const CJS_Parameters& par ams, CJS_Value& vRet, CFX_WideString& sError) 2018 FX_BOOL CJS_PublicMethods::AFSimple(IFXJS_Context* cc, const CJS_Parameters& par ams, CJS_Value& vRet, CFX_WideString& sError)
2022 { 2019 {
2023 » if (params.size() != 3) 2020 if (params.size() != 3)
2024 » { 2021 {
2025 » » CJS_Context* pContext = (CJS_Context *)cc; 2022 CJS_Context* pContext = (CJS_Context *)cc;
2026 » » ASSERT(pContext != NULL); 2023 ASSERT(pContext != NULL);
2027 2024
2028 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 2025 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2029 » » return FALSE; 2026 return FALSE;
2030 » } 2027 }
2031 2028
2032 » vRet = (double)AF_Simple(params[0].ToCFXWideString().c_str(), params[1]. ToDouble(), params[2].ToDouble()); 2029 vRet = (double)AF_Simple(params[0].ToCFXWideString().c_str(), params[1].ToDo uble(), params[2].ToDouble());
2033 » return TRUE; 2030 return TRUE;
2034 } 2031 }
2035 2032
2036 FX_BOOL CJS_PublicMethods::AFMakeNumber(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError) 2033 FX_BOOL CJS_PublicMethods::AFMakeNumber(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
2037 { 2034 {
2038 » if (params.size() != 1) 2035 if (params.size() != 1)
2039 » { 2036 {
2040 » » CJS_Context* pContext = (CJS_Context *)cc; 2037 CJS_Context* pContext = (CJS_Context *)cc;
2041 » » ASSERT(pContext != NULL); 2038 ASSERT(pContext != NULL);
2042 2039
2043 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 2040 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2044 » » return FALSE; 2041 return FALSE;
2045 » } 2042 }
2046 » vRet = ParseStringToNumber(params[0].ToCFXWideString().c_str()); 2043 vRet = ParseStringToNumber(params[0].ToCFXWideString().c_str());
2047 » return TRUE; 2044 return TRUE;
2048 } 2045 }
2049 2046
2050 FX_BOOL CJS_PublicMethods::AFSimple_Calculate(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError) 2047 FX_BOOL CJS_PublicMethods::AFSimple_Calculate(IFXJS_Context* cc, const CJS_Param eters& params, CJS_Value& vRet, CFX_WideString& sError)
2051 { 2048 {
2052 » v8::Isolate* isolate = ::GetIsolate(cc); 2049 v8::Isolate* isolate = ::GetIsolate(cc);
2053 2050
2054 » CJS_Context* pContext = (CJS_Context *)cc; 2051 CJS_Context* pContext = (CJS_Context *)cc;
2055 » ASSERT(pContext != NULL); 2052 ASSERT(pContext != NULL);
2056 2053
2057 » if (params.size() != 2) 2054 if (params.size() != 2)
2058 » { 2055 {
2059 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 2056 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2060 » » return FALSE; 2057 return FALSE;
2061 » } 2058 }
2062 2059
2063 » CJS_Value params1 = params[1]; 2060 CJS_Value params1 = params[1];
2064 2061
2065 » if (!params1.IsArrayObject() && params1.GetType() != VT_string) 2062 if (!params1.IsArrayObject() && params1.GetType() != VT_string)
2066 » { 2063 {
2067 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 2064 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2068 » » return FALSE; 2065 return FALSE;
2069 » } 2066 }
2070 2067
2071 » CPDFSDK_Document* pReaderDoc = pContext->GetReaderDocument(); 2068 CPDFSDK_Document* pReaderDoc = pContext->GetReaderDocument();
2072 ASSERT(pReaderDoc != NULL); 2069 ASSERT(pReaderDoc != NULL);
2073 2070
2074 » CPDFSDK_InterForm* pReaderInterForm = pReaderDoc->GetInterForm(); 2071 CPDFSDK_InterForm* pReaderInterForm = pReaderDoc->GetInterForm();
2075 » ASSERT(pReaderInterForm != NULL); 2072 ASSERT(pReaderInterForm != NULL);
2076 2073
2077 » CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm(); 2074 CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm();
2078 » ASSERT(pInterForm != NULL); 2075 ASSERT(pInterForm != NULL);
2079 2076
2080 » double dValue; 2077 double dValue;
2081 » CFX_WideString sFunction = params[0].ToCFXWideString(); 2078 CFX_WideString sFunction = params[0].ToCFXWideString();
2082 » if (wcscmp(sFunction.c_str(), L"PRD") == 0) 2079 if (wcscmp(sFunction.c_str(), L"PRD") == 0)
2083 » dValue = 1.0; 2080 dValue = 1.0;
2084 » else 2081 else
2085 » » dValue = 0.0; 2082 dValue = 0.0;
2086 2083
2087 » CJS_Array FieldNameArray = AF_MakeArrayFromList(isolate,params1); 2084 CJS_Array FieldNameArray = AF_MakeArrayFromList(isolate,params1);
2088 2085
2089 » int nFieldsCount = 0; 2086 int nFieldsCount = 0;
2090 2087
2091 » for (int i=0,isz=FieldNameArray.GetLength(); i<isz; i++) 2088 for (int i=0,isz=FieldNameArray.GetLength(); i<isz; i++)
2092 » { 2089 {
2093 » » CJS_Value jsValue(isolate); 2090 CJS_Value jsValue(isolate);
2094 » » FieldNameArray.GetElement(i,jsValue); 2091 FieldNameArray.GetElement(i,jsValue);
2095 » » CFX_WideString wsFieldName = jsValue.ToCFXWideString(); 2092 CFX_WideString wsFieldName = jsValue.ToCFXWideString();
2096 2093
2097 for (int j=0,jsz=pInterForm->CountFields(wsFieldName); j<jsz; j++) 2094 for (int j=0,jsz=pInterForm->CountFields(wsFieldName); j<jsz; j++)
2098 » » { 2095 {
2099 » » » if (CPDF_FormField* pFormField = pInterForm->GetField(j, wsFieldName)) 2096 if (CPDF_FormField* pFormField = pInterForm->GetField(j, wsFieldName ))
2100 » » » { 2097 {
2101 » » » » double dTemp = 0.0; 2098 double dTemp = 0.0;
2102 2099
2103 » » » » switch (pFormField->GetFieldType()) 2100 switch (pFormField->GetFieldType())
2104 » » » » { 2101 {
2105 » » » » case FIELDTYPE_TEXTFIELD: 2102 case FIELDTYPE_TEXTFIELD:
2106 » » » » case FIELDTYPE_COMBOBOX: 2103 case FIELDTYPE_COMBOBOX:
2107 » » » » » { 2104 {
2108 » » » » » » dTemp = ParseStringToNumber(pFor mField->GetValue().c_str()); 2105 dTemp = ParseStringToNumber(pFormField->GetValue().c_str ());
2109 » » » » » » break; 2106 break;
2110 » » » » » } 2107 }
2111 » » » » case FIELDTYPE_PUSHBUTTON: 2108 case FIELDTYPE_PUSHBUTTON:
2112 » » » » » { 2109 {
2113 » » » » » » dTemp = 0.0; 2110 dTemp = 0.0;
2114 » » » » » » break; 2111 break;
2115 » » » » » } 2112 }
2116 » » » » case FIELDTYPE_CHECKBOX: 2113 case FIELDTYPE_CHECKBOX:
2117 » » » » case FIELDTYPE_RADIOBUTTON: 2114 case FIELDTYPE_RADIOBUTTON:
2118 » » » » » { 2115 {
2119 » » » » » » dTemp = 0.0; 2116 dTemp = 0.0;
2120 » » » » » » for (int c=0,csz=pFormField->Cou ntControls(); c<csz; c++) 2117 for (int c=0,csz=pFormField->CountControls(); c<csz; c++ )
2121 » » » » » » { 2118 {
2122 » » » » » » » if (CPDF_FormControl* pF ormCtrl = pFormField->GetControl(c)) 2119 if (CPDF_FormControl* pFormCtrl = pFormField->GetCon trol(c))
2123 » » » » » » » { 2120 {
2124 » » » » » » » » if (pFormCtrl->I sChecked()) 2121 if (pFormCtrl->IsChecked())
2125 » » » » » » » » { 2122 {
2126 » » » » » » » » » dTemp += ParseStringToNumber(pFormCtrl->GetExportValue().c_str()); 2123 dTemp += ParseStringToNumber(pFormCtrl->GetE xportValue().c_str());
2127 » » » » » » » » » break; 2124 break;
2128 » » » » » » » » } 2125 }
2129 » » » » » » » » else 2126 else
2130 » » » » » » » » » continue ; 2127 continue;
2131 » » » » » » » } 2128 }
2132 » » » » » » } 2129 }
2133 » » » » » » break; 2130 break;
2134 » » » » » } 2131 }
2135 » » » » case FIELDTYPE_LISTBOX: 2132 case FIELDTYPE_LISTBOX:
2136 » » » » » { 2133 {
2137 » » » » » » dTemp = 0.0; 2134 dTemp = 0.0;
2138 » » » » » » if (pFormField->CountSelectedIte ms() > 1) 2135 if (pFormField->CountSelectedItems() > 1)
2139 » » » » » » » break; 2136 break;
2140 » » » » » » else 2137 else
2141 » » » » » » { 2138 {
2142 » » » » » » » dTemp = ParseStringToNum ber(pFormField->GetValue().c_str()); 2139 dTemp = ParseStringToNumber(pFormField->GetValue().c _str());
2143 » » » » » » » break; 2140 break;
2144 » » » » » » } 2141 }
2145 » » » » » } 2142 }
2146 » » » » default: 2143 default:
2147 » » » » » break; 2144 break;
2148 » » » » } 2145 }
2149 2146
2150 » » » » if (i == 0 && j == 0 && (wcscmp(sFunction.c_str( ), L"MIN") == 0 || wcscmp(sFunction.c_str(), L"MAX") == 0)) 2147 if (i == 0 && j == 0 && (wcscmp(sFunction.c_str(), L"MIN") == 0 || wcscmp(sFunction.c_str(), L"MAX") == 0))
2151 » » » » » dValue = dTemp; 2148 dValue = dTemp;
2152 2149
2153 » » » » dValue = AF_Simple(sFunction.c_str(), dValue, dT emp); 2150 dValue = AF_Simple(sFunction.c_str(), dValue, dTemp);
2154 2151
2155 » » » » nFieldsCount++; 2152 nFieldsCount++;
2156 » » » } 2153 }
2157 » » } 2154 }
2158 » } 2155 }
2159 2156
2160 » if (wcscmp(sFunction.c_str(), L"AVG") == 0 && nFieldsCount > 0) 2157 if (wcscmp(sFunction.c_str(), L"AVG") == 0 && nFieldsCount > 0)
2161 » » dValue /= nFieldsCount; 2158 dValue /= nFieldsCount;
2162 2159
2163 » dValue = (double)floor(dValue * FXSYS_pow((double)10,(double)6) + 0.49) / FXSYS_pow((double)10,(double)6); 2160 dValue = (double)floor(dValue * FXSYS_pow((double)10,(double)6) + 0.49) / FX SYS_pow((double)10,(double)6);
2164 » CJS_Value jsValue(isolate,dValue); 2161 CJS_Value jsValue(isolate,dValue);
2165 » if((CJS_EventHandler*)pContext->GetEventHandler()->m_pValue) 2162 if((CJS_EventHandler*)pContext->GetEventHandler()->m_pValue)
2166 » » ((CJS_EventHandler*)pContext->GetEventHandler())->Value() = jsVa lue.ToCFXWideString(); 2163 ((CJS_EventHandler*)pContext->GetEventHandler())->Value() = jsValue.ToCF XWideString();
2167 2164
2168 » return TRUE; 2165 return TRUE;
2169 } 2166 }
2170 2167
2171 /* This function validates the current event to ensure that its value is 2168 /* This function validates the current event to ensure that its value is
2172 ** within the specified range. */ 2169 ** within the specified range. */
2173 2170
2174 FX_BOOL CJS_PublicMethods::AFRange_Validate(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError) 2171 FX_BOOL CJS_PublicMethods::AFRange_Validate(IFXJS_Context* cc, const CJS_Paramet ers& params, CJS_Value& vRet, CFX_WideString& sError)
2175 { 2172 {
2176 » CJS_Context* pContext = (CJS_Context *)cc; 2173 CJS_Context* pContext = (CJS_Context *)cc;
2177 » ASSERT(pContext != NULL); 2174 ASSERT(pContext != NULL);
2178 » CJS_EventHandler* pEvent = pContext->GetEventHandler(); 2175 CJS_EventHandler* pEvent = pContext->GetEventHandler();
2179 » ASSERT(pEvent != NULL); 2176 ASSERT(pEvent != NULL);
2180 2177
2181 » if (params.size() != 4) 2178 if (params.size() != 4)
2182 » { 2179 {
2183 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 2180 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2184 » » return FALSE; 2181 return FALSE;
2185 » } 2182 }
2186 2183
2187 » if(!pEvent->m_pValue) 2184 if(!pEvent->m_pValue)
2188 » » return FALSE; 2185 return FALSE;
2189 » if (pEvent->Value().IsEmpty() ) 2186 if (pEvent->Value().IsEmpty() )
2190 » » return TRUE; 2187 return TRUE;
2191 » double dEentValue = atof(CFX_ByteString::FromUnicode(pEvent->Value())); 2188 double dEentValue = atof(CFX_ByteString::FromUnicode(pEvent->Value()));
2192 » FX_BOOL bGreaterThan = params[0].ToBool(); 2189 FX_BOOL bGreaterThan = params[0].ToBool();
2193 » double dGreaterThan = params[1].ToDouble(); 2190 double dGreaterThan = params[1].ToDouble();
2194 » FX_BOOL bLessThan = params[2].ToBool(); 2191 FX_BOOL bLessThan = params[2].ToBool();
2195 » double dLessThan = params[3].ToDouble(); 2192 double dLessThan = params[3].ToDouble();
2196 » CFX_WideString swMsg; 2193 CFX_WideString swMsg;
2197 2194
2198 » if (bGreaterThan && bLessThan) 2195 if (bGreaterThan && bLessThan)
2199 » { 2196 {
2200 » » if (dEentValue < dGreaterThan || dEentValue > dLessThan) 2197 if (dEentValue < dGreaterThan || dEentValue > dLessThan)
2201 » » » swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRA NGE1).c_str(), 2198 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE1).c_str( ),
2202 » » » » » » params[1].ToCFXWideString().c_s tr(), 2199 params[1].ToCFXWideString().c_str(),
2203 » » » » » » params[3].ToCFXWideString().c_s tr()); 2200 params[3].ToCFXWideString().c_str());
2204 » } 2201 }
2205 » else if (bGreaterThan) 2202 else if (bGreaterThan)
2206 » { 2203 {
2207 » » if (dEentValue < dGreaterThan) 2204 if (dEentValue < dGreaterThan)
2208 » » » swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRA NGE2).c_str(), 2205 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE2).c_str( ),
2209 » » » » » » params[1].ToCFXWideString().c_s tr()); 2206 params[1].ToCFXWideString().c_str());
2210 » } 2207 }
2211 » else if (bLessThan) 2208 else if (bLessThan)
2212 » { 2209 {
2213 » » if (dEentValue > dLessThan) 2210 if (dEentValue > dLessThan)
2214 » » » swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRA NGE3).c_str(), 2211 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE3).c_str( ),
2215 » » » » » » params[3].ToCFXWideString().c_s tr()); 2212 params[3].ToCFXWideString().c_str());
2216 » } 2213 }
2217 2214
2218 » if (!swMsg.IsEmpty()) 2215 if (!swMsg.IsEmpty())
2219 » { 2216 {
2220 » » Alert(pContext, swMsg.c_str()); 2217 Alert(pContext, swMsg.c_str());
2221 » » pEvent->Rc() = FALSE; 2218 pEvent->Rc() = FALSE;
2222 » } 2219 }
2223 » return TRUE; 2220 return TRUE;
2224 } 2221 }
2225 2222
2226 FX_BOOL CJS_PublicMethods::AFExtractNums(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError) 2223 FX_BOOL CJS_PublicMethods::AFExtractNums(IFXJS_Context* cc, const CJS_Parameters & params, CJS_Value& vRet, CFX_WideString& sError)
2227 { 2224 {
2228 » v8::Isolate* isolate = ::GetIsolate(cc); 2225 v8::Isolate* isolate = ::GetIsolate(cc);
2229 » CJS_Context* pContext = (CJS_Context*)cc; 2226 CJS_Context* pContext = (CJS_Context*)cc;
2230 » ASSERT(pContext != NULL); 2227 ASSERT(pContext != NULL);
2231 2228
2232 » if (params.size() != 1) 2229 if (params.size() != 1)
2233 » { 2230 {
2234 » » sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR); 2231 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
2235 » » return FALSE; 2232 return FALSE;
2236 » } 2233 }
2237 2234
2238 » CJS_Array nums(isolate); 2235 CJS_Array nums(isolate);
2239 2236
2240 » CFX_WideString str = params[0].ToCFXWideString(); 2237 CFX_WideString str = params[0].ToCFXWideString();
2241 » CFX_WideString sPart; 2238 CFX_WideString sPart;
2242 2239
2243 » if (str.GetAt(0) == L'.' || str.GetAt(0) == L',') 2240 if (str.GetAt(0) == L'.' || str.GetAt(0) == L',')
2244 » » str = L"0" + str; 2241 str = L"0" + str;
2245 2242
2246 » int nIndex = 0; 2243 int nIndex = 0;
2247 » for (int i=0, sz=str.GetLength(); i<sz; i++) 2244 for (int i=0, sz=str.GetLength(); i<sz; i++)
2248 » { 2245 {
2249 » » FX_WCHAR wc = str.GetAt(i); 2246 FX_WCHAR wc = str.GetAt(i);
2250 » » if (IsDigit((wchar_t)wc)) 2247 if (IsDigit((wchar_t)wc))
2251 » » { 2248 {
2252 » » » sPart += wc; 2249 sPart += wc;
2253 » » } 2250 }
2254 » » else 2251 else
2255 » » { 2252 {
2256 » » » if (sPart.GetLength() > 0) 2253 if (sPart.GetLength() > 0)
2257 » » » { 2254 {
2258 » » » » nums.SetElement(nIndex,CJS_Value(isolate,sPart.c _str())); 2255 nums.SetElement(nIndex,CJS_Value(isolate,sPart.c_str()));
2259 » » » » sPart = L""; 2256 sPart = L"";
2260 » » » » nIndex ++; 2257 nIndex ++;
2261 » » » } 2258 }
2262 » » } 2259 }
2263 » } 2260 }
2264 2261
2265 » if (sPart.GetLength() > 0) 2262 if (sPart.GetLength() > 0)
2266 » { 2263 {
2267 » » nums.SetElement(nIndex,CJS_Value(isolate,sPart.c_str())); 2264 nums.SetElement(nIndex,CJS_Value(isolate,sPart.c_str()));
2268 » } 2265 }
2269 2266
2270 » if (nums.GetLength() > 0) 2267 if (nums.GetLength() > 0)
2271 » » vRet = nums; 2268 vRet = nums;
2272 » else 2269 else
2273 » » vRet.SetNull(); 2270 vRet.SetNull();
2274 2271
2275 » return TRUE; 2272 return TRUE;
2276 } 2273 }
OLDNEW
« no previous file with comments | « fpdfsdk/src/javascript/JS_Runtime.cpp ('k') | fpdfsdk/src/javascript/global.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698