libs/gtkmm2/atk/atkmm/hyperlink.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <atkmm/hyperlink.h>
   5 #include <atkmm/private/hyperlink_p.h>
   6
   7 // -*- c++ -*-
   8 /* $Id$ */
   9
  10 /* Copyright 2003 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/object.h>
  28 #include <atk/atkobject.h>
  29 #include <atk/atkhyperlink.h>
  30
  31
  32 namespace Atk
  33 {
  34
  35 } // namespace Atk
  36
  37
  38 namespace
  39 {
  40
  41
  42 static const Glib::SignalProxyInfo Hyperlink_signal_link_activated_info =
  43 {
  44   "link_activated",
  45   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  46   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
  47 };
  48
  49
  50 } // anonymous namespace
  51
  52
  53 namespace Glib
  54 {
  55
  56 Glib::RefPtr<Atk::Hyperlink> wrap(AtkHyperlink* object, bool take_copy)
  57 {
  58   return Glib::RefPtr<Atk::Hyperlink>( dynamic_cast<Atk::Hyperlink*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  59   //We use dynamic_cast<> in case of multiple inheritance.
  60 }
  61
  62 } /* namespace Glib */
  63
  64
  65 namespace Atk
  66 {
  67
  68
  69 /* The *_Class implementation: */
  70
  71 const Glib::Class& Hyperlink_Class::init()
  72 {
  73   if(!gtype_) // create the GType if necessary
  74   {
  75     // Glib::Class has to know the class init function to clone custom types.
  76     class_init_func_ = &Hyperlink_Class::class_init_function;
  77
  78     // This is actually just optimized away, apparently with no harm.
  79     // Make sure that the parent type has been created.
  80     //CppClassParent::CppObjectType::get_type();
  81
  82     // Create the wrapper type, with the same class/instance size as the base type.
  83     register_derived_type(atk_hyperlink_get_type());
  84
  85     // Add derived versions of interfaces, if the C type implements any interfaces:
  86   Action::add_interface(get_type());
  87   }
  88
  89   return *this;
  90 }
  91
  92 void Hyperlink_Class::class_init_function(void* g_class, void* class_data)
  93 {
  94   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  95   CppClassParent::class_init_function(klass, class_data);
  96
  97 #ifdef GLIBMM_VFUNCS_ENABLED
  98   klass->get_uri = &get_uri_vfunc_callback;
  99   klass->get_object = &get_object_vfunc_callback;
 100   klass->get_end_index = &get_end_index_vfunc_callback;
 101   klass->get_start_index = &get_start_index_vfunc_callback;
 102   klass->is_valid = &is_valid_vfunc_callback;
 103   klass->get_n_anchors = &get_n_anchors_vfunc_callback;
 104   klass->link_state = &link_state_vfunc_callback;
 105   klass->is_selected_link = &is_selected_link_vfunc_callback;
 106 #endif //GLIBMM_VFUNCS_ENABLED
 107
 108 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 109   klass->link_activated = &link_activated_callback;
 110 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 111 }
 112
 113 #ifdef GLIBMM_VFUNCS_ENABLED
 114 gchar* Hyperlink_Class::get_uri_vfunc_callback(AtkHyperlink* self, gint i)
 115 {
 116   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 117       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 118
 119   // Non-gtkmmproc-generated custom classes implicitly call the default
 120   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 121   // generated classes can use this optimisation, which avoids the unnecessary
 122   // parameter conversions if there is no possibility of the virtual function
 123   // being overridden:
 124   if(obj_base && obj_base->is_derived_())
 125   {
 126     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 127     if(obj) // This can be NULL during destruction.
 128     {
 129       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 130       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 131       {
 132       #endif //GLIBMM_EXCEPTIONS_ENABLED
 133         // Call the virtual member method, which derived classes might override.
 134         return obj->get_uri_vfunc(i
 135 );
 136       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 137       }
 138       catch(...)
 139       {
 140         Glib::exception_handlers_invoke();
 141       }
 142       #endif //GLIBMM_EXCEPTIONS_ENABLED
 143     }
 144   }
 145
 146   BaseClassType *const base = static_cast<BaseClassType*>(
 147       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 148   );
 149
 150   // Call the original underlying C function:
 151   if(base && base->get_uri)
 152     return (*base->get_uri)(self, i);
 153
 154
 155   typedef gchar* RType;
 156   return RType();
 157 }
 158 AtkObject* Hyperlink_Class::get_object_vfunc_callback(AtkHyperlink* self, gint i)
 159 {
 160   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 161       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 162
 163   // Non-gtkmmproc-generated custom classes implicitly call the default
 164   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 165   // generated classes can use this optimisation, which avoids the unnecessary
 166   // parameter conversions if there is no possibility of the virtual function
 167   // being overridden:
 168   if(obj_base && obj_base->is_derived_())
 169   {
 170     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 171     if(obj) // This can be NULL during destruction.
 172     {
 173       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 174       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 175       {
 176       #endif //GLIBMM_EXCEPTIONS_ENABLED
 177         // Call the virtual member method, which derived classes might override.
 178         return Glib::unwrap(obj->get_object_vfunc(i
 179 ));
 180       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 181       }
 182       catch(...)
 183       {
 184         Glib::exception_handlers_invoke();
 185       }
 186       #endif //GLIBMM_EXCEPTIONS_ENABLED
 187     }
 188   }
 189
 190   BaseClassType *const base = static_cast<BaseClassType*>(
 191       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 192   );
 193
 194   // Call the original underlying C function:
 195   if(base && base->get_object)
 196     return (*base->get_object)(self, i);
 197
 198
 199   typedef AtkObject* RType;
 200   return RType();
 201 }
 202 gint Hyperlink_Class::get_end_index_vfunc_callback(AtkHyperlink* self)
 203 {
 204   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 205       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 206
 207   // Non-gtkmmproc-generated custom classes implicitly call the default
 208   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 209   // generated classes can use this optimisation, which avoids the unnecessary
 210   // parameter conversions if there is no possibility of the virtual function
 211   // being overridden:
 212   if(obj_base && obj_base->is_derived_())
 213   {
 214     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 215     if(obj) // This can be NULL during destruction.
 216     {
 217       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 218       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 219       {
 220       #endif //GLIBMM_EXCEPTIONS_ENABLED
 221         // Call the virtual member method, which derived classes might override.
 222         return obj->get_end_index_vfunc();
 223       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 224       }
 225       catch(...)
 226       {
 227         Glib::exception_handlers_invoke();
 228       }
 229       #endif //GLIBMM_EXCEPTIONS_ENABLED
 230     }
 231   }
 232
 233   BaseClassType *const base = static_cast<BaseClassType*>(
 234       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 235   );
 236
 237   // Call the original underlying C function:
 238   if(base && base->get_end_index)
 239     return (*base->get_end_index)(self);
 240
 241
 242   typedef gint RType;
 243   return RType();
 244 }
 245 gint Hyperlink_Class::get_start_index_vfunc_callback(AtkHyperlink* self)
 246 {
 247   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 248       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 249
 250   // Non-gtkmmproc-generated custom classes implicitly call the default
 251   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 252   // generated classes can use this optimisation, which avoids the unnecessary
 253   // parameter conversions if there is no possibility of the virtual function
 254   // being overridden:
 255   if(obj_base && obj_base->is_derived_())
 256   {
 257     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 258     if(obj) // This can be NULL during destruction.
 259     {
 260       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 261       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 262       {
 263       #endif //GLIBMM_EXCEPTIONS_ENABLED
 264         // Call the virtual member method, which derived classes might override.
 265         return obj->get_start_index_vfunc();
 266       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 267       }
 268       catch(...)
 269       {
 270         Glib::exception_handlers_invoke();
 271       }
 272       #endif //GLIBMM_EXCEPTIONS_ENABLED
 273     }
 274   }
 275
 276   BaseClassType *const base = static_cast<BaseClassType*>(
 277       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 278   );
 279
 280   // Call the original underlying C function:
 281   if(base && base->get_start_index)
 282     return (*base->get_start_index)(self);
 283
 284
 285   typedef gint RType;
 286   return RType();
 287 }
 288 gboolean Hyperlink_Class::is_valid_vfunc_callback(AtkHyperlink* self)
 289 {
 290   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 291       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 292
 293   // Non-gtkmmproc-generated custom classes implicitly call the default
 294   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 295   // generated classes can use this optimisation, which avoids the unnecessary
 296   // parameter conversions if there is no possibility of the virtual function
 297   // being overridden:
 298   if(obj_base && obj_base->is_derived_())
 299   {
 300     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 301     if(obj) // This can be NULL during destruction.
 302     {
 303       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 304       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 305       {
 306       #endif //GLIBMM_EXCEPTIONS_ENABLED
 307         // Call the virtual member method, which derived classes might override.
 308         return static_cast<int>(obj->is_valid_vfunc());
 309       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 310       }
 311       catch(...)
 312       {
 313         Glib::exception_handlers_invoke();
 314       }
 315       #endif //GLIBMM_EXCEPTIONS_ENABLED
 316     }
 317   }
 318
 319   BaseClassType *const base = static_cast<BaseClassType*>(
 320       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 321   );
 322
 323   // Call the original underlying C function:
 324   if(base && base->is_valid)
 325     return (*base->is_valid)(self);
 326
 327
 328   typedef gboolean RType;
 329   return RType();
 330 }
 331 gint Hyperlink_Class::get_n_anchors_vfunc_callback(AtkHyperlink* self)
 332 {
 333   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 334       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 335
 336   // Non-gtkmmproc-generated custom classes implicitly call the default
 337   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 338   // generated classes can use this optimisation, which avoids the unnecessary
 339   // parameter conversions if there is no possibility of the virtual function
 340   // being overridden:
 341   if(obj_base && obj_base->is_derived_())
 342   {
 343     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 344     if(obj) // This can be NULL during destruction.
 345     {
 346       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 347       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 348       {
 349       #endif //GLIBMM_EXCEPTIONS_ENABLED
 350         // Call the virtual member method, which derived classes might override.
 351         return obj->get_n_anchors_vfunc();
 352       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 353       }
 354       catch(...)
 355       {
 356         Glib::exception_handlers_invoke();
 357       }
 358       #endif //GLIBMM_EXCEPTIONS_ENABLED
 359     }
 360   }
 361
 362   BaseClassType *const base = static_cast<BaseClassType*>(
 363       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 364   );
 365
 366   // Call the original underlying C function:
 367   if(base && base->get_n_anchors)
 368     return (*base->get_n_anchors)(self);
 369
 370
 371   typedef gint RType;
 372   return RType();
 373 }
 374 guint Hyperlink_Class::link_state_vfunc_callback(AtkHyperlink* self)
 375 {
 376   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 377       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 378
 379   // Non-gtkmmproc-generated custom classes implicitly call the default
 380   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 381   // generated classes can use this optimisation, which avoids the unnecessary
 382   // parameter conversions if there is no possibility of the virtual function
 383   // being overridden:
 384   if(obj_base && obj_base->is_derived_())
 385   {
 386     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 387     if(obj) // This can be NULL during destruction.
 388     {
 389       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 390       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 391       {
 392       #endif //GLIBMM_EXCEPTIONS_ENABLED
 393         // Call the virtual member method, which derived classes might override.
 394         return obj->link_state_vfunc();
 395       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 396       }
 397       catch(...)
 398       {
 399         Glib::exception_handlers_invoke();
 400       }
 401       #endif //GLIBMM_EXCEPTIONS_ENABLED
 402     }
 403   }
 404
 405   BaseClassType *const base = static_cast<BaseClassType*>(
 406       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 407   );
 408
 409   // Call the original underlying C function:
 410   if(base && base->link_state)
 411     return (*base->link_state)(self);
 412
 413
 414   typedef guint RType;
 415   return RType();
 416 }
 417 gboolean Hyperlink_Class::is_selected_link_vfunc_callback(AtkHyperlink* self)
 418 {
 419   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 420       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 421
 422   // Non-gtkmmproc-generated custom classes implicitly call the default
 423   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 424   // generated classes can use this optimisation, which avoids the unnecessary
 425   // parameter conversions if there is no possibility of the virtual function
 426   // being overridden:
 427   if(obj_base && obj_base->is_derived_())
 428   {
 429     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 430     if(obj) // This can be NULL during destruction.
 431     {
 432       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 433       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 434       {
 435       #endif //GLIBMM_EXCEPTIONS_ENABLED
 436         // Call the virtual member method, which derived classes might override.
 437         return static_cast<int>(obj->is_selected_link_vfunc());
 438       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 439       }
 440       catch(...)
 441       {
 442         Glib::exception_handlers_invoke();
 443       }
 444       #endif //GLIBMM_EXCEPTIONS_ENABLED
 445     }
 446   }
 447
 448   BaseClassType *const base = static_cast<BaseClassType*>(
 449       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 450   );
 451
 452   // Call the original underlying C function:
 453   if(base && base->is_selected_link)
 454     return (*base->is_selected_link)(self);
 455
 456
 457   typedef gboolean RType;
 458   return RType();
 459 }
 460 #endif //GLIBMM_VFUNCS_ENABLED
 461
 462 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 463 void Hyperlink_Class::link_activated_callback(AtkHyperlink* self)
 464 {
 465   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 466       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 467
 468   // Non-gtkmmproc-generated custom classes implicitly call the default
 469   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 470   // generated classes can use this optimisation, which avoids the unnecessary
 471   // parameter conversions if there is no possibility of the virtual function
 472   // being overridden:
 473   if(obj_base && obj_base->is_derived_())
 474   {
 475     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 476     if(obj) // This can be NULL during destruction.
 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_link_activated();
 484         return;
 485       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 486       }
 487       catch(...)
 488       {
 489         Glib::exception_handlers_invoke();
 490       }
 491       #endif //GLIBMM_EXCEPTIONS_ENABLED
 492     }
 493   }
 494
 495   BaseClassType *const base = static_cast<BaseClassType*>(
 496         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 497     );
 498
 499   // Call the original underlying C function:
 500   if(base && base->link_activated)
 501     (*base->link_activated)(self);
 502 }
 503 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 504
 505
 506 Glib::ObjectBase* Hyperlink_Class::wrap_new(GObject* object)
 507 {
 508   return new Hyperlink((AtkHyperlink*)object);
 509 }
 510
 511
 512 /* The implementation: */
 513
 514 AtkHyperlink* Hyperlink::gobj_copy()
 515 {
 516   reference();
 517   return gobj();
 518 }
 519
 520 Hyperlink::Hyperlink(const Glib::ConstructParams& construct_params)
 521 :
 522   Glib::Object(construct_params)
 523 {}
 524
 525 Hyperlink::Hyperlink(AtkHyperlink* castitem)
 526 :
 527   Glib::Object((GObject*)(castitem))
 528 {}
 529
 530 Hyperlink::~Hyperlink()
 531 {}
 532
 533
 534 Hyperlink::CppClassType Hyperlink::hyperlink_class_; // initialize static member
 535
 536 GType Hyperlink::get_type()
 537 {
 538   return hyperlink_class_.init().get_type();
 539 }
 540
 541 GType Hyperlink::get_base_type()
 542 {
 543   return atk_hyperlink_get_type();
 544 }
 545
 546
 547 Glib::ustring Hyperlink::get_uri(int i) const
 548 {
 549   return Glib::convert_return_gchar_ptr_to_ustring(atk_hyperlink_get_uri(const_cast<AtkHyperlink*>(gobj()), i));
 550 }
 551
 552 Glib::RefPtr<Atk::Object> Hyperlink::get_object(int i)
 553 {
 554
 555   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_hyperlink_get_object(gobj(), i));
 556   if(retvalue)
 557     retvalue->reference(); //The function does not do a ref for us.
 558   return retvalue;
 559
 560 }
 561
 562 Glib::RefPtr<const Atk::Object> Hyperlink::get_object(int i) const
 563 {
 564   return const_cast<Hyperlink*>(this)->get_object(i);
 565 }
 566
 567 int Hyperlink::get_end_index() const
 568 {
 569   return atk_hyperlink_get_end_index(const_cast<AtkHyperlink*>(gobj()));
 570 }
 571
 572 int Hyperlink::get_start_index() const
 573 {
 574   return atk_hyperlink_get_start_index(const_cast<AtkHyperlink*>(gobj()));
 575 }
 576
 577 bool Hyperlink::is_valid() const
 578 {
 579   return atk_hyperlink_is_valid(const_cast<AtkHyperlink*>(gobj()));
 580 }
 581
 582 bool Hyperlink::is_inline() const
 583 {
 584   return atk_hyperlink_is_inline(const_cast<AtkHyperlink*>(gobj()));
 585 }
 586
 587 int Hyperlink::get_n_anchors() const
 588 {
 589   return atk_hyperlink_get_n_anchors(const_cast<AtkHyperlink*>(gobj()));
 590 }
 591
 592 bool Hyperlink::is_selected_link() const
 593 {
 594   return atk_hyperlink_is_selected_link(const_cast<AtkHyperlink*>(gobj()));
 595 }
 596
 597
 598 Glib::SignalProxy0< void > Hyperlink::signal_link_activated()
 599 {
 600   return Glib::SignalProxy0< void >(this, &Hyperlink_signal_link_activated_info);
 601 }
 602
 603
 604 #ifdef GLIBMM_PROPERTIES_ENABLED
 605 Glib::PropertyProxy_ReadOnly<bool> Hyperlink::property_selected_link() const
 606 {
 607   return Glib::PropertyProxy_ReadOnly<bool>(this, "selected-link");
 608 }
 609 #endif //GLIBMM_PROPERTIES_ENABLED
 610
 611 #ifdef GLIBMM_PROPERTIES_ENABLED
 612 Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_number_of_anchors() const
 613 {
 614   return Glib::PropertyProxy_ReadOnly<int>(this, "number-of-anchors");
 615 }
 616 #endif //GLIBMM_PROPERTIES_ENABLED
 617
 618 #ifdef GLIBMM_PROPERTIES_ENABLED
 619 Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_end_index() const
 620 {
 621   return Glib::PropertyProxy_ReadOnly<int>(this, "end-index");
 622 }
 623 #endif //GLIBMM_PROPERTIES_ENABLED
 624
 625 #ifdef GLIBMM_PROPERTIES_ENABLED
 626 Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_start_index() const
 627 {
 628   return Glib::PropertyProxy_ReadOnly<int>(this, "start-index");
 629 }
 630 #endif //GLIBMM_PROPERTIES_ENABLED
 631
 632
 633 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 634 void Atk::Hyperlink::on_link_activated()
 635 {
 636   BaseClassType *const base = static_cast<BaseClassType*>(
 637       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 638   );
 639
 640   if(base && base->link_activated)
 641     (*base->link_activated)(gobj());
 642 }
 643 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 644
 645 #ifdef GLIBMM_VFUNCS_ENABLED
 646 gchar* Atk::Hyperlink::get_uri_vfunc(int i) const
 647 {
 648   BaseClassType *const base = static_cast<BaseClassType*>(
 649       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 650   );
 651
 652   if(base && base->get_uri)
 653     return (*base->get_uri)(const_cast<AtkHyperlink*>(gobj()),i);
 654
 655   typedef gchar* RType;
 656   return RType();
 657 }
 658 Glib::RefPtr<Atk::Object> Atk::Hyperlink::get_object_vfunc(int i)
 659 {
 660   BaseClassType *const base = static_cast<BaseClassType*>(
 661       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 662   );
 663
 664   if(base && base->get_object)
 665     return Glib::wrap((*base->get_object)(gobj(),i));
 666
 667   typedef Glib::RefPtr<Atk::Object> RType;
 668   return RType();
 669 }
 670 int Atk::Hyperlink::get_end_index_vfunc() const
 671 {
 672   BaseClassType *const base = static_cast<BaseClassType*>(
 673       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 674   );
 675
 676   if(base && base->get_end_index)
 677     return (*base->get_end_index)(const_cast<AtkHyperlink*>(gobj()));
 678
 679   typedef int RType;
 680   return RType();
 681 }
 682 int Atk::Hyperlink::get_start_index_vfunc() const
 683 {
 684   BaseClassType *const base = static_cast<BaseClassType*>(
 685       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 686   );
 687
 688   if(base && base->get_start_index)
 689     return (*base->get_start_index)(const_cast<AtkHyperlink*>(gobj()));
 690
 691   typedef int RType;
 692   return RType();
 693 }
 694 bool Atk::Hyperlink::is_valid_vfunc() const
 695 {
 696   BaseClassType *const base = static_cast<BaseClassType*>(
 697       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 698   );
 699
 700   if(base && base->is_valid)
 701     return (*base->is_valid)(const_cast<AtkHyperlink*>(gobj()));
 702
 703   typedef bool RType;
 704   return RType();
 705 }
 706 int Atk::Hyperlink::get_n_anchors_vfunc() const
 707 {
 708   BaseClassType *const base = static_cast<BaseClassType*>(
 709       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 710   );
 711
 712   if(base && base->get_n_anchors)
 713     return (*base->get_n_anchors)(const_cast<AtkHyperlink*>(gobj()));
 714
 715   typedef int RType;
 716   return RType();
 717 }
 718 guint Atk::Hyperlink::link_state_vfunc() const
 719 {
 720   BaseClassType *const base = static_cast<BaseClassType*>(
 721       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 722   );
 723
 724   if(base && base->link_state)
 725     return (*base->link_state)(const_cast<AtkHyperlink*>(gobj()));
 726
 727   typedef guint RType;
 728   return RType();
 729 }
 730 bool Atk::Hyperlink::is_selected_link_vfunc() const
 731 {
 732   BaseClassType *const base = static_cast<BaseClassType*>(
 733       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 734   );
 735
 736   if(base && base->is_selected_link)
 737     return (*base->is_selected_link)(const_cast<AtkHyperlink*>(gobj()));
 738
 739   typedef bool RType;
 740   return RType();
 741 }
 742 #endif //GLIBMM_VFUNCS_ENABLED
 743
 744
 745 } // namespace Atk
 746
 747