source/gui/scripting/JSInterface_IGUIObject.cpp

   1 /* Copyright (C) 2017 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "precompiled.h"
  19
  20 #include "JSInterface_IGUIObject.h"
  21 #include "JSInterface_GUITypes.h"
  22
  23 #include "gui/IGUIObject.h"
  24 #include "gui/CGUI.h"
  25 #include "gui/IGUIScrollBar.h"
  26 #include "gui/CList.h"
  27 #include "gui/GUIManager.h"
  28
  29 #include "ps/CLogger.h"
  30
  31 #include "scriptinterface/ScriptInterface.h"
  32 #include "scriptinterface/ScriptExtraHeaders.h"
  33
  34 JSClass JSI_IGUIObject::JSI_class = {
  35         "GUIObject", JSCLASS_HAS_PRIVATE,
  36         nullptr, nullptr,
  37         JSI_IGUIObject::getProperty, JSI_IGUIObject::setProperty,
  38         nullptr, nullptr, nullptr, nullptr,
  39         nullptr, nullptr, JSI_IGUIObject::construct, nullptr
  40 };
  41
  42 JSPropertySpec JSI_IGUIObject::JSI_props[] =
  43 {
  44         { 0 }
  45 };
  46
  47 JSFunctionSpec JSI_IGUIObject::JSI_methods[] =
  48 {
  49         JS_FS("toString", JSI_IGUIObject::toString, 0, 0),
  50         JS_FS("focus", JSI_IGUIObject::focus, 0, 0),
  51         JS_FS("blur", JSI_IGUIObject::blur, 0, 0),
  52         JS_FS("getComputedSize", JSI_IGUIObject::getComputedSize, 0, 0),
  53         JS_FS_END
  54 };
  55
  56 bool JSI_IGUIObject::getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp)
  57 {
  58         JSAutoRequest rq(cx);
  59         ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
  60
  61         IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, obj, &JSI_IGUIObject::JSI_class, NULL);
  62         if (!e)
  63                 return false;
  64
  65         JS::RootedValue idval(cx);
  66         if (!JS_IdToValue(cx, id, &idval))
  67                 return false;
  68
  69         std::string propName;
  70         if (!ScriptInterface::FromJSVal(cx, idval, propName))
  71                 return false;
  72
  73         // Skip some things which are known to be functions rather than properties.
  74         // ("constructor" *must* be here, else it'll try to GetSettingType before
  75         // the private IGUIObject* has been set (and thus crash). The others are
  76         // partly for efficiency, and also to allow correct reporting of attempts to
  77         // access nonexistent properties.)
  78         if (propName == "constructor" ||
  79                 propName == "prototype"   ||
  80                 propName == "toString"    ||
  81                 propName == "toJSON"      ||
  82                 propName == "focus"       ||
  83                 propName == "blur"        ||
  84                 propName == "getComputedSize"
  85            )
  86                 return true;
  87
  88         // Use onWhatever to access event handlers
  89         if (propName.substr(0, 2) == "on")
  90         {
  91                 CStr eventName(CStr(propName.substr(2)).LowerCase());
  92                 std::map<CStr, JS::Heap<JSObject*>>::iterator it = e->m_ScriptHandlers.find(eventName);
  93                 if (it == e->m_ScriptHandlers.end())
  94                         vp.setNull();
  95                 else
  96                         vp.setObject(*it->second.get());
  97                 return true;
  98         }
  99
 100         if (propName == "parent")
 101         {
 102                 IGUIObject* parent = e->GetParent();
 103
 104                 if (parent)
 105                         vp.set(JS::ObjectValue(*parent->GetJSObject()));
 106                 else
 107                         vp.set(JS::NullValue());
 108
 109                 return true;
 110         }
 111         else if (propName == "children")
 112         {
 113                 JS::RootedObject obj(cx, JS_NewArrayObject(cx, JS::HandleValueArray::empty()));
 114                 vp.setObject(*obj);
 115
 116                 for (size_t i = 0; i < e->m_Children.size(); ++i)
 117                 {
 118                         JS::RootedValue val(cx);
 119                         ScriptInterface::ToJSVal(cx, &val, e->m_Children[i]);
 120                         JS_SetElement(cx, obj, i, val);
 121                 }
 122
 123                 return true;
 124         }
 125         else if (propName == "name")
 126         {
 127                 vp.set(JS::StringValue(JS_NewStringCopyZ(cx, e->GetName().c_str())));
 128                 return true;
 129         }
 130         else
 131         {
 132                 // Retrieve the setting's type (and make sure it actually exists)
 133                 EGUISettingType Type;
 134                 if (e->GetSettingType(propName, Type) != PSRETURN_OK)
 135                 {
 136                         JS_ReportError(cx, "Invalid GUIObject property '%s'", propName.c_str());
 137                         return false;
 138                 }
 139
 140                 // (All the cases are in {...} to avoid scoping problems)
 141                 switch (Type)
 142                 {
 143                 case GUIST_bool:
 144                 {
 145                         bool value;
 146                         GUI<bool>::GetSetting(e, propName, value);
 147                         vp.set(JS::BooleanValue(value));
 148                         break;
 149                 }
 150
 151                 case GUIST_int:
 152                 {
 153                         int value;
 154                         GUI<int>::GetSetting(e, propName, value);
 155                         vp.set(JS::Int32Value(value));
 156                         break;
 157                 }
 158
 159                 case GUIST_float:
 160                 {
 161                         float value;
 162                         GUI<float>::GetSetting(e, propName, value);
 163                         // Create a garbage-collectable double
 164                         vp.set(JS::NumberValue(value));
 165                         return !vp.isNull();
 166                 }
 167
 168                 case GUIST_CColor:
 169                 {
 170                         CColor color;
 171                         GUI<CColor>::GetSetting(e, propName, color);
 172                         JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUIColor"));
 173                         vp.setObject(*obj);
 174                         JS::RootedValue c(cx);
 175                         // Attempt to minimise ugliness through macrosity
 176 #define P(x) \
 177         c = JS::NumberValue(color.x); \
 178         if (c.isNull()) \
 179                 return false; \
 180         JS_SetProperty(cx, obj, #x, c)
 181
 182                         P(r);
 183                         P(g);
 184                         P(b);
 185                         P(a);
 186 #undef P
 187                         break;
 188                 }
 189
 190                 case GUIST_CClientArea:
 191                 {
 192                         CClientArea area;
 193                         GUI<CClientArea>::GetSetting(e, propName, area);
 194
 195                         JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUISize"));
 196                         vp.setObject(*obj);
 197                         try
 198                         {
 199 #define P(x, y, z) pScriptInterface->SetProperty(vp, #z, area.x.y, false, true)
 200                                 P(pixel,        left,   left);
 201                                 P(pixel,        top,    top);
 202                                 P(pixel,        right,  right);
 203                                 P(pixel,        bottom, bottom);
 204                                 P(percent,      left,   rleft);
 205                                 P(percent,      top,    rtop);
 206                                 P(percent,      right,  rright);
 207                                 P(percent,      bottom, rbottom);
 208 #undef P
 209                         }
 210                         catch (PSERROR_Scripting_ConversionFailed&)
 211                         {
 212                                 debug_warn(L"Error creating size object!");
 213                                 break;
 214                         }
 215
 216                         break;
 217                 }
 218
 219                 case GUIST_CGUIString:
 220                 {
 221                         CGUIString value;
 222                         GUI<CGUIString>::GetSetting(e, propName, value);
 223                         ScriptInterface::ToJSVal(cx, vp, value.GetOriginalString());
 224                         break;
 225                 }
 226
 227                 case GUIST_CStr:
 228                 {
 229                         CStr value;
 230                         GUI<CStr>::GetSetting(e, propName, value);
 231                         ScriptInterface::ToJSVal(cx, vp, value);
 232                         break;
 233                 }
 234
 235                 case GUIST_CStrW:
 236                 {
 237                         CStrW value;
 238                         GUI<CStrW>::GetSetting(e, propName, value);
 239                         ScriptInterface::ToJSVal(cx, vp, value);
 240                         break;
 241                 }
 242
 243                 case GUIST_CGUISpriteInstance:
 244                 {
 245                         CGUISpriteInstance *value;
 246                         GUI<CGUISpriteInstance>::GetSettingPointer(e, propName, value);
 247                         ScriptInterface::ToJSVal(cx, vp, value->GetName());
 248                         break;
 249                 }
 250
 251                 case GUIST_EAlign:
 252                 {
 253                         EAlign value;
 254                         GUI<EAlign>::GetSetting(e, propName, value);
 255                         CStr word;
 256                         switch (value)
 257                         {
 258                         case EAlign_Left: word = "left"; break;
 259                         case EAlign_Right: word = "right"; break;
 260                         case EAlign_Center: word = "center"; break;
 261                         default: debug_warn(L"Invalid EAlign!"); word = "error"; break;
 262                         }
 263                         ScriptInterface::ToJSVal(cx, vp, word);
 264                         break;
 265                 }
 266
 267                 case GUIST_EVAlign:
 268                 {
 269                         EVAlign value;
 270                         GUI<EVAlign>::GetSetting(e, propName, value);
 271                         CStr word;
 272                         switch (value)
 273                         {
 274                         case EVAlign_Top: word = "top"; break;
 275                         case EVAlign_Bottom: word = "bottom"; break;
 276                         case EVAlign_Center: word = "center"; break;
 277                         default: debug_warn(L"Invalid EVAlign!"); word = "error"; break;
 278                         }
 279                         ScriptInterface::ToJSVal(cx, vp, word);
 280                         break;
 281                 }
 282
 283                 case GUIST_CGUIList:
 284                 {
 285                         CGUIList value;
 286                         GUI<CGUIList>::GetSetting(e, propName, value);
 287                         ScriptInterface::ToJSVal(cx, vp, value.m_Items);
 288                         break;
 289                 }
 290
 291                 case GUIST_CGUISeries:
 292                 {
 293                         CGUISeries value;
 294                         GUI<CGUISeries>::GetSetting(e, propName, value);
 295                         ScriptInterface::ToJSVal(cx, vp, value.m_Series);
 296                         break;
 297                 }
 298
 299                 default:
 300                         JS_ReportError(cx, "Setting '%s' uses an unimplemented type", propName.c_str());
 301                         DEBUG_WARN_ERR(ERR::LOGIC);
 302                         return false;
 303                 }
 304
 305                 return true;
 306         }
 307 }
 308
 309 bool JSI_IGUIObject::setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp)
 310 {
 311         IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, obj, &JSI_IGUIObject::JSI_class, NULL);
 312         if (!e)
 313                 return false;
 314
 315         JSAutoRequest rq(cx);
 316         JS::RootedValue idval(cx);
 317         if (!JS_IdToValue(cx, id, &idval))
 318                 return false;
 319
 320         std::string propName;
 321         if (!ScriptInterface::FromJSVal(cx, idval, propName))
 322                 return false;
 323
 324         if (propName == "name")
 325         {
 326                 std::string value;
 327                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 328                         return false;
 329                 e->SetName(value);
 330                 return true;
 331         }
 332
 333         JS::RootedObject vpObj(cx);
 334         if (vp.isObject())
 335                 vpObj = &vp.toObject();
 336
 337         // Use onWhatever to set event handlers
 338         if (propName.substr(0, 2) == "on")
 339         {
 340                 if (vp.isPrimitive() || vp.isNull() || !JS_ObjectIsFunction(cx, &vp.toObject()))
 341                 {
 342                         JS_ReportError(cx, "on- event-handlers must be functions");
 343                         return false;
 344                 }
 345
 346                 CStr eventName(CStr(propName.substr(2)).LowerCase());
 347                 e->SetScriptHandler(eventName, vpObj);
 348
 349                 return true;
 350         }
 351
 352         // Retrieve the setting's type (and make sure it actually exists)
 353         EGUISettingType Type;
 354         if (e->GetSettingType(propName, Type) != PSRETURN_OK)
 355         {
 356                 JS_ReportError(cx, "Invalid setting '%s'", propName.c_str());
 357                 return true;
 358         }
 359
 360         switch (Type)
 361         {
 362         case GUIST_CStr:
 363         {
 364                 std::string value;
 365                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 366                         return false;
 367
 368                 GUI<CStr>::SetSetting(e, propName, value);
 369                 break;
 370         }
 371
 372         case GUIST_CStrW:
 373         {
 374                 std::wstring value;
 375                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 376                         return false;
 377
 378                 GUI<CStrW>::SetSetting(e, propName, value);
 379                 break;
 380         }
 381
 382         case GUIST_CGUISpriteInstance:
 383         {
 384                 std::string value;
 385                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 386                         return false;
 387
 388                 GUI<CGUISpriteInstance>::SetSetting(e, propName, CGUISpriteInstance(value));
 389                 break;
 390         }
 391
 392         case GUIST_CGUIString:
 393         {
 394                 std::wstring value;
 395                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 396                         return false;
 397
 398                 CGUIString str;
 399                 str.SetValue(value);
 400                 GUI<CGUIString>::SetSetting(e, propName, str);
 401                 break;
 402         }
 403
 404         case GUIST_EAlign:
 405         {
 406                 std::string value;
 407                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 408                         return false;
 409
 410                 EAlign a;
 411                 if (value == "left") a = EAlign_Left;
 412                 else if (value == "right") a = EAlign_Right;
 413                 else if (value == "center" || value == "centre") a = EAlign_Center;
 414                 else
 415                 {
 416                         JS_ReportError(cx, "Invalid alignment (should be 'left', 'right' or 'center')");
 417                         return false;
 418                 }
 419                 GUI<EAlign>::SetSetting(e, propName, a);
 420                 break;
 421         }
 422
 423         case GUIST_EVAlign:
 424         {
 425                 std::string value;
 426                 if (!ScriptInterface::FromJSVal(cx, vp, value))
 427                         return false;
 428
 429                 EVAlign a;
 430                 if (value == "top") a = EVAlign_Top;
 431                 else if (value == "bottom") a = EVAlign_Bottom;
 432                 else if (value == "center" || value == "centre") a = EVAlign_Center;
 433                 else
 434                 {
 435                         JS_ReportError(cx, "Invalid alignment (should be 'top', 'bottom' or 'center')");
 436                         return false;
 437                 }
 438                 GUI<EVAlign>::SetSetting(e, propName, a);
 439                 break;
 440         }
 441
 442         case GUIST_int:
 443         {
 444                 int value;
 445                 if (ScriptInterface::FromJSVal(cx, vp, value))
 446                         GUI<int>::SetSetting(e, propName, value);
 447                 else
 448                 {
 449                         JS_ReportError(cx, "Cannot convert value to int");
 450                         return false;
 451                 }
 452                 break;
 453         }
 454
 455         case GUIST_float:
 456         {
 457                 double value;
 458                 if (JS::ToNumber(cx, vp, &value) == true)
 459                         GUI<float>::SetSetting(e, propName, (float)value);
 460                 else
 461                 {
 462                         JS_ReportError(cx, "Cannot convert value to float");
 463                         return false;
 464                 }
 465                 break;
 466         }
 467
 468         case GUIST_bool:
 469         {
 470                 bool value = JS::ToBoolean(vp);
 471                 GUI<bool>::SetSetting(e, propName, value);
 472                 break;
 473         }
 474
 475         case GUIST_CClientArea:
 476         {
 477                 if (vp.isString())
 478                 {
 479                         std::wstring value;
 480                         if (!ScriptInterface::FromJSVal(cx, vp, value))
 481                                 return false;
 482
 483                         if (e->SetSetting(propName, value) != PSRETURN_OK)
 484                         {
 485                                 JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
 486                                 return false;
 487                         }
 488                 }
 489                 else if (vp.isObject() && JS_InstanceOf(cx, vpObj, &JSI_GUISize::JSI_class, NULL))
 490                 {
 491                         CClientArea area;
 492                         GUI<CClientArea>::GetSetting(e, propName, area);
 493
 494                         ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 495 #define P(x, y, z) pScriptInterface->GetProperty(vp, #z, area.x.y)
 496                         P(pixel,        left,   left);
 497                         P(pixel,        top,    top);
 498                         P(pixel,        right,  right);
 499                         P(pixel,        bottom, bottom);
 500                         P(percent,      left,   rleft);
 501                         P(percent,      top,    rtop);
 502                         P(percent,      right,  rright);
 503                         P(percent,      bottom, rbottom);
 504 #undef P
 505
 506                         GUI<CClientArea>::SetSetting(e, propName, area);
 507                 }
 508                 else
 509                 {
 510                         JS_ReportError(cx, "Size only accepts strings or GUISize objects");
 511                         return false;
 512                 }
 513                 break;
 514         }
 515
 516         case GUIST_CColor:
 517         {
 518                 if (vp.isString())
 519                 {
 520                         std::wstring value;
 521                         if (!ScriptInterface::FromJSVal(cx, vp, value))
 522                                 return false;
 523
 524                         if (e->SetSetting(propName, value) != PSRETURN_OK)
 525                         {
 526                                 JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
 527                                 return false;
 528                         }
 529                 }
 530                 else if (vp.isObject() && JS_InstanceOf(cx, vpObj, &JSI_GUIColor::JSI_class, NULL))
 531                 {
 532                         CColor color;
 533                         JS::RootedValue t(cx);
 534                         double s;
 535 #define PROP(x) \
 536         JS_GetProperty(cx, vpObj, #x, &t); \
 537         s = t.toDouble(); \
 538         color.x = (float)s
 539
 540                         PROP(r);
 541                         PROP(g);
 542                         PROP(b);
 543                         PROP(a);
 544 #undef PROP
 545                         GUI<CColor>::SetSetting(e, propName, color);
 546                 }
 547                 else
 548                 {
 549                         JS_ReportError(cx, "Color only accepts strings or GUIColor objects");
 550                         return false;
 551                 }
 552                 break;
 553         }
 554
 555         case GUIST_CGUIList:
 556         {
 557                 CGUIList list;
 558                 if (ScriptInterface::FromJSVal(cx, vp, list.m_Items))
 559                         GUI<CGUIList>::SetSetting(e, propName, list);
 560                 else
 561                 {
 562                         JS_ReportError(cx, "Failed to get list '%s'", propName.c_str());
 563                         return false;
 564                 }
 565                 break;
 566         }
 567
 568         case GUIST_CGUISeries:
 569         {
 570                 CGUISeries series;
 571                 if (ScriptInterface::FromJSVal(cx, vp, series.m_Series))
 572                         GUI<CGUISeries>::SetSetting(e, propName, series);
 573                 else
 574                 {
 575                         JS_ReportError(cx, "Invalid value for chart series '%s'", propName.c_str());
 576                         return false;
 577                 }
 578                 break;
 579         }
 580
 581         default:
 582                 JS_ReportError(cx, "Setting '%s' uses an unimplemented type", propName.c_str());
 583                 break;
 584         }
 585
 586         return !JS_IsExceptionPending(cx);
 587 }
 588
 589
 590 bool JSI_IGUIObject::construct(JSContext* cx, uint argc, JS::Value* vp)
 591 {
 592         JSAutoRequest rq(cx);
 593         JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 594         ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 595
 596         if (args.length() == 0)
 597         {
 598                 JS_ReportError(cx, "GUIObject has no default constructor");
 599                 return false;
 600         }
 601
 602         JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUIObject"));
 603
 604         // Store the IGUIObject in the JS object's 'private' area
 605         IGUIObject* guiObject = (IGUIObject*)args[0].get().toPrivate();
 606         JS_SetPrivate(obj, guiObject);
 607
 608         args.rval().setObject(*obj);
 609         return true;
 610 }
 611
 612 void JSI_IGUIObject::init(ScriptInterface& scriptInterface)
 613 {
 614         scriptInterface.DefineCustomObjectType(&JSI_class, construct, 1, JSI_props, JSI_methods, NULL, NULL);
 615 }
 616
 617 bool JSI_IGUIObject::toString(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 618 {
 619         JSAutoRequest rq(cx);
 620         JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 621
 622         JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 623
 624         IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 625         if (!e)
 626                 return false;
 627
 628         char buffer[256];
 629         snprintf(buffer, 256, "[GUIObject: %s]", e->GetName().c_str());
 630         buffer[255] = 0;
 631         rec.rval().setString(JS_NewStringCopyZ(cx, buffer));
 632         return true;
 633 }
 634
 635 bool JSI_IGUIObject::focus(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 636 {
 637         JSAutoRequest rq(cx);
 638         JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 639
 640         JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 641
 642         IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 643         if (!e)
 644                 return false;
 645
 646         e->GetGUI()->SetFocusedObject(e);
 647
 648         rec.rval().setUndefined();
 649         return true;
 650 }
 651
 652 bool JSI_IGUIObject::blur(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 653 {
 654         JSAutoRequest rq(cx);
 655         JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 656
 657         JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 658
 659         IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 660         if (!e)
 661                 return false;
 662
 663         e->GetGUI()->SetFocusedObject(NULL);
 664
 665         rec.rval().setUndefined();
 666         return true;
 667 }
 668
 669 bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 670 {
 671         JSAutoRequest rq(cx);
 672         JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 673
 674         JS::RootedObject thisObj(cx, JS_THIS_OBJECT(cx, vp));
 675
 676         IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, thisObj, &JSI_IGUIObject::JSI_class, NULL);
 677         if (!e)
 678                 return false;
 679
 680         e->UpdateCachedSize();
 681         CRect size = e->m_CachedActualSize;
 682
 683         JS::RootedValue objVal(cx, JS::ObjectValue(*JS_NewPlainObject(cx)));
 684         try
 685         {
 686                 ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
 687                 pScriptInterface->SetProperty(objVal, "left", size.left, false, true);
 688                 pScriptInterface->SetProperty(objVal, "right", size.right, false, true);
 689                 pScriptInterface->SetProperty(objVal, "top", size.top, false, true);
 690                 pScriptInterface->SetProperty(objVal, "bottom", size.bottom, false, true);
 691         }
 692         catch (PSERROR_Scripting_ConversionFailed&)
 693         {
 694                 debug_warn(L"Error creating size object!");
 695                 return false;
 696         }
 697
 698         rec.rval().set(objVal);
 699         return true;
 700 }