libs/gtkmm2/atk/atkmm/object.cc

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