libs/gtkmm2/atk/atkmm/object.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <atkmm/object.h>
   5 #include <atkmm/private/object_p.h>
   6
   7 #include <atk/atk-enum-types.h>
   8 // -*- c++ -*-
   9 /* $Id$ */
  10
  11 /* Copyright 1998-2002 The gtkmm Development Team
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Library General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Library General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Library General Public
  24  * License along with this library; if not, write to the Free
  25  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  */
  27
  28 #include <atkmm/noopobject.h>
  29 #include <atkmm/relation.h>
  30 #include <atkmm/relationset.h>
  31 #include <atkmm/stateset.h>
  32 #include <atk/atkobject.h>
  33
  34
  35 namespace Atk
  36 {
  37
  38 /* AtkObject is actually an abstract base class.  So if this wrap_new()
  39  * function is called, it means that no wrapper exists for the real C object.
  40  * The problem is that gail (the real accessibility implementation) is
  41  * currently not wrapped and will probably never be.  Therefore, code like
  42  * in the following example is doomed to fail:
  43  *
  44  * Gtk::Image image ("icon.png");
  45  * Glib::RefPtr<Atk::Image> accessible = Glib::RefPtr<Atk::Image>::cast_dynamic(image.get_accessible());
  46  * accessible->set_image_description("my icon");
  47  *
  48  * This would segfault, even though the accessible object _does_ implement
  49  * AtkImage.  But Atk::Image is an interface class that can't be instantiated
  50  * as is.  It needs an object.
  51  *
  52  * The solution is to instantiate a dummy object that implements all of the
  53  * ATK interfaces.  Fortunately, ATK already provides us with such a thing,
  54  * AtkNoOpObject.  All widget accessible objects are of this type if the gail
  55  * module is not loaded (which is the default).
  56  *
  57  * So what we do here is abusing Atk::NoOpObject to get around the lack of
  58  * C++ wrappers for gail.  Instead of instantiating a useless instance of an
  59  * abstract base class, we just create a Atk::NoOpObject instance which can
  60  * be casted to any of the Atk interface classes.
  61  */
  62 Glib::ObjectBase* Object_Class::wrap_new(GObject* object)
  63 {
  64   return new Atk::NoOpObject((AtkNoOpObject*) object);
  65 }
  66
  67 } // namespace Atk
  68
  69
  70 namespace
  71 {
  72
  73
  74 static void Object_signal_children_changed_callback(AtkObject* self, guint p0,gpointer p1,void* data)
  75 {
  76   using namespace Atk;
  77   typedef sigc::slot< void,guint,gpointer > SlotType;
  78
  79   // Do not try to call a signal on a disassociated wrapper.
  80   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  81   {
  82     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  83     try
  84     {
  85     #endif //GLIBMM_EXCEPTIONS_ENABLED
  86       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  87         (*static_cast<SlotType*>(slot))(p0, p1);
  88     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  89     }
  90     catch(...)
  91     {
  92       Glib::exception_handlers_invoke();
  93     }
  94     #endif //GLIBMM_EXCEPTIONS_ENABLED
  95   }
  96 }
  97
  98 static const Glib::SignalProxyInfo Object_signal_children_changed_info =
  99 {
 100   "children_changed",
 101   (GCallback) &Object_signal_children_changed_callback,
 102   (GCallback) &Object_signal_children_changed_callback
 103 };
 104
 105
 106 static void Object_signal_focus_event_callback(AtkObject* self, gboolean p0,void* data)
 107 {
 108   using namespace Atk;
 109   typedef sigc::slot< void,bool > SlotType;
 110
 111   // Do not try to call a signal on a disassociated wrapper.
 112   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 113   {
 114     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 115     try
 116     {
 117     #endif //GLIBMM_EXCEPTIONS_ENABLED
 118       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 119         (*static_cast<SlotType*>(slot))(p0
 120 );
 121     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 122     }
 123     catch(...)
 124     {
 125       Glib::exception_handlers_invoke();
 126     }
 127     #endif //GLIBMM_EXCEPTIONS_ENABLED
 128   }
 129 }
 130
 131 static const Glib::SignalProxyInfo Object_signal_focus_event_info =
 132 {
 133   "focus_event",
 134   (GCallback) &Object_signal_focus_event_callback,
 135   (GCallback) &Object_signal_focus_event_callback
 136 };
 137
 138
 139 static void Object_signal_property_change_callback(AtkObject* self, AtkPropertyValues* p0,void* data)
 140 {
 141   using namespace Atk;
 142   typedef sigc::slot< void,AtkPropertyValues* > SlotType;
 143
 144   // Do not try to call a signal on a disassociated wrapper.
 145   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 146   {
 147     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 148     try
 149     {
 150     #endif //GLIBMM_EXCEPTIONS_ENABLED
 151       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 152         (*static_cast<SlotType*>(slot))(p0);
 153     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 154     }
 155     catch(...)
 156     {
 157       Glib::exception_handlers_invoke();
 158     }
 159     #endif //GLIBMM_EXCEPTIONS_ENABLED
 160   }
 161 }
 162
 163 static const Glib::SignalProxyInfo Object_signal_property_change_info =
 164 {
 165   "property_change",
 166   (GCallback) &Object_signal_property_change_callback,
 167   (GCallback) &Object_signal_property_change_callback
 168 };
 169
 170
 171 static void Object_signal_state_change_callback(AtkObject* self, const gchar* p0,gboolean p1,void* data)
 172 {
 173   using namespace Atk;
 174   typedef sigc::slot< void,const Glib::ustring&,bool > SlotType;
 175
 176   // Do not try to call a signal on a disassociated wrapper.
 177   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 178   {
 179     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 180     try
 181     {
 182     #endif //GLIBMM_EXCEPTIONS_ENABLED
 183       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 184         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 185 , p1
 186 );
 187     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 188     }
 189     catch(...)
 190     {
 191       Glib::exception_handlers_invoke();
 192     }
 193     #endif //GLIBMM_EXCEPTIONS_ENABLED
 194   }
 195 }
 196
 197 static const Glib::SignalProxyInfo Object_signal_state_change_info =
 198 {
 199   "state_change",
 200   (GCallback) &Object_signal_state_change_callback,
 201   (GCallback) &Object_signal_state_change_callback
 202 };
 203
 204
 205 static const Glib::SignalProxyInfo Object_signal_visible_data_changed_info =
 206 {
 207   "visible_data_changed",
 208   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 209   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 210 };
 211
 212
 213 static void Object_signal_active_descendant_changed_callback(AtkObject* self, gpointer* p0,void* data)
 214 {
 215   using namespace Atk;
 216   typedef sigc::slot< void,void** > SlotType;
 217
 218   // Do not try to call a signal on a disassociated wrapper.
 219   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 220   {
 221     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 222     try
 223     {
 224     #endif //GLIBMM_EXCEPTIONS_ENABLED
 225       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 226         (*static_cast<SlotType*>(slot))(p0
 227 );
 228     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 229     }
 230     catch(...)
 231     {
 232       Glib::exception_handlers_invoke();
 233     }
 234     #endif //GLIBMM_EXCEPTIONS_ENABLED
 235   }
 236 }
 237
 238 static const Glib::SignalProxyInfo Object_signal_active_descendant_changed_info =
 239 {
 240   "active_descendant_changed",
 241   (GCallback) &Object_signal_active_descendant_changed_callback,
 242   (GCallback) &Object_signal_active_descendant_changed_callback
 243 };
 244
 245
 246 } // anonymous namespace
 247
 248 // static
 249 GType Glib::Value<Atk::Role>::value_type()
 250 {
 251   return atk_role_get_type();
 252 }
 253
 254
 255 namespace Glib
 256 {
 257
 258 Glib::RefPtr<Atk::Object> wrap(AtkObject* object, bool take_copy)
 259 {
 260   return Glib::RefPtr<Atk::Object>( dynamic_cast<Atk::Object*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
 261   //We use dynamic_cast<> in case of multiple inheritance.
 262 }
 263
 264 } /* namespace Glib */
 265
 266
 267 namespace Atk
 268 {
 269
 270
 271 /* The *_Class implementation: */
 272
 273 const Glib::Class& Object_Class::init()
 274 {
 275   if(!gtype_) // create the GType if necessary
 276   {
 277     // Glib::Class has to know the class init function to clone custom types.
 278     class_init_func_ = &Object_Class::class_init_function;
 279
 280     // This is actually just optimized away, apparently with no harm.
 281     // Make sure that the parent type has been created.
 282     //CppClassParent::CppObjectType::get_type();
 283
 284     // Create the wrapper type, with the same class/instance size as the base type.
 285     register_derived_type(atk_object_get_type());
 286
 287     // Add derived versions of interfaces, if the C type implements any interfaces:
 288   }
 289
 290   return *this;
 291 }
 292
 293 void Object_Class::class_init_function(void* g_class, void* class_data)
 294 {
 295   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 296   CppClassParent::class_init_function(klass, class_data);
 297
 298 #ifdef GLIBMM_VFUNCS_ENABLED
 299 #endif //GLIBMM_VFUNCS_ENABLED
 300
 301 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 302   klass->children_changed = &children_changed_callback;
 303   klass->focus_event = &focus_event_callback;
 304   klass->property_change = &property_change_callback;
 305   klass->state_change = &state_change_callback;
 306   klass->visible_data_changed = &visible_data_changed_callback;
 307   klass->active_descendant_changed = &active_descendant_changed_callback;
 308 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 309 }
 310
 311 #ifdef GLIBMM_VFUNCS_ENABLED
 312 #endif //GLIBMM_VFUNCS_ENABLED
 313
 314 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 315 void Object_Class::children_changed_callback(AtkObject* self, guint p0, gpointer p1)
 316 {
 317   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 318       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 319
 320   // Non-gtkmmproc-generated custom classes implicitly call the default
 321   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 322   // generated classes can use this optimisation, which avoids the unnecessary
 323   // parameter conversions if there is no possibility of the virtual function
 324   // being overridden:
 325   if(obj && obj->is_derived_())
 326   {
 327     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 328     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 329     {
 330     #endif //GLIBMM_EXCEPTIONS_ENABLED
 331       // Call the virtual member method, which derived classes might override.
 332       obj->on_children_changed(p0, p1);
 333     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 334     }
 335     catch(...)
 336     {
 337       Glib::exception_handlers_invoke();
 338     }
 339     #endif //GLIBMM_EXCEPTIONS_ENABLED
 340   }
 341   else
 342   {
 343     BaseClassType *const base = static_cast<BaseClassType*>(
 344         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 345     );
 346
 347     // Call the original underlying C function:
 348     if(base && base->children_changed)
 349       (*base->children_changed)(self, p0, p1);
 350   }
 351 }
 352 void Object_Class::focus_event_callback(AtkObject* self, gboolean p0)
 353 {
 354   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 355       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 356
 357   // Non-gtkmmproc-generated custom classes implicitly call the default
 358   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 359   // generated classes can use this optimisation, which avoids the unnecessary
 360   // parameter conversions if there is no possibility of the virtual function
 361   // being overridden:
 362   if(obj && obj->is_derived_())
 363   {
 364     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 365     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 366     {
 367     #endif //GLIBMM_EXCEPTIONS_ENABLED
 368       // Call the virtual member method, which derived classes might override.
 369       obj->on_focus_event(p0
 370 );
 371     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 372     }
 373     catch(...)
 374     {
 375       Glib::exception_handlers_invoke();
 376     }
 377     #endif //GLIBMM_EXCEPTIONS_ENABLED
 378   }
 379   else
 380   {
 381     BaseClassType *const base = static_cast<BaseClassType*>(
 382         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 383     );
 384
 385     // Call the original underlying C function:
 386     if(base && base->focus_event)
 387       (*base->focus_event)(self, p0);
 388   }
 389 }
 390 void Object_Class::property_change_callback(AtkObject* self, AtkPropertyValues* p0)
 391 {
 392   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 393       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 394
 395   // Non-gtkmmproc-generated custom classes implicitly call the default
 396   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 397   // generated classes can use this optimisation, which avoids the unnecessary
 398   // parameter conversions if there is no possibility of the virtual function
 399   // being overridden:
 400   if(obj && obj->is_derived_())
 401   {
 402     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 403     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 404     {
 405     #endif //GLIBMM_EXCEPTIONS_ENABLED
 406       // Call the virtual member method, which derived classes might override.
 407       obj->on_property_change(p0);
 408     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 409     }
 410     catch(...)
 411     {
 412       Glib::exception_handlers_invoke();
 413     }
 414     #endif //GLIBMM_EXCEPTIONS_ENABLED
 415   }
 416   else
 417   {
 418     BaseClassType *const base = static_cast<BaseClassType*>(
 419         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 420     );
 421
 422     // Call the original underlying C function:
 423     if(base && base->property_change)
 424       (*base->property_change)(self, p0);
 425   }
 426 }
 427 void Object_Class::state_change_callback(AtkObject* self, const gchar* p0, gboolean p1)
 428 {
 429   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 430       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 431
 432   // Non-gtkmmproc-generated custom classes implicitly call the default
 433   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 434   // generated classes can use this optimisation, which avoids the unnecessary
 435   // parameter conversions if there is no possibility of the virtual function
 436   // being overridden:
 437   if(obj && obj->is_derived_())
 438   {
 439     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 440     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 441     {
 442     #endif //GLIBMM_EXCEPTIONS_ENABLED
 443       // Call the virtual member method, which derived classes might override.
 444       obj->on_state_change(Glib::convert_const_gchar_ptr_to_ustring(p0)
 445 , p1
 446 );
 447     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 448     }
 449     catch(...)
 450     {
 451       Glib::exception_handlers_invoke();
 452     }
 453     #endif //GLIBMM_EXCEPTIONS_ENABLED
 454   }
 455   else
 456   {
 457     BaseClassType *const base = static_cast<BaseClassType*>(
 458         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 459     );
 460
 461     // Call the original underlying C function:
 462     if(base && base->state_change)
 463       (*base->state_change)(self, p0, p1);
 464   }
 465 }
 466 void Object_Class::visible_data_changed_callback(AtkObject* self)
 467 {
 468   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 469       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 470
 471   // Non-gtkmmproc-generated custom classes implicitly call the default
 472   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 473   // generated classes can use this optimisation, which avoids the unnecessary
 474   // parameter conversions if there is no possibility of the virtual function
 475   // being overridden:
 476   if(obj && obj->is_derived_())
 477   {
 478     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 479     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 480     {
 481     #endif //GLIBMM_EXCEPTIONS_ENABLED
 482       // Call the virtual member method, which derived classes might override.
 483       obj->on_visible_data_changed();
 484     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 485     }
 486     catch(...)
 487     {
 488       Glib::exception_handlers_invoke();
 489     }
 490     #endif //GLIBMM_EXCEPTIONS_ENABLED
 491   }
 492   else
 493   {
 494     BaseClassType *const base = static_cast<BaseClassType*>(
 495         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 496     );
 497
 498     // Call the original underlying C function:
 499     if(base && base->visible_data_changed)
 500       (*base->visible_data_changed)(self);
 501   }
 502 }
 503 void Object_Class::active_descendant_changed_callback(AtkObject* self, gpointer* p0)
 504 {
 505   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 506       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 507
 508   // Non-gtkmmproc-generated custom classes implicitly call the default
 509   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 510   // generated classes can use this optimisation, which avoids the unnecessary
 511   // parameter conversions if there is no possibility of the virtual function
 512   // being overridden:
 513   if(obj && obj->is_derived_())
 514   {
 515     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 516     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 517     {
 518     #endif //GLIBMM_EXCEPTIONS_ENABLED
 519       // Call the virtual member method, which derived classes might override.
 520       obj->on_active_descendant_changed(p0
 521 );
 522     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 523     }
 524     catch(...)
 525     {
 526       Glib::exception_handlers_invoke();
 527     }
 528     #endif //GLIBMM_EXCEPTIONS_ENABLED
 529   }
 530   else
 531   {
 532     BaseClassType *const base = static_cast<BaseClassType*>(
 533         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 534     );
 535
 536     // Call the original underlying C function:
 537     if(base && base->active_descendant_changed)
 538       (*base->active_descendant_changed)(self, p0);
 539   }
 540 }
 541 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 542
 543
 544 /* The implementation: */
 545
 546 AtkObject* Object::gobj_copy()
 547 {
 548   reference();
 549   return gobj();
 550 }
 551
 552 Object::Object(const Glib::ConstructParams& construct_params)
 553 :
 554   Glib::Object(construct_params)
 555 {}
 556
 557 Object::Object(AtkObject* castitem)
 558 :
 559   Glib::Object((GObject*)(castitem))
 560 {}
 561
 562 Object::~Object()
 563 {}
 564
 565
 566 Object::CppClassType Object::object_class_; // initialize static member
 567
 568 GType Object::get_type()
 569 {
 570   return object_class_.init().get_type();
 571 }
 572
 573 GType Object::get_base_type()
 574 {
 575   return atk_object_get_type();
 576 }
 577
 578
 579 Glib::ustring Object::get_name() const
 580 {
 581   return Glib::convert_const_gchar_ptr_to_ustring(atk_object_get_name(const_cast<AtkObject*>(gobj())));
 582 }
 583
 584 Glib::ustring Object::get_description() const
 585 {
 586   return Glib::convert_const_gchar_ptr_to_ustring(atk_object_get_description(const_cast<AtkObject*>(gobj())));
 587 }
 588
 589 Glib::RefPtr<Atk::Object> Object::get_parent()
 590 {
 591
 592   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_object_get_parent(gobj()));
 593   if(retvalue)
 594     retvalue->reference(); //The function does not do a ref for us.
 595   return retvalue;
 596
 597 }
 598
 599 int Object::get_n_accessible_children() const
 600 {
 601   return atk_object_get_n_accessible_children(const_cast<AtkObject*>(gobj()));
 602 }
 603
 604 Glib::RefPtr<Atk::Object> Object::get_accessible_child(int i)
 605 {
 606   return Glib::wrap(atk_object_ref_accessible_child(gobj(), i));
 607 }
 608
 609 Glib::RefPtr<RelationSet> Object::get_relation_set()
 610 {
 611
 612   Glib::RefPtr<RelationSet> retvalue = Glib::wrap(atk_object_ref_relation_set(gobj()));
 613   if(retvalue)
 614     retvalue->reference(); //The function does not do a ref for us.
 615   return retvalue;
 616
 617 }
 618
 619 Role Object::get_role() const
 620 {
 621   return ((Role)(atk_object_get_role(const_cast<AtkObject*>(gobj()))));
 622 }
 623
 624 Glib::RefPtr<StateSet> Object::get_state_set()
 625 {
 626   return Glib::wrap(atk_object_ref_state_set(gobj()));
 627 }
 628
 629 int Object::get_index_in_parent()
 630 {
 631   return atk_object_get_index_in_parent(gobj());
 632 }
 633
 634 void Object::set_name(const Glib::ustring& name)
 635 {
 636 atk_object_set_name(gobj(), name.c_str());
 637 }
 638
 639 void Object::set_description(const Glib::ustring& description)
 640 {
 641 atk_object_set_description(gobj(), description.c_str());
 642 }
 643
 644 void Object::set_parent(const Glib::RefPtr<Atk::Object>& parent)
 645 {
 646 atk_object_set_parent(gobj(), Glib::unwrap(parent));
 647 }
 648
 649 void Object::set_role(Role role)
 650 {
 651 atk_object_set_role(gobj(), ((AtkRole)(role)));
 652 }
 653
 654 void Object::notify_state_change(State state, bool value)
 655 {
 656 atk_object_notify_state_change(gobj(), state, static_cast<int>(value));
 657 }
 658
 659 bool Object::add_relationship(RelationType relationship, const Glib::RefPtr<Object>& target)
 660 {
 661   return atk_object_add_relationship(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target));
 662 }
 663
 664 bool Object::remove_relationship(RelationType relationship, const Glib::RefPtr<Object>& target)
 665 {
 666   return atk_object_remove_relationship(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target));
 667 }
 668
 669
 670 Glib::SignalProxy2< void,guint,gpointer > Object::signal_children_changed()
 671 {
 672   return Glib::SignalProxy2< void,guint,gpointer >(this, &Object_signal_children_changed_info);
 673 }
 674
 675
 676 Glib::SignalProxy1< void,bool > Object::signal_focus_event()
 677 {
 678   return Glib::SignalProxy1< void,bool >(this, &Object_signal_focus_event_info);
 679 }
 680
 681
 682 Glib::SignalProxy1< void,AtkPropertyValues* > Object::signal_property_change()
 683 {
 684   return Glib::SignalProxy1< void,AtkPropertyValues* >(this, &Object_signal_property_change_info);
 685 }
 686
 687
 688 Glib::SignalProxy2< void,const Glib::ustring&,bool > Object::signal_state_change()
 689 {
 690   return Glib::SignalProxy2< void,const Glib::ustring&,bool >(this, &Object_signal_state_change_info);
 691 }
 692
 693
 694 Glib::SignalProxy0< void > Object::signal_visible_data_changed()
 695 {
 696   return Glib::SignalProxy0< void >(this, &Object_signal_visible_data_changed_info);
 697 }
 698
 699
 700 Glib::SignalProxy1< void,void** > Object::signal_active_descendant_changed()
 701 {
 702   return Glib::SignalProxy1< void,void** >(this, &Object_signal_active_descendant_changed_info);
 703 }
 704
 705
 706 #ifdef GLIBMM_PROPERTIES_ENABLED
 707 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_name()
 708 {
 709   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-name");
 710 }
 711 #endif //GLIBMM_PROPERTIES_ENABLED
 712
 713 #ifdef GLIBMM_PROPERTIES_ENABLED
 714 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_name() const
 715 {
 716   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-name");
 717 }
 718 #endif //GLIBMM_PROPERTIES_ENABLED
 719
 720 #ifdef GLIBMM_PROPERTIES_ENABLED
 721 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_description()
 722 {
 723   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-description");
 724 }
 725 #endif //GLIBMM_PROPERTIES_ENABLED
 726
 727 #ifdef GLIBMM_PROPERTIES_ENABLED
 728 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_description() const
 729 {
 730   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-description");
 731 }
 732 #endif //GLIBMM_PROPERTIES_ENABLED
 733
 734 #ifdef GLIBMM_PROPERTIES_ENABLED
 735 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_parent()
 736 {
 737   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-parent");
 738 }
 739 #endif //GLIBMM_PROPERTIES_ENABLED
 740
 741 #ifdef GLIBMM_PROPERTIES_ENABLED
 742 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_parent() const
 743 {
 744   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-parent");
 745 }
 746 #endif //GLIBMM_PROPERTIES_ENABLED
 747
 748 #ifdef GLIBMM_PROPERTIES_ENABLED
 749 Glib::PropertyProxy<double> Object::property_accessible_value()
 750 {
 751   return Glib::PropertyProxy<double>(this, "accessible-value");
 752 }
 753 #endif //GLIBMM_PROPERTIES_ENABLED
 754
 755 #ifdef GLIBMM_PROPERTIES_ENABLED
 756 Glib::PropertyProxy_ReadOnly<double> Object::property_accessible_value() const
 757 {
 758   return Glib::PropertyProxy_ReadOnly<double>(this, "accessible-value");
 759 }
 760 #endif //GLIBMM_PROPERTIES_ENABLED
 761
 762 #ifdef GLIBMM_PROPERTIES_ENABLED
 763 Glib::PropertyProxy<int> Object::property_accessible_role()
 764 {
 765   return Glib::PropertyProxy<int>(this, "accessible-role");
 766 }
 767 #endif //GLIBMM_PROPERTIES_ENABLED
 768
 769 #ifdef GLIBMM_PROPERTIES_ENABLED
 770 Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_role() const
 771 {
 772   return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-role");
 773 }
 774 #endif //GLIBMM_PROPERTIES_ENABLED
 775
 776 #ifdef GLIBMM_PROPERTIES_ENABLED
 777 Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_component_layer() const
 778 {
 779   return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-component-layer");
 780 }
 781 #endif //GLIBMM_PROPERTIES_ENABLED
 782
 783 #ifdef GLIBMM_PROPERTIES_ENABLED
 784 Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_component_mdi_zorder() const
 785 {
 786   return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-component-mdi-zorder");
 787 }
 788 #endif //GLIBMM_PROPERTIES_ENABLED
 789
 790 #ifdef GLIBMM_PROPERTIES_ENABLED
 791 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_caption()
 792 {
 793   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-caption");
 794 }
 795 #endif //GLIBMM_PROPERTIES_ENABLED
 796
 797 #ifdef GLIBMM_PROPERTIES_ENABLED
 798 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_caption() const
 799 {
 800   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-caption");
 801 }
 802 #endif //GLIBMM_PROPERTIES_ENABLED
 803
 804 #ifdef GLIBMM_PROPERTIES_ENABLED
 805 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_column_description()
 806 {
 807   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-column-description");
 808 }
 809 #endif //GLIBMM_PROPERTIES_ENABLED
 810
 811 #ifdef GLIBMM_PROPERTIES_ENABLED
 812 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_column_description() const
 813 {
 814   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-column-description");
 815 }
 816 #endif //GLIBMM_PROPERTIES_ENABLED
 817
 818 #ifdef GLIBMM_PROPERTIES_ENABLED
 819 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_column_header()
 820 {
 821   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-column-header");
 822 }
 823 #endif //GLIBMM_PROPERTIES_ENABLED
 824
 825 #ifdef GLIBMM_PROPERTIES_ENABLED
 826 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_column_header() const
 827 {
 828   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-column-header");
 829 }
 830 #endif //GLIBMM_PROPERTIES_ENABLED
 831
 832 #ifdef GLIBMM_PROPERTIES_ENABLED
 833 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_row_description()
 834 {
 835   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-row-description");
 836 }
 837 #endif //GLIBMM_PROPERTIES_ENABLED
 838
 839 #ifdef GLIBMM_PROPERTIES_ENABLED
 840 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_row_description() const
 841 {
 842   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-row-description");
 843 }
 844 #endif //GLIBMM_PROPERTIES_ENABLED
 845
 846 #ifdef GLIBMM_PROPERTIES_ENABLED
 847 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_row_header()
 848 {
 849   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-row-header");
 850 }
 851 #endif //GLIBMM_PROPERTIES_ENABLED
 852
 853 #ifdef GLIBMM_PROPERTIES_ENABLED
 854 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_row_header() const
 855 {
 856   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-row-header");
 857 }
 858 #endif //GLIBMM_PROPERTIES_ENABLED
 859
 860 #ifdef GLIBMM_PROPERTIES_ENABLED
 861 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_summary()
 862 {
 863   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-summary");
 864 }
 865 #endif //GLIBMM_PROPERTIES_ENABLED
 866
 867 #ifdef GLIBMM_PROPERTIES_ENABLED
 868 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_summary() const
 869 {
 870   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-summary");
 871 }
 872 #endif //GLIBMM_PROPERTIES_ENABLED
 873
 874
 875 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 876 void Atk::Object::on_children_changed(guint change_index, gpointer changed_child)
 877 {
 878   BaseClassType *const base = static_cast<BaseClassType*>(
 879       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 880   );
 881
 882   if(base && base->children_changed)
 883     (*base->children_changed)(gobj(),change_index,changed_child);
 884 }
 885 void Atk::Object::on_focus_event(bool focus_in)
 886 {
 887   BaseClassType *const base = static_cast<BaseClassType*>(
 888       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 889   );
 890
 891   if(base && base->focus_event)
 892     (*base->focus_event)(gobj(),static_cast<int>(focus_in));
 893 }
 894 void Atk::Object::on_property_change(AtkPropertyValues* values)
 895 {
 896   BaseClassType *const base = static_cast<BaseClassType*>(
 897       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 898   );
 899
 900   if(base && base->property_change)
 901     (*base->property_change)(gobj(),values);
 902 }
 903 void Atk::Object::on_state_change(const Glib::ustring& name, bool state_set)
 904 {
 905   BaseClassType *const base = static_cast<BaseClassType*>(
 906       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 907   );
 908
 909   if(base && base->state_change)
 910     (*base->state_change)(gobj(),name.c_str(),static_cast<int>(state_set));
 911 }
 912 void Atk::Object::on_visible_data_changed()
 913 {
 914   BaseClassType *const base = static_cast<BaseClassType*>(
 915       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 916   );
 917
 918   if(base && base->visible_data_changed)
 919     (*base->visible_data_changed)(gobj());
 920 }
 921 void Atk::Object::on_active_descendant_changed(void** child)
 922 {
 923   BaseClassType *const base = static_cast<BaseClassType*>(
 924       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 925   );
 926
 927   if(base && base->active_descendant_changed)
 928     (*base->active_descendant_changed)(gobj(),child);
 929 }
 930 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 931
 932 #ifdef GLIBMM_VFUNCS_ENABLED
 933 #endif //GLIBMM_VFUNCS_ENABLED
 934
 935
 936 } // namespace Atk
 937
 938