WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp

   1 /*
   2     This file is part of the WebKit open source project.
   3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public License
  16     along with this library; see the file COPYING.LIB.  If not, write to
  17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18     Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include <glib-object.h>
  22 #include "config.h"
  23
  24 #include <wtf/GetPtr.h>
  25 #include <wtf/RefPtr.h>
  26 #include "ExceptionCode.h"
  27 #include "TestObj.h"
  28 #include "WebKitDOMBinding.h"
  29 #include "gobject/ConvertToUTF8String.h"
  30 #include "webkit/WebKitDOMSerializedScriptValue.h"
  31 #include "webkit/WebKitDOMSerializedScriptValuePrivate.h"
  32 #include "webkit/WebKitDOMTestObj.h"
  33 #include "webkit/WebKitDOMTestObjPrivate.h"
  34 #include "webkitmarshal.h"
  35 #include "webkitprivate.h"
  36
  37 namespace WebKit {
  38
  39 gpointer kit(WebCore::TestObj* obj)
  40 {
  41     g_return_val_if_fail(obj != 0, 0);
  42
  43     if (gpointer ret = DOMObjectCache::get(obj))
  44         return ret;
  45
  46     return DOMObjectCache::put(obj, WebKit::wrapTestObj(obj));
  47 }
  48
  49 } // namespace WebKit //
  50
  51 void
  52 webkit_dom_test_obj_void_method (WebKitDOMTestObj *self)
  53 {
  54     g_return_if_fail (self);
  55     WebCore::TestObj * item = WebKit::core(self);
  56     item->voidMethod();
  57
  58 }
  59
  60 void
  61 webkit_dom_test_obj_void_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
  62 {
  63     g_return_if_fail (self);
  64     WebCore::TestObj * item = WebKit::core(self);
  65     g_return_if_fail (str_arg);
  66     g_return_if_fail (obj_arg);
  67     WebCore::String _g_str_arg = WebCore::String::fromUTF8(str_arg);
  68     WebCore::TestObj * _g_obj_arg = WebKit::core(obj_arg);
  69     g_return_if_fail (_g_obj_arg);
  70     item->voidMethodWithArgs(int_arg, _g_str_arg, _g_obj_arg);
  71
  72 }
  73
  74 glong
  75 webkit_dom_test_obj_int_method (WebKitDOMTestObj *self)
  76 {
  77     g_return_val_if_fail (self, 0);
  78     WebCore::TestObj * item = WebKit::core(self);
  79     glong res = item->intMethod();
  80     return res;
  81
  82 }
  83
  84 glong
  85 webkit_dom_test_obj_int_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
  86 {
  87     g_return_val_if_fail (self, 0);
  88     WebCore::TestObj * item = WebKit::core(self);
  89     g_return_val_if_fail (str_arg, 0);
  90     g_return_val_if_fail (obj_arg, 0);
  91     WebCore::String _g_str_arg = WebCore::String::fromUTF8(str_arg);
  92     WebCore::TestObj * _g_obj_arg = WebKit::core(obj_arg);
  93     g_return_val_if_fail (_g_obj_arg, 0);
  94     glong res = item->intMethodWithArgs(int_arg, _g_str_arg, _g_obj_arg);
  95     return res;
  96
  97 }
  98
  99 WebKitDOMTestObj*
 100 webkit_dom_test_obj_obj_method (WebKitDOMTestObj *self)
 101 {
 102     g_return_val_if_fail (self, 0);
 103     WebCore::TestObj * item = WebKit::core(self);
 104     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->objMethod());
 105     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 106     return res;
 107
 108 }
 109
 110 WebKitDOMTestObj*
 111 webkit_dom_test_obj_obj_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
 112 {
 113     g_return_val_if_fail (self, 0);
 114     WebCore::TestObj * item = WebKit::core(self);
 115     g_return_val_if_fail (str_arg, 0);
 116     g_return_val_if_fail (obj_arg, 0);
 117     WebCore::String _g_str_arg = WebCore::String::fromUTF8(str_arg);
 118     WebCore::TestObj * _g_obj_arg = WebKit::core(obj_arg);
 119     g_return_val_if_fail (_g_obj_arg, 0);
 120     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->objMethodWithArgs(int_arg, _g_str_arg, _g_obj_arg));
 121     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 122     return res;
 123
 124 }
 125
 126 void
 127 webkit_dom_test_obj_serialized_value (WebKitDOMTestObj *self, WebKitDOMSerializedScriptValue*  serialized_arg)
 128 {
 129     g_return_if_fail (self);
 130     WebCore::TestObj * item = WebKit::core(self);
 131     g_return_if_fail (serialized_arg);
 132     WebCore::SerializedScriptValue * _g_serialized_arg = WebKit::core(serialized_arg);
 133     g_return_if_fail (_g_serialized_arg);
 134     item->serializedValue(_g_serialized_arg);
 135
 136 }
 137
 138 void
 139 webkit_dom_test_obj_method_with_exception (WebKitDOMTestObj *self, GError **error)
 140 {
 141     g_return_if_fail (self);
 142     WebCore::TestObj * item = WebKit::core(self);
 143     WebCore::ExceptionCode ec = 0;
 144     item->methodWithException(ec);
 145     if (ec) {
 146         WebCore::ExceptionCodeDescription ecdesc;
 147         WebCore::getExceptionCodeDescription(ec, ecdesc);
 148         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
 149     }
 150
 151 }
 152
 153
 154 /* TODO: event function webkit_dom_test_obj_add_event_listener */
 155
 156
 157 /* TODO: event function webkit_dom_test_obj_remove_event_listener */
 158
 159 void
 160 webkit_dom_test_obj_with_dynamic_frame (WebKitDOMTestObj *self)
 161 {
 162     g_return_if_fail (self);
 163     WebCore::TestObj * item = WebKit::core(self);
 164     item->withDynamicFrame();
 165
 166 }
 167
 168 void
 169 webkit_dom_test_obj_with_dynamic_frame_and_arg (WebKitDOMTestObj *self, glong int_arg)
 170 {
 171     g_return_if_fail (self);
 172     WebCore::TestObj * item = WebKit::core(self);
 173     item->withDynamicFrameAndArg(int_arg);
 174
 175 }
 176
 177 void
 178 webkit_dom_test_obj_with_dynamic_frame_and_optional_arg (WebKitDOMTestObj *self, glong int_arg, glong optional_arg)
 179 {
 180     g_return_if_fail (self);
 181     WebCore::TestObj * item = WebKit::core(self);
 182     item->withDynamicFrameAndOptionalArg(int_arg, optional_arg);
 183
 184 }
 185
 186 void
 187 webkit_dom_test_obj_with_dynamic_frame_and_user_gesture (WebKitDOMTestObj *self, glong int_arg)
 188 {
 189     g_return_if_fail (self);
 190     WebCore::TestObj * item = WebKit::core(self);
 191     item->withDynamicFrameAndUserGesture(int_arg);
 192
 193 }
 194
 195 void
 196 webkit_dom_test_obj_with_dynamic_frame_and_user_gesture_asad (WebKitDOMTestObj *self, glong int_arg, glong optional_arg)
 197 {
 198     g_return_if_fail (self);
 199     WebCore::TestObj * item = WebKit::core(self);
 200     item->withDynamicFrameAndUserGestureASAD(int_arg, optional_arg);
 201
 202 }
 203
 204 void
 205 webkit_dom_test_obj_with_script_state_void (WebKitDOMTestObj *self)
 206 {
 207     g_return_if_fail (self);
 208     WebCore::TestObj * item = WebKit::core(self);
 209     item->withScriptStateVoid();
 210
 211 }
 212
 213 WebKitDOMTestObj*
 214 webkit_dom_test_obj_with_script_state_obj (WebKitDOMTestObj *self)
 215 {
 216     g_return_val_if_fail (self, 0);
 217     WebCore::TestObj * item = WebKit::core(self);
 218     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->withScriptStateObj());
 219     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 220     return res;
 221
 222 }
 223
 224 void
 225 webkit_dom_test_obj_with_script_state_void_exception (WebKitDOMTestObj *self, GError **error)
 226 {
 227     g_return_if_fail (self);
 228     WebCore::TestObj * item = WebKit::core(self);
 229     WebCore::ExceptionCode ec = 0;
 230     item->withScriptStateVoidException(ec);
 231     if (ec) {
 232         WebCore::ExceptionCodeDescription ecdesc;
 233         WebCore::getExceptionCodeDescription(ec, ecdesc);
 234         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
 235     }
 236
 237 }
 238
 239 WebKitDOMTestObj*
 240 webkit_dom_test_obj_with_script_state_obj_exception (WebKitDOMTestObj *self, GError **error)
 241 {
 242     g_return_val_if_fail (self, 0);
 243     WebCore::TestObj * item = WebKit::core(self);
 244     WebCore::ExceptionCode ec = 0;
 245     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->withScriptStateObjException(ec));
 246     if (ec) {
 247         WebCore::ExceptionCodeDescription ecdesc;
 248         WebCore::getExceptionCodeDescription(ec, ecdesc);
 249         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
 250     }
 251     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 252     return res;
 253
 254 }
 255
 256 void
 257 webkit_dom_test_obj_method_with_optional_arg (WebKitDOMTestObj *self, glong opt)
 258 {
 259     g_return_if_fail (self);
 260     WebCore::TestObj * item = WebKit::core(self);
 261     item->methodWithOptionalArg(opt);
 262
 263 }
 264
 265 void
 266 webkit_dom_test_obj_method_with_non_optional_arg_and_optional_arg (WebKitDOMTestObj *self, glong non_opt, glong opt)
 267 {
 268     g_return_if_fail (self);
 269     WebCore::TestObj * item = WebKit::core(self);
 270     item->methodWithNonOptionalArgAndOptionalArg(non_opt, opt);
 271
 272 }
 273
 274 void
 275 webkit_dom_test_obj_method_with_non_optional_arg_and_two_optional_args (WebKitDOMTestObj *self, glong non_opt, glong opt1, glong opt2)
 276 {
 277     g_return_if_fail (self);
 278     WebCore::TestObj * item = WebKit::core(self);
 279     item->methodWithNonOptionalArgAndTwoOptionalArgs(non_opt, opt1, opt2);
 280
 281 }
 282
 283 glong
 284 webkit_dom_test_obj_get_read_only_int_attr (WebKitDOMTestObj *self)
 285 {
 286     g_return_val_if_fail (self, 0);
 287     WebCore::TestObj * item = WebKit::core(self);
 288     glong res = item->readOnlyIntAttr();
 289     return res;
 290
 291 }
 292
 293 gchar*
 294 webkit_dom_test_obj_get_read_only_string_attr (WebKitDOMTestObj *self)
 295 {
 296     g_return_val_if_fail (self, 0);
 297     WebCore::TestObj * item = WebKit::core(self);
 298     gchar*  res = convertToUTF8String(item->readOnlyStringAttr());
 299     return res;
 300
 301 }
 302
 303 WebKitDOMTestObj*
 304 webkit_dom_test_obj_get_read_only_test_obj_attr (WebKitDOMTestObj *self)
 305 {
 306     g_return_val_if_fail (self, 0);
 307     WebCore::TestObj * item = WebKit::core(self);
 308     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->readOnlyTestObjAttr());
 309     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 310     return res;
 311
 312 }
 313
 314 glong
 315 webkit_dom_test_obj_get_int_attr (WebKitDOMTestObj *self)
 316 {
 317     g_return_val_if_fail (self, 0);
 318     WebCore::TestObj * item = WebKit::core(self);
 319     glong res = item->intAttr();
 320     return res;
 321
 322 }
 323
 324 void
 325 webkit_dom_test_obj_set_int_attr (WebKitDOMTestObj *self, glong value)
 326 {
 327     g_return_if_fail (self);
 328     WebCore::TestObj * item = WebKit::core(self);
 329     item->setIntAttr(value);
 330
 331 }
 332
 333 gint64
 334 webkit_dom_test_obj_get_long_long_attr (WebKitDOMTestObj *self)
 335 {
 336     g_return_val_if_fail (self, 0);
 337     WebCore::TestObj * item = WebKit::core(self);
 338     gint64 res = item->longLongAttr();
 339     return res;
 340
 341 }
 342
 343 void
 344 webkit_dom_test_obj_set_long_long_attr (WebKitDOMTestObj *self, gint64 value)
 345 {
 346     g_return_if_fail (self);
 347     WebCore::TestObj * item = WebKit::core(self);
 348     item->setLongLongAttr(value);
 349
 350 }
 351
 352 guint64
 353 webkit_dom_test_obj_get_unsigned_long_long_attr (WebKitDOMTestObj *self)
 354 {
 355     g_return_val_if_fail (self, 0);
 356     WebCore::TestObj * item = WebKit::core(self);
 357     guint64 res = item->unsignedLongLongAttr();
 358     return res;
 359
 360 }
 361
 362 void
 363 webkit_dom_test_obj_set_unsigned_long_long_attr (WebKitDOMTestObj *self, guint64 value)
 364 {
 365     g_return_if_fail (self);
 366     WebCore::TestObj * item = WebKit::core(self);
 367     item->setUnsignedLongLongAttr(value);
 368
 369 }
 370
 371 gchar*
 372 webkit_dom_test_obj_get_string_attr (WebKitDOMTestObj *self)
 373 {
 374     g_return_val_if_fail (self, 0);
 375     WebCore::TestObj * item = WebKit::core(self);
 376     gchar*  res = convertToUTF8String(item->stringAttr());
 377     return res;
 378
 379 }
 380
 381 void
 382 webkit_dom_test_obj_set_string_attr (WebKitDOMTestObj *self, gchar*  value)
 383 {
 384     g_return_if_fail (self);
 385     WebCore::TestObj * item = WebKit::core(self);
 386     g_return_if_fail (value);
 387     WebCore::String _g_value = WebCore::String::fromUTF8(value);
 388     item->setStringAttr(_g_value);
 389
 390 }
 391
 392 WebKitDOMTestObj*
 393 webkit_dom_test_obj_get_test_obj_attr (WebKitDOMTestObj *self)
 394 {
 395     g_return_val_if_fail (self, 0);
 396     WebCore::TestObj * item = WebKit::core(self);
 397     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->testObjAttr());
 398     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 399     return res;
 400
 401 }
 402
 403 void
 404 webkit_dom_test_obj_set_test_obj_attr (WebKitDOMTestObj *self, WebKitDOMTestObj*  value)
 405 {
 406     g_return_if_fail (self);
 407     WebCore::TestObj * item = WebKit::core(self);
 408     g_return_if_fail (value);
 409     WebCore::TestObj * _g_value = WebKit::core(value);
 410     g_return_if_fail (_g_value);
 411     item->setTestObjAttr(_g_value);
 412
 413 }
 414
 415 glong
 416 webkit_dom_test_obj_get_attr_with_exception (WebKitDOMTestObj *self)
 417 {
 418     g_return_val_if_fail (self, 0);
 419     WebCore::TestObj * item = WebKit::core(self);
 420     glong res = item->attrWithException();
 421     return res;
 422
 423 }
 424
 425 void
 426 webkit_dom_test_obj_set_attr_with_exception (WebKitDOMTestObj *self, glong value)
 427 {
 428     g_return_if_fail (self);
 429     WebCore::TestObj * item = WebKit::core(self);
 430     item->setAttrWithException(value);
 431
 432 }
 433
 434 glong
 435 webkit_dom_test_obj_get_attr_with_setter_exception (WebKitDOMTestObj *self)
 436 {
 437     g_return_val_if_fail (self, 0);
 438     WebCore::TestObj * item = WebKit::core(self);
 439     glong res = item->attrWithSetterException();
 440     return res;
 441
 442 }
 443
 444 void
 445 webkit_dom_test_obj_set_attr_with_setter_exception (WebKitDOMTestObj *self, glong value)
 446 {
 447     g_return_if_fail (self);
 448     WebCore::TestObj * item = WebKit::core(self);
 449     item->setAttrWithSetterException(value);
 450
 451 }
 452
 453 glong
 454 webkit_dom_test_obj_get_attr_with_getter_exception (WebKitDOMTestObj *self)
 455 {
 456     g_return_val_if_fail (self, 0);
 457     WebCore::TestObj * item = WebKit::core(self);
 458     glong res = item->attrWithGetterException();
 459     return res;
 460
 461 }
 462
 463 void
 464 webkit_dom_test_obj_set_attr_with_getter_exception (WebKitDOMTestObj *self, glong value)
 465 {
 466     g_return_if_fail (self);
 467     WebCore::TestObj * item = WebKit::core(self);
 468     item->setAttrWithGetterException(value);
 469
 470 }
 471
 472
 473 G_DEFINE_TYPE(WebKitDOMTestObj, webkit_dom_test_obj, WEBKIT_TYPE_DOM_OBJECT)
 474
 475 namespace WebKit {
 476
 477 WebKitDOMTestObj* wrapTestObj(WebCore::TestObj* coreObject)
 478 {
 479     g_return_val_if_fail(coreObject != 0, 0);
 480
 481     WebKitDOMTestObj* wrapper = WEBKIT_DOM_TEST_OBJ(g_object_new(WEBKIT_TYPE_DOM_TEST_OBJ, NULL));
 482     g_return_val_if_fail(wrapper != 0, 0);
 483
 484     /* We call ref() rather than using a C++ smart pointer because we can't store a C++ object
 485      * in a C-allocated GObject structure.  See the finalize() code for the
 486      * matching deref().
 487      */
 488
 489     coreObject->ref();
 490     WEBKIT_DOM_OBJECT(wrapper)->coreObject = coreObject;
 491
 492     return wrapper;
 493 }
 494
 495 WebCore::TestObj* core(WebKitDOMTestObj* request)
 496 {
 497     g_return_val_if_fail(request != 0, 0);
 498
 499     WebCore::TestObj* coreObject = static_cast<WebCore::TestObj*>(WEBKIT_DOM_OBJECT(request)->coreObject);
 500     g_return_val_if_fail(coreObject != 0, 0);
 501
 502     return coreObject;
 503 }
 504
 505 } // namespace WebKit
 506 enum {
 507     PROP_0,
 508     PROP_READ_ONLY_INT_ATTR,
 509     PROP_READ_ONLY_STRING_ATTR,
 510     PROP_READ_ONLY_TEST_OBJ_ATTR,
 511     PROP_INT_ATTR,
 512     PROP_LONG_LONG_ATTR,
 513     PROP_UNSIGNED_LONG_LONG_ATTR,
 514     PROP_STRING_ATTR,
 515     PROP_TEST_OBJ_ATTR,
 516     PROP_ATTR_WITH_EXCEPTION,
 517     PROP_ATTR_WITH_SETTER_EXCEPTION,
 518     PROP_ATTR_WITH_GETTER_EXCEPTION,
 519     PROP_CUSTOM_ATTR,
 520 };
 521
 522
 523 static void webkit_dom_test_obj_finalize(GObject* object)
 524 {
 525     WebKitDOMObject* dom_object = WEBKIT_DOM_OBJECT(object);
 526
 527     if (dom_object->coreObject != NULL) {
 528         WebCore::TestObj* coreObject = static_cast<WebCore::TestObj *>(dom_object->coreObject);
 529
 530         WebKit::DOMObjectCache::forget(coreObject);
 531         coreObject->deref();
 532
 533         dom_object->coreObject = NULL;
 534     }
 535
 536     G_OBJECT_CLASS(webkit_dom_test_obj_parent_class)->finalize(object);
 537 }
 538
 539 static void webkit_dom_test_obj_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
 540 {
 541      WebKitDOMTestObj *self = WEBKIT_DOM_TEST_OBJ(object);
 542     WebCore::TestObj* coreSelf = WebKit::core(self);
 543      switch (prop_id) {
 544     case PROP_INT_ATTR:
 545     {
 546          coreSelf->setIntAttr((g_value_get_long(value)) );
 547          break;
 548     }
 549     case PROP_UNSIGNED_LONG_LONG_ATTR:
 550     {
 551          coreSelf->setUnsignedLongLongAttr((g_value_get_uint64(value)) );
 552          break;
 553     }
 554     case PROP_STRING_ATTR:
 555     {
 556          coreSelf->setStringAttr(WebCore::String::fromUTF8(g_value_get_string(value)) );
 557          break;
 558     }
 559     case PROP_ATTR_WITH_EXCEPTION:
 560     {
 561          coreSelf->setAttrWithException((g_value_get_long(value)) );
 562          break;
 563     }
 564     case PROP_ATTR_WITH_SETTER_EXCEPTION:
 565     {
 566          coreSelf->setAttrWithSetterException((g_value_get_long(value)) );
 567          break;
 568     }
 569     case PROP_ATTR_WITH_GETTER_EXCEPTION:
 570     {
 571          coreSelf->setAttrWithGetterException((g_value_get_long(value)) );
 572          break;
 573     }
 574     case PROP_CUSTOM_ATTR:
 575     {
 576          coreSelf->setCustomAttr((g_value_get_long(value)) );
 577          break;
 578     }
 579      default:
 580         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 581         break;
 582     }
 583 }
 584
 585
 586 static void webkit_dom_test_obj_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
 587 {
 588      WebKitDOMTestObj* self = WEBKIT_DOM_TEST_OBJ(object);
 589     WebCore::TestObj* coreSelf = WebKit::core(self);
 590      switch (prop_id) {
 591     case PROP_READ_ONLY_INT_ATTR:
 592     {
 593          g_value_set_long(value, coreSelf->readOnlyIntAttr());
 594          break;
 595     }
 596     case PROP_READ_ONLY_STRING_ATTR:
 597     {
 598          g_value_take_string(value, convertToUTF8String(coreSelf->readOnlyStringAttr()));
 599          break;
 600     }
 601     case PROP_READ_ONLY_TEST_OBJ_ATTR:
 602     {
 603          RefPtr<WebCore::TestObj> ptr = coreSelf->readOnlyTestObjAttr();
 604         g_value_set_object(value, WebKit::kit(ptr.get()));
 605          break;
 606     }
 607     case PROP_INT_ATTR:
 608     {
 609          g_value_set_long(value, coreSelf->intAttr());
 610          break;
 611     }
 612     case PROP_LONG_LONG_ATTR:
 613     {
 614          g_value_set_int64(value, coreSelf->longLongAttr());
 615          break;
 616     }
 617     case PROP_UNSIGNED_LONG_LONG_ATTR:
 618     {
 619          g_value_set_uint64(value, coreSelf->unsignedLongLongAttr());
 620          break;
 621     }
 622     case PROP_STRING_ATTR:
 623     {
 624          g_value_take_string(value, convertToUTF8String(coreSelf->stringAttr()));
 625          break;
 626     }
 627     case PROP_TEST_OBJ_ATTR:
 628     {
 629          RefPtr<WebCore::TestObj> ptr = coreSelf->testObjAttr();
 630         g_value_set_object(value, WebKit::kit(ptr.get()));
 631          break;
 632     }
 633     case PROP_ATTR_WITH_EXCEPTION:
 634     {
 635          g_value_set_long(value, coreSelf->attrWithException());
 636          break;
 637     }
 638     case PROP_ATTR_WITH_SETTER_EXCEPTION:
 639     {
 640          g_value_set_long(value, coreSelf->attrWithSetterException());
 641          break;
 642     }
 643     case PROP_ATTR_WITH_GETTER_EXCEPTION:
 644     {
 645          g_value_set_long(value, coreSelf->attrWithGetterException());
 646          break;
 647     }
 648     case PROP_CUSTOM_ATTR:
 649     {
 650          g_value_set_long(value, coreSelf->customAttr());
 651          break;
 652     }
 653      default:
 654         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 655         break;
 656     }
 657 }
 658
 659
 660 static void webkit_dom_test_obj_class_init(WebKitDOMTestObjClass* requestClass)
 661 {
 662     GObjectClass *gobjectClass = G_OBJECT_CLASS(requestClass);
 663     gobjectClass->finalize = webkit_dom_test_obj_finalize;
 664     gobjectClass->set_property = webkit_dom_test_obj_set_property;
 665     gobjectClass->get_property = webkit_dom_test_obj_get_property;
 666
 667     g_object_class_install_property(gobjectClass,
 668                                     PROP_READ_ONLY_INT_ATTR,
 669                                     g_param_spec_long("read-only-int-attr", /* name */
 670                                                            "test_obj_read-only-int-attr", /* short description */
 671                                                            "read-only  glong TestObj.read-only-int-attr", /* longer - could do with some extra doc stuff here */
 672                                                            G_MINLONG, /* min */
 673 G_MAXLONG, /* max */
 674 0, /* default */
 675                                                            WEBKIT_PARAM_READABLE));
 676      g_object_class_install_property(gobjectClass,
 677                                     PROP_READ_ONLY_STRING_ATTR,
 678                                     g_param_spec_string("read-only-string-attr", /* name */
 679                                                            "test_obj_read-only-string-attr", /* short description */
 680                                                            "read-only  gchar*  TestObj.read-only-string-attr", /* longer - could do with some extra doc stuff here */
 681                                                            "", /* default */
 682                                                            WEBKIT_PARAM_READABLE));
 683      g_object_class_install_property(gobjectClass,
 684                                     PROP_READ_ONLY_TEST_OBJ_ATTR,
 685                                     g_param_spec_object("read-only-test-obj-attr", /* name */
 686                                                            "test_obj_read-only-test-obj-attr", /* short description */
 687                                                            "read-only  WebKitDOMTestObj*  TestObj.read-only-test-obj-attr", /* longer - could do with some extra doc stuff here */
 688                                                            WEBKIT_TYPE_DOM_TEST_OBJ, /* gobject type */
 689                                                            WEBKIT_PARAM_READABLE));
 690      g_object_class_install_property(gobjectClass,
 691                                     PROP_INT_ATTR,
 692                                     g_param_spec_long("int-attr", /* name */
 693                                                            "test_obj_int-attr", /* short description */
 694                                                            "read-write  glong TestObj.int-attr", /* longer - could do with some extra doc stuff here */
 695                                                            G_MINLONG, /* min */
 696 G_MAXLONG, /* max */
 697 0, /* default */
 698                                                            WEBKIT_PARAM_READWRITE));
 699      g_object_class_install_property(gobjectClass,
 700                                     PROP_LONG_LONG_ATTR,
 701                                     g_param_spec_int64("long-long-attr", /* name */
 702                                                            "test_obj_long-long-attr", /* short description */
 703                                                            "read-write  gint64 TestObj.long-long-attr", /* longer - could do with some extra doc stuff here */
 704                                                            G_MININT64, /* min */
 705 G_MAXINT64, /* max */
 706 0, /* default */
 707                                                            WEBKIT_PARAM_READWRITE));
 708      g_object_class_install_property(gobjectClass,
 709                                     PROP_UNSIGNED_LONG_LONG_ATTR,
 710                                     g_param_spec_uint64("unsigned-long-long-attr", /* name */
 711                                                            "test_obj_unsigned-long-long-attr", /* short description */
 712                                                            "read-write  guint64 TestObj.unsigned-long-long-attr", /* longer - could do with some extra doc stuff here */
 713                                                            0, /* min */
 714 G_MAXUINT64, /* min */
 715 0, /* default */
 716                                                            WEBKIT_PARAM_READWRITE));
 717      g_object_class_install_property(gobjectClass,
 718                                     PROP_STRING_ATTR,
 719                                     g_param_spec_string("string-attr", /* name */
 720                                                            "test_obj_string-attr", /* short description */
 721                                                            "read-write  gchar*  TestObj.string-attr", /* longer - could do with some extra doc stuff here */
 722                                                            "", /* default */
 723                                                            WEBKIT_PARAM_READWRITE));
 724      g_object_class_install_property(gobjectClass,
 725                                     PROP_TEST_OBJ_ATTR,
 726                                     g_param_spec_object("test-obj-attr", /* name */
 727                                                            "test_obj_test-obj-attr", /* short description */
 728                                                            "read-write  WebKitDOMTestObj*  TestObj.test-obj-attr", /* longer - could do with some extra doc stuff here */
 729                                                            WEBKIT_TYPE_DOM_TEST_OBJ, /* gobject type */
 730                                                            WEBKIT_PARAM_READWRITE));
 731      g_object_class_install_property(gobjectClass,
 732                                     PROP_ATTR_WITH_EXCEPTION,
 733                                     g_param_spec_long("attr-with-exception", /* name */
 734                                                            "test_obj_attr-with-exception", /* short description */
 735                                                            "read-write  glong TestObj.attr-with-exception", /* longer - could do with some extra doc stuff here */
 736                                                            G_MINLONG, /* min */
 737 G_MAXLONG, /* max */
 738 0, /* default */
 739                                                            WEBKIT_PARAM_READWRITE));
 740      g_object_class_install_property(gobjectClass,
 741                                     PROP_ATTR_WITH_SETTER_EXCEPTION,
 742                                     g_param_spec_long("attr-with-setter-exception", /* name */
 743                                                            "test_obj_attr-with-setter-exception", /* short description */
 744                                                            "read-write  glong TestObj.attr-with-setter-exception", /* longer - could do with some extra doc stuff here */
 745                                                            G_MINLONG, /* min */
 746 G_MAXLONG, /* max */
 747 0, /* default */
 748                                                            WEBKIT_PARAM_READWRITE));
 749      g_object_class_install_property(gobjectClass,
 750                                     PROP_ATTR_WITH_GETTER_EXCEPTION,
 751                                     g_param_spec_long("attr-with-getter-exception", /* name */
 752                                                            "test_obj_attr-with-getter-exception", /* short description */
 753                                                            "read-write  glong TestObj.attr-with-getter-exception", /* longer - could do with some extra doc stuff here */
 754                                                            G_MINLONG, /* min */
 755 G_MAXLONG, /* max */
 756 0, /* default */
 757                                                            WEBKIT_PARAM_READWRITE));
 758      g_object_class_install_property(gobjectClass,
 759                                     PROP_CUSTOM_ATTR,
 760                                     g_param_spec_long("custom-attr", /* name */
 761                                                            "test_obj_custom-attr", /* short description */
 762                                                            "read-write  glong TestObj.custom-attr", /* longer - could do with some extra doc stuff here */
 763                                                            G_MINLONG, /* min */
 764 G_MAXLONG, /* max */
 765 0, /* default */
 766                                                            WEBKIT_PARAM_READWRITE));
 767
 768
 769
 770 }
 771
 772 static void webkit_dom_test_obj_init(WebKitDOMTestObj* request)
 773 {
 774 }
 775