fpdfsdk/src/javascript/JS_Value.cpp

   1 // Copyright 2014 PDFium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
   6
   7 #include "../../include/javascript/JavaScript.h"
   8 #include "../../include/javascript/JS_Define.h"
   9 #include "../../include/javascript/JS_Object.h"
  10 #include "../../include/javascript/JS_Value.h"
  11 #include "../../include/javascript/Document.h"
  12
  13 /* ---------------------------- CJS_Value ---------------------------- */
  14
  15 CJS_Value::CJS_Value(v8::Isolate* isolate) : m_eType(VT_unknown),m_isolate(isolate)
  16 {
  17 }
  18 CJS_Value::CJS_Value(v8::Isolate* isolate, v8::Handle<v8::Value> pValue,FXJSVALUETYPE t) :
  19         m_pValue(pValue), m_eType(t), m_isolate(isolate)
  20 {
  21 }
  22
  23 CJS_Value::CJS_Value(v8::Isolate* isolate, const int &iValue):m_isolate(isolate)
  24 {
  25         operator =(iValue);
  26 }
  27
  28 CJS_Value::CJS_Value(v8::Isolate* isolate, const bool &bValue):m_isolate(isolate)
  29 {
  30         operator =(bValue);
  31 }
  32
  33 CJS_Value::CJS_Value(v8::Isolate* isolate, const float &fValue):m_isolate(isolate)
  34 {
  35         operator =(fValue);
  36 }
  37
  38 CJS_Value::CJS_Value(v8::Isolate* isolate, const double &dValue):m_isolate(isolate)
  39 {
  40         operator =(dValue);
  41 }
  42
  43 CJS_Value::CJS_Value(v8::Isolate* isolate, JSFXObject  pJsObj):m_isolate(isolate)
  44 {
  45         operator =(pJsObj);
  46 }
  47
  48 CJS_Value::CJS_Value(v8::Isolate* isolate, CJS_Object* pJsObj):m_isolate(isolate)
  49 {
  50         operator =(pJsObj);
  51 }
  52
  53 CJS_Value::CJS_Value(v8::Isolate* isolate, CJS_Document* pJsDoc):m_isolate(isolate)
  54 {
  55         m_eType = VT_object;
  56         if (pJsDoc)
  57                 m_pValue = (JSFXObject)*pJsDoc;
  58 }
  59
  60 CJS_Value::CJS_Value(v8::Isolate* isolate, FX_LPCWSTR pWstr):m_isolate(isolate)
  61 {
  62         operator =(pWstr);
  63 }
  64
  65 CJS_Value::CJS_Value(v8::Isolate* isolate, FX_LPCSTR pStr):m_isolate(isolate)
  66 {
  67         operator = (pStr);
  68 }
  69
  70 CJS_Value::CJS_Value(v8::Isolate* isolate, CJS_Array& array):m_isolate(isolate)
  71 {
  72         operator = (array);
  73 }
  74
  75 CJS_Value::~CJS_Value()
  76 {
  77 }
  78
  79 void CJS_Value::Attach(v8::Handle<v8::Value> pValue,FXJSVALUETYPE t)
  80 {
  81         m_pValue = pValue;
  82         m_eType = t;
  83 }
  84
  85 void CJS_Value::Attach(CJS_Value *pValue)
  86 {
  87         if (pValue)
  88                 Attach(pValue->ToJSValue(),pValue->GetType());
  89 }
  90
  91 void CJS_Value::Detach()
  92 {
  93         m_pValue = v8::Handle<v8::Value>();
  94         m_eType = VT_unknown;
  95 }
  96
  97 /* ---------------------------------------------------------------------------------------- */
  98
  99 CJS_Value::operator int() const
 100 {
 101
 102         return JS_ToInt32(m_pValue);
 103
 104 }
 105
 106 CJS_Value::operator bool() const
 107 {
 108
 109         return JS_ToBoolean(m_pValue);
 110
 111 }
 112
 113 CJS_Value::operator double() const
 114 {
 115
 116         return JS_ToNumber(m_pValue);
 117
 118 }
 119
 120 CJS_Value::operator float() const
 121 {
 122
 123         return (float)JS_ToNumber(m_pValue);
 124
 125 }
 126
 127 CJS_Value::operator CJS_Object *() const
 128 {
 129
 130         v8::Handle<v8::Object>  pObj = JS_ToObject(m_pValue);
 131         return (CJS_Object*)JS_GetPrivate(m_isolate, pObj);
 132 }
 133
 134 CJS_Value::operator v8::Handle<v8::Object>() const
 135 {
 136         return JS_ToObject(m_pValue);
 137 }
 138
 139 CJS_Value::operator CFX_WideString() const
 140 {
 141         return JS_ToString(m_pValue);
 142 }
 143
 144 CJS_Value::operator CFX_ByteString() const
 145 {
 146         return CFX_ByteString::FromUnicode(operator CFX_WideString());
 147 }
 148
 149 v8::Handle<v8::Value> CJS_Value::ToJSValue()
 150 {
 151         return m_pValue;
 152 }
 153
 154
 155 CJS_Value::operator v8::Handle<v8::Array>() const
 156 {
 157         if (IsArrayObject())
 158                 return v8::Handle<v8::Array>::Cast(JS_ToObject(m_pValue));
 159         return v8::Handle<v8::Array>();
 160 }
 161
 162 /* ---------------------------------------------------------------------------------------- */
 163
 164 void CJS_Value::operator =(int iValue)
 165 {
 166         m_pValue = JS_NewNumber(m_isolate, iValue);
 167
 168         m_eType = VT_number;
 169 }
 170
 171 void CJS_Value::operator =(bool bValue)
 172 {
 173         m_pValue = JS_NewBoolean(m_isolate, bValue);
 174
 175         m_eType = VT_boolean;
 176 }
 177
 178 void CJS_Value::operator =(double dValue)
 179 {
 180         m_pValue = JS_NewNumber(m_isolate,dValue);
 181
 182         m_eType = VT_number;
 183 }
 184
 185 void CJS_Value::operator = (float fValue)
 186 {
 187         m_pValue = JS_NewNumber(m_isolate,fValue);
 188         m_eType = VT_number;
 189 }
 190
 191 void CJS_Value::operator =(v8::Handle<v8::Object> pObj)
 192 {
 193
 194         m_pValue = JS_NewObject(m_isolate,pObj);
 195
 196         m_eType = VT_fxobject;
 197 }
 198
 199 void CJS_Value::operator =(CJS_Object * pObj)
 200 {
 201         if (pObj)
 202                 operator = ((JSFXObject)*pObj);
 203 }
 204
 205 void CJS_Value::operator = (CJS_Document* pJsDoc)
 206 {
 207         m_eType = VT_object;
 208         if (pJsDoc) {
 209                 m_pValue = static_cast<JSFXObject>(*pJsDoc);
 210         }
 211 }
 212
 213 void CJS_Value::operator =(FX_LPCWSTR pWstr)
 214 {
 215         m_pValue = JS_NewString(m_isolate,(wchar_t *)pWstr);
 216
 217         m_eType = VT_string;
 218 }
 219
 220 void CJS_Value::SetNull()
 221 {
 222         m_pValue = JS_NewNull();
 223
 224         m_eType = VT_null;
 225 }
 226
 227 void CJS_Value::operator = (FX_LPCSTR pStr)
 228 {
 229         operator = (CFX_WideString::FromLocal(pStr));
 230 }
 231
 232 void CJS_Value::operator = (CJS_Array & array)
 233 {
 234         m_pValue = JS_NewObject2(m_isolate,(v8::Handle<v8::Array>)array);
 235
 236         m_eType = VT_object;
 237 }
 238
 239 void CJS_Value::operator = (CJS_Date & date)
 240 {
 241         m_pValue = JS_NewDate(m_isolate, (double)date);
 242
 243         m_eType = VT_date;
 244 }
 245
 246 void CJS_Value::operator = (CJS_Value value)
 247 {
 248         m_pValue = value.ToJSValue();
 249
 250         m_eType = value.m_eType;
 251 }
 252
 253 /* ---------------------------------------------------------------------------------------- */
 254
 255 FXJSVALUETYPE CJS_Value::GetType() const
 256 {
 257         if(m_pValue.IsEmpty()) return VT_unknown;
 258         if(m_pValue->IsString()) return VT_string;
 259         if(m_pValue->IsNumber()) return VT_number;
 260         if(m_pValue->IsBoolean()) return VT_boolean;
 261         if(m_pValue->IsDate()) return VT_date;
 262         if(m_pValue->IsObject()) return VT_object;
 263         if(m_pValue->IsNull()) return VT_null;
 264         if(m_pValue->IsUndefined()) return VT_undefined;
 265         return VT_unknown;
 266 }
 267
 268 FX_BOOL CJS_Value::IsArrayObject() const
 269 {
 270         if(m_pValue.IsEmpty()) return FALSE;
 271         return m_pValue->IsArray();
 272 }
 273
 274 FX_BOOL CJS_Value::IsDateObject() const
 275 {
 276         if(m_pValue.IsEmpty()) return FALSE;
 277         return m_pValue->IsDate();
 278 }
 279
 280 //CJS_Value::operator CJS_Array()
 281 FX_BOOL CJS_Value::ConvertToArray(CJS_Array &array) const
 282 {
 283         if (IsArrayObject())
 284         {
 285                 array.Attach(JS_ToArray(m_pValue));
 286                 return TRUE;
 287         }
 288
 289         return FALSE;
 290 }
 291
 292 FX_BOOL CJS_Value::ConvertToDate(CJS_Date &date) const
 293 {
 294 //      if (GetType() == VT_date)
 295 //      {
 296 //              date = (double)(*this);
 297 //              return TRUE;
 298 //      }
 299
 300         if (IsDateObject())
 301         {
 302                 date.Attach(m_pValue);
 303                 return TRUE;
 304         }
 305
 306         return FALSE;
 307 }
 308
 309 /* ---------------------------- CJS_PropValue ---------------------------- */
 310
 311 CJS_PropValue::CJS_PropValue(const CJS_Value &value) :
 312         CJS_Value(value),
 313         m_bIsSetting(0)
 314 {
 315 }
 316
 317 CJS_PropValue::CJS_PropValue(v8::Isolate* isolate) : CJS_Value(isolate),
 318                                  m_bIsSetting(0)
 319 {
 320 }
 321
 322 CJS_PropValue::~CJS_PropValue()
 323 {
 324 }
 325
 326 FX_BOOL CJS_PropValue::IsSetting()
 327 {
 328         return m_bIsSetting;
 329 }
 330
 331 FX_BOOL CJS_PropValue::IsGetting()
 332 {
 333         return !m_bIsSetting;
 334 }
 335
 336 void CJS_PropValue::operator <<(int iValue)
 337 {
 338         ASSERT(!m_bIsSetting);
 339         CJS_Value::operator =(iValue);
 340 }
 341
 342 void CJS_PropValue::operator >>(int & iValue) const
 343 {
 344         ASSERT(m_bIsSetting);
 345         iValue = CJS_Value::operator int();
 346 }
 347
 348
 349 void CJS_PropValue::operator <<(bool bValue)
 350 {
 351         ASSERT(!m_bIsSetting);
 352         CJS_Value::operator =(bValue);
 353 }
 354
 355 void CJS_PropValue::operator >>(bool& bValue) const
 356 {
 357         ASSERT(m_bIsSetting);
 358         bValue = CJS_Value::operator bool();
 359
 360 }
 361
 362 void CJS_PropValue::operator <<(double dValue)
 363 {
 364         ASSERT(!m_bIsSetting);
 365         CJS_Value::operator =(dValue);
 366 }
 367
 368 void CJS_PropValue::operator >>(double& dValue) const
 369 {
 370         ASSERT(m_bIsSetting);
 371         dValue = CJS_Value::operator double();
 372 }
 373
 374 void CJS_PropValue::operator <<(CJS_Object* pObj)
 375 {
 376         ASSERT(!m_bIsSetting);
 377         CJS_Value::operator = (pObj);
 378 }
 379
 380 void CJS_PropValue::operator >>(CJS_Object*& ppObj) const
 381 {
 382         ASSERT(m_bIsSetting);
 383         ppObj = CJS_Value::operator CJS_Object *();
 384 }
 385
 386 void CJS_PropValue::operator <<(CJS_Document* pJsDoc)
 387 {
 388         ASSERT(!m_bIsSetting);
 389         CJS_Value::operator = (pJsDoc);
 390 }
 391
 392 void CJS_PropValue::operator >>(CJS_Document*& ppJsDoc) const
 393 {
 394         ASSERT(m_bIsSetting);
 395         ppJsDoc = static_cast<CJS_Document*>(CJS_Value::operator CJS_Object *());
 396 }
 397
 398 void CJS_PropValue::operator<<(JSFXObject pObj)
 399 {
 400         ASSERT(!m_bIsSetting);
 401         CJS_Value::operator = (pObj);
 402 }
 403
 404 void CJS_PropValue::operator>>(JSFXObject &ppObj) const
 405 {
 406         ASSERT(m_bIsSetting);
 407         ppObj = CJS_Value::operator JSFXObject ();
 408 }
 409
 410
 411 void CJS_PropValue::StartSetting()
 412 {
 413         m_bIsSetting = 1;
 414 }
 415
 416 void CJS_PropValue::StartGetting()
 417 {
 418         m_bIsSetting = 0;
 419 }
 420 void CJS_PropValue::operator <<(CFX_ByteString string)
 421 {
 422         ASSERT(!m_bIsSetting);
 423         CJS_Value::operator = (string.c_str());
 424 }
 425
 426 void CJS_PropValue::operator >>(CFX_ByteString &string) const
 427 {
 428         ASSERT(m_bIsSetting);
 429         string = CJS_Value::operator CFX_ByteString();
 430 }
 431
 432 void CJS_PropValue::operator <<(FX_LPCWSTR c_string)
 433 {
 434         ASSERT(!m_bIsSetting);
 435         CJS_Value::operator =(c_string);
 436 }
 437
 438 void CJS_PropValue::operator >>(CFX_WideString &wide_string) const
 439 {
 440         ASSERT(m_bIsSetting);
 441         wide_string = CJS_Value::operator CFX_WideString();
 442 }
 443
 444 void CJS_PropValue::operator <<(CFX_WideString wide_string)
 445 {
 446         ASSERT(!m_bIsSetting);
 447         CJS_Value::operator = (wide_string);
 448 }
 449
 450 void CJS_PropValue::operator >>(CJS_Array &array) const
 451 {
 452         ASSERT(m_bIsSetting);
 453         ConvertToArray(array);
 454 }
 455
 456 void CJS_PropValue::operator <<(CJS_Array &array)
 457 {
 458         ASSERT(!m_bIsSetting);
 459         CJS_Value::operator=(array);
 460 }
 461
 462 void CJS_PropValue::operator>>(CJS_Date &date) const
 463 {
 464         ASSERT(m_bIsSetting);
 465         ConvertToDate(date);
 466 }
 467
 468 void CJS_PropValue::operator<<(CJS_Date &date)
 469 {
 470         ASSERT(!m_bIsSetting);
 471         CJS_Value::operator=(date);
 472 }
 473
 474 CJS_PropValue::operator v8::Handle<v8::Value>() const
 475 {
 476         return m_pValue;
 477 }
 478
 479 /* ======================================== CJS_Array ========================================= */
 480 CJS_Array::CJS_Array(v8::Isolate* isolate):m_isolate(isolate)
 481 {
 482 }
 483
 484 CJS_Array::~CJS_Array()
 485 {
 486 }
 487
 488 void CJS_Array::Attach(v8::Handle<v8::Array> pArray)
 489 {
 490         m_pArray = pArray;
 491 }
 492
 493 FX_BOOL CJS_Array::IsAttached()
 494 {
 495         return FALSE;
 496 }
 497
 498 void CJS_Array::GetElement(unsigned index,CJS_Value &value)
 499 {
 500         if (m_pArray.IsEmpty())
 501                 return;
 502         v8::Handle<v8::Value>  p = JS_GetArrayElemnet(m_pArray,index);
 503         value.Attach(p,VT_object);
 504 }
 505
 506 void CJS_Array::SetElement(unsigned index,CJS_Value value)
 507 {
 508         if (m_pArray.IsEmpty())
 509                 m_pArray = JS_NewArray(m_isolate);
 510
 511         JS_PutArrayElement(m_pArray,index,value.ToJSValue(),value.GetType());
 512 }
 513
 514 int CJS_Array::GetLength()
 515 {
 516         if (m_pArray.IsEmpty())
 517                 return 0;
 518         return JS_GetArrayLength(m_pArray);
 519 }
 520
 521 CJS_Array:: operator v8::Handle<v8::Array>()
 522 {
 523         if (m_pArray.IsEmpty())
 524                 m_pArray = JS_NewArray(m_isolate);
 525
 526         return m_pArray;
 527 }
 528
 529 /* ======================================== CJS_Date ========================================= */
 530
 531 CJS_Date::CJS_Date(v8::Isolate* isolate) :m_isolate(isolate)
 532 {
 533 }
 534
 535 CJS_Date::CJS_Date(v8::Isolate* isolate,double dMsec_time)
 536 {
 537         m_isolate = isolate;
 538         m_pDate = JS_NewDate(isolate,dMsec_time);
 539 }
 540
 541 CJS_Date::CJS_Date(v8::Isolate* isolate,int year, int mon, int day,int hour, int min, int sec)
 542 {
 543         m_isolate = isolate;
 544         m_pDate = JS_NewDate(isolate,MakeDate(year,mon,day,hour,min,sec,0));
 545 }
 546
 547 double CJS_Date::MakeDate(int year, int mon, int day,int hour, int min, int sec,int ms)
 548 {
 549         return JS_MakeDate(JS_MakeDay(year,mon,day), JS_MakeTime(hour,min,sec,ms));
 550 }
 551
 552 CJS_Date::~CJS_Date()
 553 {
 554 }
 555
 556 FX_BOOL CJS_Date::IsValidDate()
 557 {
 558         if(m_pDate.IsEmpty()) return FALSE;
 559         return !JS_PortIsNan(JS_ToNumber(m_pDate));
 560 }
 561
 562 void CJS_Date::Attach(v8::Handle<v8::Value> pDate)
 563 {
 564         m_pDate = pDate;
 565 }
 566
 567 int CJS_Date::GetYear()
 568 {
 569         if (IsValidDate())
 570                 return JS_GetYearFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
 571
 572         return 0;
 573 }
 574
 575 void CJS_Date::SetYear(int iYear)
 576 {
 577         double date = MakeDate(iYear,GetMonth(),GetDay(),GetHours(),GetMinutes(),GetSeconds(),0);
 578         JS_ValueCopy(m_pDate, JS_NewDate(m_isolate,date));
 579 }
 580
 581 int CJS_Date::GetMonth()
 582 {
 583         if (IsValidDate())
 584                 return JS_GetMonthFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
 585
 586         return 0;
 587 }
 588
 589 void CJS_Date::SetMonth(int iMonth)
 590 {
 591
 592         double date = MakeDate(GetYear(),iMonth,GetDay(),GetHours(),GetMinutes(),GetSeconds(),0);
 593         JS_ValueCopy(m_pDate, JS_NewDate(m_isolate,date));
 594
 595 }
 596
 597 int CJS_Date::GetDay()
 598 {
 599         if (IsValidDate())
 600                 return JS_GetDayFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
 601
 602         return 0;
 603 }
 604
 605 void CJS_Date::SetDay(int iDay)
 606 {
 607
 608         double date = MakeDate(GetYear(),GetMonth(),iDay,GetHours(),GetMinutes(),GetSeconds(),0);
 609         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 610
 611 }
 612
 613 int CJS_Date::GetHours()
 614 {
 615         if (IsValidDate())
 616                 return JS_GetHourFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
 617
 618         return 0;
 619 }
 620
 621 void CJS_Date::SetHours(int iHours)
 622 {
 623         double date = MakeDate(GetYear(),GetMonth(),GetDay(),iHours,GetMinutes(),GetSeconds(),0);
 624         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 625 }
 626
 627 int CJS_Date::GetMinutes()
 628 {
 629         if (IsValidDate())
 630                 return JS_GetMinFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
 631
 632         return 0;
 633 }
 634
 635 void CJS_Date::SetMinutes(int minutes)
 636 {
 637         double date = MakeDate(GetYear(),GetMonth(),GetDay(),GetHours(),minutes,GetSeconds(),0);
 638         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 639 }
 640
 641 int CJS_Date::GetSeconds()
 642 {
 643         if (IsValidDate())
 644                 return JS_GetSecFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
 645
 646         return 0;
 647 }
 648
 649 void CJS_Date::SetSeconds(int seconds)
 650 {
 651         double date = MakeDate(GetYear(),GetMonth(),GetDay(),GetHours(),GetMinutes(),seconds,0);
 652         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 653 }
 654
 655 CJS_Date::operator v8::Handle<v8::Value>()
 656 {
 657         return m_pDate;
 658 }
 659
 660 CJS_Date::operator double() const
 661 {
 662         if(m_pDate.IsEmpty())
 663                 return 0.0;
 664         return JS_ToNumber(m_pDate);
 665 }
 666
 667 CFX_WideString CJS_Date::ToString() const
 668 {
 669         if(m_pDate.IsEmpty())
 670                 return L"";
 671         return JS_ToString(m_pDate);
 672 }