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/WebKitDOMTestObj.h"
  31 #include "webkit/WebKitDOMTestObjPrivate.h"
  32 #include "webkit/WebKitDOMlog.h"
  33 #include "webkit/WebKitDOMlogPrivate.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_method_with_exception (WebKitDOMTestObj *self, GError **error)
 128 {
 129     g_return_if_fail (self);
 130     WebCore::TestObj * item = WebKit::core(self);
 131     WebCore::ExceptionCode ec = 0;
 132     item->methodWithException(ec);
 133     if (ec) {
 134         WebCore::ExceptionCodeDescription ecdesc;
 135         WebCore::getExceptionCodeDescription(ec, ecdesc);
 136         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
 137     }
 138
 139 }
 140
 141
 142 /* TODO: custom function webkit_dom_test_obj_custom_args_and_exception */
 143
 144 void
 145 webkit_dom_test_obj_with_dynamic_frame (WebKitDOMTestObj *self)
 146 {
 147     g_return_if_fail (self);
 148     WebCore::TestObj * item = WebKit::core(self);
 149     item->withDynamicFrame();
 150
 151 }
 152
 153 void
 154 webkit_dom_test_obj_with_dynamic_frame_and_arg (WebKitDOMTestObj *self, glong int_arg)
 155 {
 156     g_return_if_fail (self);
 157     WebCore::TestObj * item = WebKit::core(self);
 158     item->withDynamicFrameAndArg(int_arg);
 159
 160 }
 161
 162 void
 163 webkit_dom_test_obj_with_dynamic_frame_and_optional_arg (WebKitDOMTestObj *self, glong int_arg, glong optional_arg)
 164 {
 165     g_return_if_fail (self);
 166     WebCore::TestObj * item = WebKit::core(self);
 167     item->withDynamicFrameAndOptionalArg(int_arg, optional_arg);
 168
 169 }
 170
 171 void
 172 webkit_dom_test_obj_with_dynamic_frame_and_user_gesture (WebKitDOMTestObj *self, glong int_arg)
 173 {
 174     g_return_if_fail (self);
 175     WebCore::TestObj * item = WebKit::core(self);
 176     item->withDynamicFrameAndUserGesture(int_arg);
 177
 178 }
 179
 180 void
 181 webkit_dom_test_obj_with_dynamic_frame_and_user_gesture_asad (WebKitDOMTestObj *self, glong int_arg, glong optional_arg)
 182 {
 183     g_return_if_fail (self);
 184     WebCore::TestObj * item = WebKit::core(self);
 185     item->withDynamicFrameAndUserGestureASAD(int_arg, optional_arg);
 186
 187 }
 188
 189 void
 190 webkit_dom_test_obj_with_script_state_void (WebKitDOMTestObj *self)
 191 {
 192     g_return_if_fail (self);
 193     WebCore::TestObj * item = WebKit::core(self);
 194     item->withScriptStateVoid();
 195
 196 }
 197
 198 WebKitDOMTestObj*
 199 webkit_dom_test_obj_with_script_state_obj (WebKitDOMTestObj *self)
 200 {
 201     g_return_val_if_fail (self, 0);
 202     WebCore::TestObj * item = WebKit::core(self);
 203     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->withScriptStateObj());
 204     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 205     return res;
 206
 207 }
 208
 209 void
 210 webkit_dom_test_obj_method_with_optional_arg (WebKitDOMTestObj *self, glong opt)
 211 {
 212     g_return_if_fail (self);
 213     WebCore::TestObj * item = WebKit::core(self);
 214     item->methodWithOptionalArg(opt);
 215
 216 }
 217
 218 void
 219 webkit_dom_test_obj_method_with_non_optional_arg_and_optional_arg (WebKitDOMTestObj *self, glong non_opt, glong opt)
 220 {
 221     g_return_if_fail (self);
 222     WebCore::TestObj * item = WebKit::core(self);
 223     item->methodWithNonOptionalArgAndOptionalArg(non_opt, opt);
 224
 225 }
 226
 227 void
 228 webkit_dom_test_obj_method_with_non_optional_arg_and_two_optional_args (WebKitDOMTestObj *self, glong non_opt, glong opt1, glong opt2)
 229 {
 230     g_return_if_fail (self);
 231     WebCore::TestObj * item = WebKit::core(self);
 232     item->methodWithNonOptionalArgAndTwoOptionalArgs(non_opt, opt1, opt2);
 233
 234 }
 235
 236 glong
 237 webkit_dom_test_obj_get_read_only_int_attr (WebKitDOMTestObj *self)
 238 {
 239     g_return_val_if_fail (self, 0);
 240     WebCore::TestObj * item = WebKit::core(self);
 241     glong res = item->readOnlyIntAttr();
 242     return res;
 243
 244 }
 245
 246 gchar*
 247 webkit_dom_test_obj_get_read_only_string_attr (WebKitDOMTestObj *self)
 248 {
 249     g_return_val_if_fail (self, 0);
 250     WebCore::TestObj * item = WebKit::core(self);
 251     gchar*  res = convertToUTF8String(item->readOnlyStringAttr());
 252     return res;
 253
 254 }
 255
 256 WebKitDOMTestObj*
 257 webkit_dom_test_obj_get_read_only_test_obj_attr (WebKitDOMTestObj *self)
 258 {
 259     g_return_val_if_fail (self, 0);
 260     WebCore::TestObj * item = WebKit::core(self);
 261     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->readOnlyTestObjAttr());
 262     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 263     return res;
 264
 265 }
 266
 267 glong
 268 webkit_dom_test_obj_get_int_attr (WebKitDOMTestObj *self)
 269 {
 270     g_return_val_if_fail (self, 0);
 271     WebCore::TestObj * item = WebKit::core(self);
 272     glong res = item->intAttr();
 273     return res;
 274
 275 }
 276
 277 void
 278 webkit_dom_test_obj_set_int_attr (WebKitDOMTestObj *self, glong value)
 279 {
 280     g_return_if_fail (self);
 281     WebCore::TestObj * item = WebKit::core(self);
 282     item->setIntAttr(value);
 283
 284 }
 285
 286 gchar*
 287 webkit_dom_test_obj_get_string_attr (WebKitDOMTestObj *self)
 288 {
 289     g_return_val_if_fail (self, 0);
 290     WebCore::TestObj * item = WebKit::core(self);
 291     gchar*  res = convertToUTF8String(item->stringAttr());
 292     return res;
 293
 294 }
 295
 296 void
 297 webkit_dom_test_obj_set_string_attr (WebKitDOMTestObj *self, gchar*  value)
 298 {
 299     g_return_if_fail (self);
 300     WebCore::TestObj * item = WebKit::core(self);
 301     g_return_if_fail (value);
 302     WebCore::String _g_value = WebCore::String::fromUTF8(value);
 303     item->setStringAttr(_g_value);
 304
 305 }
 306
 307 WebKitDOMTestObj*
 308 webkit_dom_test_obj_get_test_obj_attr (WebKitDOMTestObj *self)
 309 {
 310     g_return_val_if_fail (self, 0);
 311     WebCore::TestObj * item = WebKit::core(self);
 312     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->testObjAttr());
 313     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
 314     return res;
 315
 316 }
 317
 318 void
 319 webkit_dom_test_obj_set_test_obj_attr (WebKitDOMTestObj *self, WebKitDOMTestObj*  value)
 320 {
 321     g_return_if_fail (self);
 322     WebCore::TestObj * item = WebKit::core(self);
 323     g_return_if_fail (value);
 324     WebCore::TestObj * _g_value = WebKit::core(value);
 325     g_return_if_fail (_g_value);
 326     item->setTestObjAttr(_g_value);
 327
 328 }
 329
 330 glong
 331 webkit_dom_test_obj_get_attr_with_exception (WebKitDOMTestObj *self)
 332 {
 333     g_return_val_if_fail (self, 0);
 334     WebCore::TestObj * item = WebKit::core(self);
 335     glong res = item->attrWithException();
 336     return res;
 337
 338 }
 339
 340 void
 341 webkit_dom_test_obj_set_attr_with_exception (WebKitDOMTestObj *self, glong value)
 342 {
 343     g_return_if_fail (self);
 344     WebCore::TestObj * item = WebKit::core(self);
 345     item->setAttrWithException(value);
 346
 347 }
 348
 349 glong
 350 webkit_dom_test_obj_get_attr_with_setter_exception (WebKitDOMTestObj *self)
 351 {
 352     g_return_val_if_fail (self, 0);
 353     WebCore::TestObj * item = WebKit::core(self);
 354     glong res = item->attrWithSetterException();
 355     return res;
 356
 357 }
 358
 359 void
 360 webkit_dom_test_obj_set_attr_with_setter_exception (WebKitDOMTestObj *self, glong value)
 361 {
 362     g_return_if_fail (self);
 363     WebCore::TestObj * item = WebKit::core(self);
 364     item->setAttrWithSetterException(value);
 365
 366 }
 367
 368 glong
 369 webkit_dom_test_obj_get_attr_with_getter_exception (WebKitDOMTestObj *self)
 370 {
 371     g_return_val_if_fail (self, 0);
 372     WebCore::TestObj * item = WebKit::core(self);
 373     glong res = item->attrWithGetterException();
 374     return res;
 375
 376 }
 377
 378 void
 379 webkit_dom_test_obj_set_attr_with_getter_exception (WebKitDOMTestObj *self, glong value)
 380 {
 381     g_return_if_fail (self);
 382     WebCore::TestObj * item = WebKit::core(self);
 383     item->setAttrWithGetterException(value);
 384
 385 }
 386
 387
 388 G_DEFINE_TYPE(WebKitDOMTestObj, webkit_dom_test_obj, WEBKIT_TYPE_DOM_OBJECT)
 389
 390 namespace WebKit {
 391
 392 WebKitDOMTestObj* wrapTestObj(WebCore::TestObj* coreObject)
 393 {
 394     g_return_val_if_fail(coreObject != 0, 0);
 395
 396     WebKitDOMTestObj* wrapper = WEBKIT_DOM_TEST_OBJ(g_object_new(WEBKIT_TYPE_DOM_TEST_OBJ, NULL));
 397     g_return_val_if_fail(wrapper != 0, 0);
 398
 399     /* We call ref() rather than using a C++ smart pointer because we can't store a C++ object
 400      * in a C-allocated GObject structure.  See the finalize() code for the
 401      * matching deref().
 402      */
 403
 404     coreObject->ref();
 405     WEBKIT_DOM_OBJECT(wrapper)->coreObject = coreObject;
 406
 407     return wrapper;
 408 }
 409
 410 WebCore::TestObj* core(WebKitDOMTestObj* request)
 411 {
 412     g_return_val_if_fail(request != 0, 0);
 413
 414     WebCore::TestObj* coreObject = static_cast<WebCore::TestObj*>(WEBKIT_DOM_OBJECT(request)->coreObject);
 415     g_return_val_if_fail(coreObject != 0, 0);
 416
 417     return coreObject;
 418 }
 419
 420 } // namespace WebKit
 421 enum {
 422     PROP_0,
 423     PROP_READ_ONLY_INT_ATTR,
 424     PROP_READ_ONLY_STRING_ATTR,
 425     PROP_READ_ONLY_TEST_OBJ_ATTR,
 426     PROP_INT_ATTR,
 427     PROP_STRING_ATTR,
 428     PROP_TEST_OBJ_ATTR,
 429     PROP_ATTR_WITH_EXCEPTION,
 430     PROP_ATTR_WITH_SETTER_EXCEPTION,
 431     PROP_ATTR_WITH_GETTER_EXCEPTION,
 432     PROP_CUSTOM_ATTR,
 433 };
 434
 435
 436 static void webkit_dom_test_obj_finalize(GObject* object)
 437 {
 438     WebKitDOMObject* dom_object = WEBKIT_DOM_OBJECT(object);
 439
 440     if (dom_object->coreObject != NULL) {
 441         WebCore::TestObj* coreObject = static_cast<WebCore::TestObj *>(dom_object->coreObject);
 442
 443         WebKit::DOMObjectCache::forget(coreObject);
 444         coreObject->deref();
 445
 446         dom_object->coreObject = NULL;
 447     }
 448
 449     G_OBJECT_CLASS(webkit_dom_test_obj_parent_class)->finalize(object);
 450 }
 451
 452 static void webkit_dom_test_obj_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
 453 {
 454     WebKitDOMTestObj *self = WEBKIT_DOM_TEST_OBJ(object);
 455     WebCore::TestObj* coreSelf = WebKit::core(self);
 456
 457     switch (prop_id) {
 458     case PROP_INT_ATTR:
 459     {
 460          coreSelf->setIntAttr((g_value_get_long(value)) );
 461          break;
 462     }
 463     case PROP_STRING_ATTR:
 464     {
 465          coreSelf->setStringAttr(WebCore::String::fromUTF8(g_value_get_string(value)) );
 466          break;
 467     }
 468     case PROP_ATTR_WITH_EXCEPTION:
 469     {
 470          coreSelf->setAttrWithException((g_value_get_long(value)) );
 471          break;
 472     }
 473     case PROP_ATTR_WITH_SETTER_EXCEPTION:
 474     {
 475          coreSelf->setAttrWithSetterException((g_value_get_long(value)) );
 476          break;
 477     }
 478     case PROP_ATTR_WITH_GETTER_EXCEPTION:
 479     {
 480          coreSelf->setAttrWithGetterException((g_value_get_long(value)) );
 481          break;
 482     }
 483     case PROP_CUSTOM_ATTR:
 484     {
 485          coreSelf->setCustomAttr((g_value_get_long(value)) );
 486          break;
 487     }
 488      default:
 489         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 490         break;
 491     }
 492 }
 493
 494
 495 static void webkit_dom_test_obj_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
 496 {
 497     WebKitDOMTestObj* self = WEBKIT_DOM_TEST_OBJ(object);
 498     WebCore::TestObj* coreSelf = WebKit::core(self);
 499
 500     switch (prop_id) {
 501     case PROP_READ_ONLY_INT_ATTR:
 502     {
 503          g_value_set_long(value, coreSelf->readOnlyIntAttr());
 504          break;
 505     }
 506     case PROP_READ_ONLY_STRING_ATTR:
 507     {
 508          g_value_take_string(value, convertToUTF8String(coreSelf->readOnlyStringAttr()));
 509          break;
 510     }
 511     case PROP_READ_ONLY_TEST_OBJ_ATTR:
 512     {
 513          RefPtr<WebCore::TestObj> ptr = coreSelf->readOnlyTestObjAttr();
 514         g_value_set_object(value, WebKit::kit(ptr.get()));
 515          break;
 516     }
 517     case PROP_INT_ATTR:
 518     {
 519          g_value_set_long(value, coreSelf->intAttr());
 520          break;
 521     }
 522     case PROP_STRING_ATTR:
 523     {
 524          g_value_take_string(value, convertToUTF8String(coreSelf->stringAttr()));
 525          break;
 526     }
 527     case PROP_TEST_OBJ_ATTR:
 528     {
 529          RefPtr<WebCore::TestObj> ptr = coreSelf->testObjAttr();
 530         g_value_set_object(value, WebKit::kit(ptr.get()));
 531          break;
 532     }
 533     case PROP_ATTR_WITH_EXCEPTION:
 534     {
 535          g_value_set_long(value, coreSelf->attrWithException());
 536          break;
 537     }
 538     case PROP_ATTR_WITH_SETTER_EXCEPTION:
 539     {
 540          g_value_set_long(value, coreSelf->attrWithSetterException());
 541          break;
 542     }
 543     case PROP_ATTR_WITH_GETTER_EXCEPTION:
 544     {
 545          g_value_set_long(value, coreSelf->attrWithGetterException());
 546          break;
 547     }
 548     case PROP_CUSTOM_ATTR:
 549     {
 550          g_value_set_long(value, coreSelf->customAttr());
 551          break;
 552     }
 553      default:
 554         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 555         break;
 556     }
 557 }
 558
 559
 560 static void webkit_dom_test_obj_class_init(WebKitDOMTestObjClass* requestClass)
 561 {
 562     GObjectClass *gobjectClass = G_OBJECT_CLASS(requestClass);
 563     gobjectClass->finalize = webkit_dom_test_obj_finalize;
 564     gobjectClass->set_property = webkit_dom_test_obj_set_property;
 565     gobjectClass->get_property = webkit_dom_test_obj_get_property;
 566
 567     g_object_class_install_property(gobjectClass,
 568                                     PROP_READ_ONLY_INT_ATTR,
 569                                     g_param_spec_long("read-only-int-attr", /* name */
 570                                                            "test_obj_read-only-int-attr", /* short description */
 571                                                            "read-only  glong TestObj.read-only-int-attr", /* longer - could do with some extra doc stuff here */
 572                                                            G_MINLONG, /* min */
 573 G_MAXLONG, /* max */
 574 0, /* default */
 575                                                            WEBKIT_PARAM_READABLE));
 576      g_object_class_install_property(gobjectClass,
 577                                     PROP_READ_ONLY_STRING_ATTR,
 578                                     g_param_spec_string("read-only-string-attr", /* name */
 579                                                            "test_obj_read-only-string-attr", /* short description */
 580                                                            "read-only  gchar*  TestObj.read-only-string-attr", /* longer - could do with some extra doc stuff here */
 581                                                            "", /* default */
 582                                                            WEBKIT_PARAM_READABLE));
 583      g_object_class_install_property(gobjectClass,
 584                                     PROP_READ_ONLY_TEST_OBJ_ATTR,
 585                                     g_param_spec_object("read-only-test-obj-attr", /* name */
 586                                                            "test_obj_read-only-test-obj-attr", /* short description */
 587                                                            "read-only  WebKitDOMTestObj*  TestObj.read-only-test-obj-attr", /* longer - could do with some extra doc stuff here */
 588                                                            WEBKIT_TYPE_DOM_TEST_OBJ, /* gobject type */
 589                                                            WEBKIT_PARAM_READABLE));
 590      g_object_class_install_property(gobjectClass,
 591                                     PROP_INT_ATTR,
 592                                     g_param_spec_long("int-attr", /* name */
 593                                                            "test_obj_int-attr", /* short description */
 594                                                            "read-write  glong TestObj.int-attr", /* longer - could do with some extra doc stuff here */
 595                                                            G_MINLONG, /* min */
 596 G_MAXLONG, /* max */
 597 0, /* default */
 598                                                            WEBKIT_PARAM_READWRITE));
 599      g_object_class_install_property(gobjectClass,
 600                                     PROP_STRING_ATTR,
 601                                     g_param_spec_string("string-attr", /* name */
 602                                                            "test_obj_string-attr", /* short description */
 603                                                            "read-write  gchar*  TestObj.string-attr", /* longer - could do with some extra doc stuff here */
 604                                                            "", /* default */
 605                                                            WEBKIT_PARAM_READWRITE));
 606      g_object_class_install_property(gobjectClass,
 607                                     PROP_TEST_OBJ_ATTR,
 608                                     g_param_spec_object("test-obj-attr", /* name */
 609                                                            "test_obj_test-obj-attr", /* short description */
 610                                                            "read-write  WebKitDOMTestObj*  TestObj.test-obj-attr", /* longer - could do with some extra doc stuff here */
 611                                                            WEBKIT_TYPE_DOM_TEST_OBJ, /* gobject type */
 612                                                            WEBKIT_PARAM_READWRITE));
 613      g_object_class_install_property(gobjectClass,
 614                                     PROP_ATTR_WITH_EXCEPTION,
 615                                     g_param_spec_long("attr-with-exception", /* name */
 616                                                            "test_obj_attr-with-exception", /* short description */
 617                                                            "read-write  glong TestObj.attr-with-exception", /* longer - could do with some extra doc stuff here */
 618                                                            G_MINLONG, /* min */
 619 G_MAXLONG, /* max */
 620 0, /* default */
 621                                                            WEBKIT_PARAM_READWRITE));
 622      g_object_class_install_property(gobjectClass,
 623                                     PROP_ATTR_WITH_SETTER_EXCEPTION,
 624                                     g_param_spec_long("attr-with-setter-exception", /* name */
 625                                                            "test_obj_attr-with-setter-exception", /* short description */
 626                                                            "read-write  glong TestObj.attr-with-setter-exception", /* longer - could do with some extra doc stuff here */
 627                                                            G_MINLONG, /* min */
 628 G_MAXLONG, /* max */
 629 0, /* default */
 630                                                            WEBKIT_PARAM_READWRITE));
 631      g_object_class_install_property(gobjectClass,
 632                                     PROP_ATTR_WITH_GETTER_EXCEPTION,
 633                                     g_param_spec_long("attr-with-getter-exception", /* name */
 634                                                            "test_obj_attr-with-getter-exception", /* short description */
 635                                                            "read-write  glong TestObj.attr-with-getter-exception", /* longer - could do with some extra doc stuff here */
 636                                                            G_MINLONG, /* min */
 637 G_MAXLONG, /* max */
 638 0, /* default */
 639                                                            WEBKIT_PARAM_READWRITE));
 640      g_object_class_install_property(gobjectClass,
 641                                     PROP_CUSTOM_ATTR,
 642                                     g_param_spec_long("custom-attr", /* name */
 643                                                            "test_obj_custom-attr", /* short description */
 644                                                            "read-write  glong TestObj.custom-attr", /* longer - could do with some extra doc stuff here */
 645                                                            G_MINLONG, /* min */
 646 G_MAXLONG, /* max */
 647 0, /* default */
 648                                                            WEBKIT_PARAM_READWRITE));
 649
 650
 651
 652 }
 653
 654 static void webkit_dom_test_obj_init(WebKitDOMTestObj* request)
 655 {
 656 }
 657