libs/gtkmm2/gtk/gtkmm/widget.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/widget.h>
   5 #include <gtkmm/private/widget_p.h>
   6
   7 #include <gtk/gtktypebuiltins.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 <gtkmm/adjustment.h>
  29 #include <gtkmm/window.h>
  30 #include <gtkmm/accelgroup.h>
  31 #include <gtkmm/settings.h>
  32 #include <gtkmm/style.h>
  33 #include <gtkmm/container.h>
  34 #include <gtkmm/selectiondata_private.h>
  35 #include <gtkmm/action.h>
  36 #include <gtkmm/tooltip.h>
  37 #include <gtk/gtkdnd.h>
  38 #include <gtk/gtkselection.h>
  39 #include <gtk/gtkwidget.h>
  40 #include <gtk/gtkcontainer.h>
  41 #include <gtk/gtkmenu.h>
  42 #include <gtk/gtkmenuitem.h>
  43 #include <gtk/gtkmain.h>
  44 #include <gtk/gtkaction.h> //For gtk_widget_get_action().
  45
  46
  47 namespace //anonymous
  48 {
  49
  50 //These signal callbacks are custom implemented, so that we can create a temporary SelectionData instance.
  51 //To do this, we used the optional custom_c_callback paramater to _WRAP_SIGNAL() in the .hg file.
  52 static void Widget_signal_drag_data_get_callback(GtkWidget* self, GdkDragContext* p0,GtkSelectionData* p1,guint p2,guint p3,void* data)
  53 {
  54   using namespace Gtk;
  55   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > SlotType;
  56
  57   // Do not try to call a signal on a disassociated wrapper.
  58   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  59   {
  60     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  61     try
  62     {
  63     #endif //GLIBMM_EXCEPTIONS_ENABLED
  64       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  65       {
  66         SelectionData_WithoutOwnership temp_instance(p1);
  67         (*static_cast<SlotType*>(slot))( Glib::wrap(p0, true), temp_instance, p2, p3 );
  68       }
  69     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  70     }
  71     catch(...)
  72     {
  73       Glib::exception_handlers_invoke();
  74     }
  75     #endif //GLIBMM_EXCEPTIONS_ENABLED
  76   }
  77 }
  78
  79 static void Widget_signal_selection_get_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,guint p2,void* data)
  80 {
  81   using namespace Gtk;
  82   typedef sigc::slot< void, SelectionData&, guint, guint > SlotType;
  83
  84   // Do not try to call a signal on a disassociated wrapper.
  85   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  86   {
  87     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  88     try
  89     {
  90     #endif //GLIBMM_EXCEPTIONS_ENABLED
  91       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  92       {
  93         SelectionData_WithoutOwnership temp_instance(p0);
  94         (*static_cast<SlotType*>(slot))( temp_instance, p1, p2 );
  95       }
  96     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  97     }
  98     catch(...)
  99     {
 100       Glib::exception_handlers_invoke();
 101     }
 102     #endif //GLIBMM_EXCEPTIONS_ENABLED
 103   }
 104 }
 105
 106
 107 } //anonymous
 108
 109 namespace Gtk
 110 {
 111
 112 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 113 //These default handler callbacks are custom implemented, so that we can create a temporary SelectionData instance.
 114 //To do this, we used the optional custom_c_callback paramater to _WRAP_SIGNAL() in the .hg file.
 115 void Widget_Class::selection_get_callback(GtkWidget* self, GtkSelectionData* p0, guint p1, guint p2)
 116 {
 117   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 118       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 119
 120   // Non-gtkmmproc-generated custom classes implicitly call the default
 121   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 122   // generated classes can use this optimisation, which avoids the unnecessary
 123   // parameter conversions if there is no possibility of the virtual function
 124   // being overridden:
 125   if(obj && obj->is_derived_())
 126   {
 127     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 128     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 129     {
 130     #endif //GLIBMM_EXCEPTIONS_ENABLED
 131       // Call the virtual member method, which derived classes might override.
 132       SelectionData_WithoutOwnership temp_instance(p0);
 133       obj->on_selection_get(temp_instance, p1, p2);
 134     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 135     }
 136     catch(...)
 137     {
 138       Glib::exception_handlers_invoke();
 139     }
 140     #endif //GLIBMM_EXCEPTIONS_ENABLED
 141   }
 142   else
 143   {
 144     BaseClassType *const base = static_cast<BaseClassType*>(
 145         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 146     );
 147
 148     // Call the original underlying C function:
 149     if(base && base->selection_get)
 150       (*base->selection_get)(self, p0, p1, p2);
 151   }
 152 }
 153
 154 void Widget_Class::drag_data_get_callback(GtkWidget* self, GdkDragContext* p0, GtkSelectionData* p1, guint p2, guint p3)
 155 {
 156   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 157       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 158
 159   // Non-gtkmmproc-generated custom classes implicitly call the default
 160   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 161   // generated classes can use this optimisation, which avoids the unnecessary
 162   // parameter conversions if there is no possibility of the virtual function
 163   // being overridden:
 164   if(obj && obj->is_derived_())
 165   {
 166     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 167     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 168     {
 169     #endif //GLIBMM_EXCEPTIONS_ENABLED
 170       // Call the virtual member method, which derived classes might override.
 171       SelectionData_WithoutOwnership temp_instance(p1);
 172       obj->on_drag_data_get(Glib::wrap(p0, true), temp_instance, p2, p3);
 173     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 174     }
 175     catch(...)
 176     {
 177       Glib::exception_handlers_invoke();
 178     }
 179     #endif //GLIBMM_EXCEPTIONS_ENABLED
 180   }
 181   else
 182   {
 183     BaseClassType *const base = static_cast<BaseClassType*>(
 184         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 185     );
 186
 187     // Call the original underlying C function:
 188     if(base && base->drag_data_get)
 189       (*base->drag_data_get)(self, p0, p1, p2, p3);
 190   }
 191 }
 192 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 193
 194 Widget::~Widget()
 195 {}
 196
 197 bool Widget::intersect(const Gdk::Rectangle& area) const
 198 {
 199   return gtk_widget_intersect(
 200       const_cast<GtkWidget*>(gobj()), const_cast<GdkRectangle*>(area.gobj()), 0);
 201 }
 202
 203 void Widget::unset_name()
 204 {
 205   gtk_widget_set_name(gobj(), 0);
 206 }
 207
 208 void Widget::unset_composite_name()
 209 {
 210   gtk_widget_set_composite_name(gobj(), 0);
 211 }
 212
 213 void Widget::realize_if_needed()
 214 {
 215   if(!is_realized())
 216     realize();
 217 }
 218
 219 void Widget::add_modal_grab()
 220 {
 221   gtk_grab_add(gobj());
 222 }
 223
 224 void Widget::remove_modal_grab()
 225 {
 226   gtk_grab_remove(gobj());
 227 }
 228
 229 Widget* Widget::get_current_modal_grab()
 230 {
 231   return Glib::wrap(gtk_grab_get_current());
 232 }
 233
 234 void Widget::path(Glib::ustring& path_arg, Glib::ustring& path_reversed)
 235 {
 236   guint path_length = 0;
 237   Glib::ScopedPtr<gchar> path_ptr;
 238   Glib::ScopedPtr<gchar> rpath_ptr;
 239
 240   gtk_widget_path(gobj(), &path_length, path_ptr.addr(), rpath_ptr.addr());
 241
 242   path_arg.assign(path_ptr.get(), path_ptr.get() + path_length);
 243   path_reversed.assign(rpath_ptr.get(), rpath_ptr.get() + path_length);
 244 }
 245
 246 void Widget::class_path(Glib::ustring& path_arg, Glib::ustring& path_reversed)
 247 {
 248   guint path_length = 0;
 249   Glib::ScopedPtr<gchar> path_ptr;
 250   Glib::ScopedPtr<gchar> rpath_ptr;
 251
 252   gtk_widget_class_path(gobj(), &path_length, path_ptr.addr(), rpath_ptr.addr());
 253
 254   path_arg.assign(path_ptr.get(), path_ptr.get() + path_length);
 255   path_reversed.assign(rpath_ptr.get(), rpath_ptr.get() + path_length);
 256 }
 257
 258 void Widget::modify_bg_pixmap(StateType state, const Glib::ustring& pixmap_name)
 259 {
 260   const Glib::RefPtr<RcStyle> modifier_style = get_modifier_style();
 261   modifier_style->set_bg_pixmap_name(state, pixmap_name);
 262   modify_style(modifier_style);
 263 }
 264
 265 void Widget::unset_fg(StateType state)
 266 {
 267   gtk_widget_modify_fg(gobj(), static_cast<GtkStateType>(int(state)), 0);
 268 }
 269
 270 void Widget::unset_bg(StateType state)
 271 {
 272   gtk_widget_modify_bg(gobj(), static_cast<GtkStateType>(int(state)), 0);
 273 }
 274
 275 void Widget::unset_text(StateType state)
 276 {
 277   gtk_widget_modify_text(gobj(), static_cast<GtkStateType>(int(state)), 0);
 278 }
 279
 280 void Widget::unset_base(StateType state)
 281 {
 282   gtk_widget_modify_base(gobj(), static_cast<GtkStateType>(int(state)), 0);
 283 }
 284
 285 void Widget::unset_font()
 286 {
 287   gtk_widget_modify_font(gobj(), 0);
 288 }
 289
 290 void Widget::unset_cursor()
 291 {
 292   gtk_widget_modify_cursor(gobj(), 0, 0);
 293 }
 294
 295 bool Widget::is_toplevel() const
 296   { return GTK_WIDGET_TOPLEVEL(gobj()); }
 297
 298 bool Widget::has_no_window() const
 299   { return GTK_WIDGET_NO_WINDOW(gobj()); }
 300
 301 bool Widget::is_realized() const
 302   { return GTK_WIDGET_REALIZED(gobj()); }
 303
 304 bool Widget::is_mapped() const
 305   { return GTK_WIDGET_MAPPED(gobj()); }
 306
 307 bool Widget::is_visible() const
 308   { return GTK_WIDGET_VISIBLE(gobj()); }
 309
 310 bool Widget::is_drawable() const
 311   { return GTK_WIDGET_DRAWABLE(gobj()); }
 312
 313 bool Widget::sensitive() const
 314   { return GTK_WIDGET_SENSITIVE(gobj()); }
 315
 316 bool Widget::parent_sensitive() const
 317   { return GTK_WIDGET_PARENT_SENSITIVE(gobj()); }
 318
 319 bool Widget::is_sensitive() const
 320   { return GTK_WIDGET_IS_SENSITIVE(gobj()); }
 321
 322 bool Widget::can_focus() const
 323   { return GTK_WIDGET_CAN_FOCUS(gobj()); }
 324
 325 bool Widget::has_focus() const
 326   { return GTK_WIDGET_HAS_FOCUS(gobj()); }
 327
 328 bool Widget::can_default() const
 329   { return GTK_WIDGET_CAN_DEFAULT(gobj()); }
 330
 331 bool Widget::has_default() const
 332   { return GTK_WIDGET_HAS_DEFAULT(gobj()); }
 333
 334 bool Widget::has_grab() const
 335   { return GTK_WIDGET_HAS_GRAB(gobj()); }
 336
 337 bool Widget::rc_style() const
 338   { return GTK_WIDGET_RC_STYLE(gobj()); }
 339
 340 bool Widget::is_composite_child() const
 341   { return GTK_WIDGET_COMPOSITE_CHILD(gobj()); }
 342
 343 bool Widget::app_paintable() const
 344   { return GTK_WIDGET_APP_PAINTABLE(gobj()); }
 345
 346 bool Widget::receives_default() const
 347   { return GTK_WIDGET_RECEIVES_DEFAULT(gobj()); }
 348
 349 bool Widget::double_buffered() const
 350   { return GTK_WIDGET_DOUBLE_BUFFERED(gobj()); }
 351
 352 WidgetFlags Widget::get_flags() const
 353   { return static_cast<WidgetFlags>(GTK_WIDGET_FLAGS(gobj())); }
 354
 355 void Widget::set_flags(WidgetFlags flags)
 356   { GTK_WIDGET_SET_FLAGS(gobj(), static_cast<guint32>(flags)); }
 357
 358 void Widget::unset_flags(WidgetFlags flags)
 359   { GTK_WIDGET_UNSET_FLAGS(gobj(), static_cast<guint32>(flags)); }
 360
 361 int Widget::get_width() const
 362   { return gobj()->allocation.width; }
 363
 364 int Widget::get_height() const
 365   { return gobj()->allocation.height; }
 366
 367
 368 void Widget::drag_dest_set(DestDefaults flags, Gdk::DragAction actions)
 369 {
 370   gtk_drag_dest_set(gobj(), (GtkDestDefaults)flags, 0, 0, (GdkDragAction)actions);
 371 }
 372
 373 void Widget::drag_dest_set(const ArrayHandle_TargetEntry& targets,
 374                            DestDefaults flags, Gdk::DragAction actions)
 375 {
 376   // I've used Gdk::ACTION_COPY as the default, because Gdk::ACTION_DEFAULT means that
 377   // it's never a drag destination, so it would seem like this method didn't work. murrayc.
 378   gtk_drag_dest_set(
 379       gobj(), (GtkDestDefaults)flags,
 380       targets.data(), targets.size(), (GdkDragAction)actions);
 381 }
 382
 383 void Widget::drag_source_set(const ArrayHandle_TargetEntry& targets,
 384                              Gdk::ModifierType start_button_mask, Gdk::DragAction actions)
 385 {
 386   // I've used Gdk::MODIFIER_MASK as the default, because it seems
 387   // to mean 'whatever is possible in the context'. murrayc.
 388   gtk_drag_source_set(
 389       gobj(), (GdkModifierType)start_button_mask,
 390       targets.data(), targets.size(), (GdkDragAction)actions);
 391 }
 392
 393 Widget* Widget::drag_get_source_widget(const Glib::RefPtr<Gdk::DragContext>& context) //static
 394 {
 395   return Glib::wrap( gtk_drag_get_source_widget(Glib::unwrap(context)) );
 396 }
 397
 398 void Widget::drag_set_as_icon(const Glib::RefPtr<Gdk::DragContext>& context, int hot_x, int hot_y)
 399 {
 400   gtk_drag_set_icon_widget(Glib::unwrap(context), gobj(), hot_x, hot_y);
 401 }
 402
 403 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 404 void Widget_Class::hierarchy_changed_callback_custom(GtkWidget* self, GtkWidget* p0)
 405 {
 406   //GTKMM_LIFECYCLE
 407   //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
 408   bool gtkmm_child_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
 409
 410   if(!gtkmm_child_already_deleted)
 411   {
 412     //Call the regular, generated callback:
 413     Widget_Class::hierarchy_changed_callback(self, p0);
 414   }
 415   else
 416   {
 417     BaseClassType *const base = static_cast<BaseClassType*>(
 418         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 419     );
 420
 421     //Call the original underlying C function:
 422     if(base && base->hierarchy_changed)
 423       (*base->hierarchy_changed)(self, p0);
 424   }
 425 }
 426
 427 void Widget_Class::parent_set_callback_custom(GtkWidget* self, GtkWidget* p0)
 428 {
 429   //GTKMM_LIFECYCLE
 430   //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
 431   bool gtkmm_p0_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
 432
 433   if(!gtkmm_p0_already_deleted)
 434   {
 435     //Call the regular, generated callback:
 436     Widget_Class::parent_set_callback(self, p0);
 437   }
 438   else
 439   {
 440     BaseClassType *const base = static_cast<BaseClassType*>(
 441         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 442     );
 443
 444     //Call the original underlying C function:
 445     if(base && base->parent_set)
 446       (*base->parent_set)(self, p0);
 447   }
 448 }
 449 #endif //#GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 450
 451 void Widget_Class::dispose_vfunc_callback(GObject* self)
 452 {
 453   //Avoid disposal. See also Window_Class::dispose_vfunc_callback().
 454
 455   #ifdef GLIBMM_DEBUG_REFCOUNTING
 456   g_warning("Widget_Class::dispose_vfunc_callback(): gobject_: %p\n", (void*)self);
 457   //if(self)
 458    //g_warning("  gtypename: %s\n", G_OBJECT_TYPE_NAME(self));
 459   #endif
 460
 461   Widget *const obj = dynamic_cast<Widget*>(
 462       Glib::ObjectBase::_get_current_wrapper(self));
 463
 464   // This function might be invoked recursively because we're triggering
 465   // several signal emissions, particularly signal_hide().  Therefore we
 466   // have to test for cpp_destruction_in_progress_ at this point.
 467
 468   if(obj && !obj->_cpp_destruction_is_in_progress()) //When it should really be destroyed, we zero gobj_.
 469   {
 470     GtkWidget *const pWidget = obj->gobj();
 471     g_return_if_fail(pWidget == GTK_WIDGET(self));
 472
 473     // Abort dispose if the widget isn't managed, in order to prevent
 474     // the nasty self-destroying behaviour of GTK+.  This applies to
 475     // any widget inside a GtkContainer on gtk_container_destroy()
 476     // See also Window_Class::dispose_vfunc_callback().
 477
 478     if(obj->referenced_) //Not managed
 479     {
 480       // GTKMM_LIFECYCLE
 481       // Remove the widget from its parent container so that it
 482       // won't be destroyed later by gtk_container_destroy().
 483       if(pWidget->parent)
 484       {
 485         // Normally, we would have to ref the child widget because
 486         // gtk_container_remove() unrefs it.  But since we only remove
 487         // non-managed objects here, the container just releases the
 488         // reference it has acquired before in gtk_container_add().
 489
 490         #ifdef GLIBMM_DEBUG_REFCOUNTING
 491         g_warning("Widget_Class::dispose_vfunc_callback(): removing gobject_: %p from parent: %p", (void*)self, (void*)pWidget->parent);
 492         #endif
 493
 494         gtk_container_remove(GTK_CONTAINER(pWidget->parent), pWidget);
 495
 496         #ifdef GLIBMM_DEBUG_REFCOUNTING
 497         g_warning("Widget_Class::dispose_vfunc_callback(): after removing from parent.");
 498         #endif
 499       }
 500       // Special case for GtkMenu because gtk_menu_attach_to_widget does
 501       // not set widget->parent but gtk_menu_item_destroy() destroys the menu
 502       // like gtk_container_destroy()
 503       // Gtk::Menu does not use a parent widget because it must
 504       // be contained in its Gtk::Window so that it can be displayed as a popup.
 505       else if (GTK_IS_MENU(pWidget) && GTK_IS_MENU_ITEM(gtk_menu_get_attach_widget(GTK_MENU(pWidget))))
 506       {
 507          gtk_menu_detach(GTK_MENU(pWidget));
 508       }
 509
 510       #ifdef GLIBMM_DEBUG_REFCOUNTING
 511       g_warning("Widget_Class::dispose_vfunc_callback(): before gtk_widget_hide().");
 512       #endif
 513
 514       // Now hide the widget.  The C++ object must _not_ be accessed anymore
 515       // after this call, because a signal_hide() handler might delete it.
 516       gtk_widget_hide(pWidget);
 517
 518       #ifdef GLIBMM_DEBUG_REFCOUNTING
 519       g_warning("Widget_Class::dispose_vfunc_callback(): after gtk_widget_hide().");
 520       #endif
 521
 522       // GTKMM_LIFECYCLE
 523       return; // Prevent calling of normal C dispose vfunc (see below)
 524     }
 525
 526     #ifdef GLIBMM_DEBUG_REFCOUNTING
 527     g_warning("Widget_Class::dispose_vfunc_callback(): unreferenced: before gtk_widget_hide().");
 528     #endif
 529
 530     // Always hide widgets on gtk_object_destroy(), regardless of whether
 531     // the widget is managed or not.  This is done for consistency so that
 532     // connecting to signal_hide() is guaranteed to work.
 533     gtk_widget_hide(pWidget);
 534
 535     #ifdef GLIBMM_DEBUG_REFCOUNTING
 536     g_warning("Widget_Class::dispose_vfunc_callback(): unreferenced:  after gtk_widget_hide().");
 537     #endif
 538   }
 539
 540   GObjectClass *const base = static_cast<GObjectClass*>(
 541       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)));
 542
 543   #ifdef GLIBMM_DEBUG_REFCOUNTING
 544   g_warning("Widget_Class::dispose_vfunc_callback(): before calling base->dispose.");
 545   #endif
 546
 547   if(base->dispose)
 548     (*base->dispose)(self);
 549
 550   #ifdef GLIBMM_DEBUG_REFCOUNTING
 551   g_warning("Widget_Class::dispose_vfunc_callback(): after calling base->dispose.");
 552   #endif
 553 }
 554
 555
 556 void Widget::unset_style()
 557 {
 558   gtk_widget_set_style(gobj(), 0 /* See GTK+ docs */);
 559 }
 560
 561 Glib::ustring Widget::drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context) const
 562 {
 563   return Gdk::AtomString::to_cpp_type(gtk_drag_dest_find_target(const_cast<GtkWidget*>(gobj()), Glib::unwrap(context), 0 /* See GTK+ docs */));
 564 }
 565
 566 void Widget::unset_shape_combine_mask()
 567 {
 568   gtk_widget_shape_combine_mask(gobj(), 0, 0, 0); /* See GTK+ docs */
 569 }
 570
 571 void Widget::unset_input_shape_combine_mask()
 572 {
 573   gtk_widget_input_shape_combine_mask(gobj(), 0, 0, 0); /* See GTK+ docs */
 574 }
 575
 576 void Widget::draw_insertion_cursor(Glib::RefPtr<Gdk::Drawable> drawable, const Gdk::Rectangle& area, const Gdk::Rectangle& location, bool is_primary, TextDirection direction, bool draw_arrow)
 577 {
 578   gtk_draw_insertion_cursor(gobj(), drawable->gobj(), const_cast<GdkRectangle*>(area.gobj()), const_cast<GdkRectangle*>(location.gobj()), is_primary, (GtkTextDirection)direction, draw_arrow);
 579 }
 580
 581 Requisition Widget::size_request() const
 582 {
 583   Requisition requisition;
 584   gtk_widget_size_request(const_cast<GtkWidget*>(gobj()), (GtkRequisition*)(&requisition));
 585   return requisition;
 586 }
 587
 588
 589 } // namespace Gtk
 590
 591
 592 namespace
 593 {
 594
 595
 596 static const Glib::SignalProxyInfo Widget_signal_show_info =
 597 {
 598   "show",
 599   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 600   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 601 };
 602
 603
 604 static const Glib::SignalProxyInfo Widget_signal_hide_info =
 605 {
 606   "hide",
 607   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 608   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 609 };
 610
 611
 612 static const Glib::SignalProxyInfo Widget_signal_map_info =
 613 {
 614   "map",
 615   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 616   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 617 };
 618
 619
 620 static const Glib::SignalProxyInfo Widget_signal_unmap_info =
 621 {
 622   "unmap",
 623   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 624   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 625 };
 626
 627
 628 static const Glib::SignalProxyInfo Widget_signal_realize_info =
 629 {
 630   "realize",
 631   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 632   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 633 };
 634
 635
 636 static const Glib::SignalProxyInfo Widget_signal_unrealize_info =
 637 {
 638   "unrealize",
 639   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 640   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 641 };
 642
 643
 644 static void Widget_signal_size_request_callback(GtkWidget* self, GtkRequisition* p0,void* data)
 645 {
 646   using namespace Gtk;
 647   typedef sigc::slot< void,Requisition* > SlotType;
 648
 649   // Do not try to call a signal on a disassociated wrapper.
 650   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 651   {
 652     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 653     try
 654     {
 655     #endif //GLIBMM_EXCEPTIONS_ENABLED
 656       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 657         (*static_cast<SlotType*>(slot))((Requisition*)(p0)
 658 );
 659     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 660     }
 661     catch(...)
 662     {
 663       Glib::exception_handlers_invoke();
 664     }
 665     #endif //GLIBMM_EXCEPTIONS_ENABLED
 666   }
 667 }
 668
 669 static const Glib::SignalProxyInfo Widget_signal_size_request_info =
 670 {
 671   "size_request",
 672   (GCallback) &Widget_signal_size_request_callback,
 673   (GCallback) &Widget_signal_size_request_callback
 674 };
 675
 676
 677 static void Widget_signal_size_allocate_callback(GtkWidget* self, GtkAllocation* p0,void* data)
 678 {
 679   using namespace Gtk;
 680   typedef sigc::slot< void,Allocation& > SlotType;
 681
 682   // Do not try to call a signal on a disassociated wrapper.
 683   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 684   {
 685     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 686     try
 687     {
 688     #endif //GLIBMM_EXCEPTIONS_ENABLED
 689       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 690         (*static_cast<SlotType*>(slot))((Allocation&)(Glib::wrap(p0))
 691 );
 692     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 693     }
 694     catch(...)
 695     {
 696       Glib::exception_handlers_invoke();
 697     }
 698     #endif //GLIBMM_EXCEPTIONS_ENABLED
 699   }
 700 }
 701
 702 static const Glib::SignalProxyInfo Widget_signal_size_allocate_info =
 703 {
 704   "size_allocate",
 705   (GCallback) &Widget_signal_size_allocate_callback,
 706   (GCallback) &Widget_signal_size_allocate_callback
 707 };
 708
 709
 710 static void Widget_signal_state_changed_callback(GtkWidget* self, GtkStateType p0,void* data)
 711 {
 712   using namespace Gtk;
 713   typedef sigc::slot< void,Gtk::StateType > SlotType;
 714
 715   // Do not try to call a signal on a disassociated wrapper.
 716   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 717   {
 718     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 719     try
 720     {
 721     #endif //GLIBMM_EXCEPTIONS_ENABLED
 722       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 723         (*static_cast<SlotType*>(slot))(((Gtk::StateType)(p0))
 724 );
 725     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 726     }
 727     catch(...)
 728     {
 729       Glib::exception_handlers_invoke();
 730     }
 731     #endif //GLIBMM_EXCEPTIONS_ENABLED
 732   }
 733 }
 734
 735 static const Glib::SignalProxyInfo Widget_signal_state_changed_info =
 736 {
 737   "state_changed",
 738   (GCallback) &Widget_signal_state_changed_callback,
 739   (GCallback) &Widget_signal_state_changed_callback
 740 };
 741
 742
 743 static void Widget_signal_parent_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
 744 {
 745   using namespace Gtk;
 746   typedef sigc::slot< void,Widget* > SlotType;
 747
 748   // Do not try to call a signal on a disassociated wrapper.
 749   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 750   {
 751     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 752     try
 753     {
 754     #endif //GLIBMM_EXCEPTIONS_ENABLED
 755       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 756         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 757 );
 758     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 759     }
 760     catch(...)
 761     {
 762       Glib::exception_handlers_invoke();
 763     }
 764     #endif //GLIBMM_EXCEPTIONS_ENABLED
 765   }
 766 }
 767
 768 static const Glib::SignalProxyInfo Widget_signal_parent_changed_info =
 769 {
 770   "parent_set",
 771   (GCallback) &Widget_signal_parent_changed_callback,
 772   (GCallback) &Widget_signal_parent_changed_callback
 773 };
 774
 775
 776 static void Widget_signal_hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
 777 {
 778   using namespace Gtk;
 779   typedef sigc::slot< void,Widget* > SlotType;
 780
 781   // Do not try to call a signal on a disassociated wrapper.
 782   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 783   {
 784     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 785     try
 786     {
 787     #endif //GLIBMM_EXCEPTIONS_ENABLED
 788       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 789         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 790 );
 791     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 792     }
 793     catch(...)
 794     {
 795       Glib::exception_handlers_invoke();
 796     }
 797     #endif //GLIBMM_EXCEPTIONS_ENABLED
 798   }
 799 }
 800
 801 static const Glib::SignalProxyInfo Widget_signal_hierarchy_changed_info =
 802 {
 803   "hierarchy_changed",
 804   (GCallback) &Widget_signal_hierarchy_changed_callback,
 805   (GCallback) &Widget_signal_hierarchy_changed_callback
 806 };
 807
 808
 809 static void Widget_signal_style_changed_callback(GtkWidget* self, GtkStyle* p0,void* data)
 810 {
 811   using namespace Gtk;
 812   typedef sigc::slot< void,const Glib::RefPtr<Gtk::Style>& > SlotType;
 813
 814   // Do not try to call a signal on a disassociated wrapper.
 815   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 816   {
 817     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 818     try
 819     {
 820     #endif //GLIBMM_EXCEPTIONS_ENABLED
 821       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 822         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 823 );
 824     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 825     }
 826     catch(...)
 827     {
 828       Glib::exception_handlers_invoke();
 829     }
 830     #endif //GLIBMM_EXCEPTIONS_ENABLED
 831   }
 832 }
 833
 834 static const Glib::SignalProxyInfo Widget_signal_style_changed_info =
 835 {
 836   "style_set",
 837   (GCallback) &Widget_signal_style_changed_callback,
 838   (GCallback) &Widget_signal_style_changed_callback
 839 };
 840
 841
 842 static void Widget_signal_direction_changed_callback(GtkWidget* self, GtkTextDirection p0,void* data)
 843 {
 844   using namespace Gtk;
 845   typedef sigc::slot< void,TextDirection > SlotType;
 846
 847   // Do not try to call a signal on a disassociated wrapper.
 848   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 849   {
 850     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 851     try
 852     {
 853     #endif //GLIBMM_EXCEPTIONS_ENABLED
 854       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 855         (*static_cast<SlotType*>(slot))(((TextDirection)(p0))
 856 );
 857     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 858     }
 859     catch(...)
 860     {
 861       Glib::exception_handlers_invoke();
 862     }
 863     #endif //GLIBMM_EXCEPTIONS_ENABLED
 864   }
 865 }
 866
 867 static const Glib::SignalProxyInfo Widget_signal_direction_changed_info =
 868 {
 869   "direction_changed",
 870   (GCallback) &Widget_signal_direction_changed_callback,
 871   (GCallback) &Widget_signal_direction_changed_callback
 872 };
 873
 874
 875 static void Widget_signal_grab_notify_callback(GtkWidget* self, gboolean p0,void* data)
 876 {
 877   using namespace Gtk;
 878   typedef sigc::slot< void,bool > SlotType;
 879
 880   // Do not try to call a signal on a disassociated wrapper.
 881   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 882   {
 883     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 884     try
 885     {
 886     #endif //GLIBMM_EXCEPTIONS_ENABLED
 887       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 888         (*static_cast<SlotType*>(slot))(p0
 889 );
 890     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 891     }
 892     catch(...)
 893     {
 894       Glib::exception_handlers_invoke();
 895     }
 896     #endif //GLIBMM_EXCEPTIONS_ENABLED
 897   }
 898 }
 899
 900 static const Glib::SignalProxyInfo Widget_signal_grab_notify_info =
 901 {
 902   "grab_notify",
 903   (GCallback) &Widget_signal_grab_notify_callback,
 904   (GCallback) &Widget_signal_grab_notify_callback
 905 };
 906
 907
 908 static void Widget_signal_child_notify_callback(GtkWidget* self, GParamSpec* p0,void* data)
 909 {
 910   using namespace Gtk;
 911   typedef sigc::slot< void,GParamSpec* > SlotType;
 912
 913   // Do not try to call a signal on a disassociated wrapper.
 914   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 915   {
 916     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 917     try
 918     {
 919     #endif //GLIBMM_EXCEPTIONS_ENABLED
 920       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 921         (*static_cast<SlotType*>(slot))(p0);
 922     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 923     }
 924     catch(...)
 925     {
 926       Glib::exception_handlers_invoke();
 927     }
 928     #endif //GLIBMM_EXCEPTIONS_ENABLED
 929   }
 930 }
 931
 932 static const Glib::SignalProxyInfo Widget_signal_child_notify_info =
 933 {
 934   "child_notify",
 935   (GCallback) &Widget_signal_child_notify_callback,
 936   (GCallback) &Widget_signal_child_notify_callback
 937 };
 938
 939
 940 static gboolean Widget_signal_mnemonic_activate_callback(GtkWidget* self, gboolean p0,void* data)
 941 {
 942   using namespace Gtk;
 943   typedef sigc::slot< bool,bool > SlotType;
 944
 945   // Do not try to call a signal on a disassociated wrapper.
 946   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 947   {
 948     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 949     try
 950     {
 951     #endif //GLIBMM_EXCEPTIONS_ENABLED
 952       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 953         return static_cast<int>((*static_cast<SlotType*>(slot))(p0
 954 ));
 955     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 956     }
 957     catch(...)
 958     {
 959       Glib::exception_handlers_invoke();
 960     }
 961     #endif //GLIBMM_EXCEPTIONS_ENABLED
 962   }
 963
 964   typedef gboolean RType;
 965   return RType();
 966 }
 967
 968 static gboolean Widget_signal_mnemonic_activate_notify_callback(GtkWidget* self, gboolean p0, void* data)
 969 {
 970   using namespace Gtk;
 971   typedef sigc::slot< void,bool > SlotType;
 972
 973   // Do not try to call a signal on a disassociated wrapper.
 974   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 975   {
 976     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 977     try
 978     {
 979     #endif //GLIBMM_EXCEPTIONS_ENABLED
 980       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 981         (*static_cast<SlotType*>(slot))(p0
 982 );
 983     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 984     }
 985     catch(...)
 986     {
 987       Glib::exception_handlers_invoke();
 988     }
 989     #endif //GLIBMM_EXCEPTIONS_ENABLED
 990   }
 991
 992   typedef gboolean RType;
 993   return RType();
 994 }
 995
 996 static const Glib::SignalProxyInfo Widget_signal_mnemonic_activate_info =
 997 {
 998   "mnemonic_activate",
 999   (GCallback) &Widget_signal_mnemonic_activate_callback,
1000   (GCallback) &Widget_signal_mnemonic_activate_notify_callback
1001 };
1002
1003
1004 static const Glib::SignalProxyInfo Widget_signal_grab_focus_info =
1005 {
1006   "grab_focus",
1007   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
1008   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
1009 };
1010
1011
1012 static gboolean Widget_signal_focus_callback(GtkWidget* self, GtkDirectionType p0,void* data)
1013 {
1014   using namespace Gtk;
1015   typedef sigc::slot< bool,DirectionType > SlotType;
1016
1017   // Do not try to call a signal on a disassociated wrapper.
1018   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1019   {
1020     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1021     try
1022     {
1023     #endif //GLIBMM_EXCEPTIONS_ENABLED
1024       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1025         return static_cast<int>((*static_cast<SlotType*>(slot))(((DirectionType)(p0))
1026 ));
1027     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1028     }
1029     catch(...)
1030     {
1031       Glib::exception_handlers_invoke();
1032     }
1033     #endif //GLIBMM_EXCEPTIONS_ENABLED
1034   }
1035
1036   typedef gboolean RType;
1037   return RType();
1038 }
1039
1040 static gboolean Widget_signal_focus_notify_callback(GtkWidget* self, GtkDirectionType p0, void* data)
1041 {
1042   using namespace Gtk;
1043   typedef sigc::slot< void,DirectionType > SlotType;
1044
1045   // Do not try to call a signal on a disassociated wrapper.
1046   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1047   {
1048     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1049     try
1050     {
1051     #endif //GLIBMM_EXCEPTIONS_ENABLED
1052       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1053         (*static_cast<SlotType*>(slot))(((DirectionType)(p0))
1054 );
1055     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1056     }
1057     catch(...)
1058     {
1059       Glib::exception_handlers_invoke();
1060     }
1061     #endif //GLIBMM_EXCEPTIONS_ENABLED
1062   }
1063
1064   typedef gboolean RType;
1065   return RType();
1066 }
1067
1068 static const Glib::SignalProxyInfo Widget_signal_focus_info =
1069 {
1070   "focus",
1071   (GCallback) &Widget_signal_focus_callback,
1072   (GCallback) &Widget_signal_focus_notify_callback
1073 };
1074
1075
1076 static gboolean Widget_signal_event_callback(GtkWidget* self, GdkEvent* p0,void* data)
1077 {
1078   using namespace Gtk;
1079   typedef sigc::slot< bool,GdkEvent* > SlotType;
1080
1081   // Do not try to call a signal on a disassociated wrapper.
1082   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1083   {
1084     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1085     try
1086     {
1087     #endif //GLIBMM_EXCEPTIONS_ENABLED
1088       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1089         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1090     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1091     }
1092     catch(...)
1093     {
1094       Glib::exception_handlers_invoke();
1095     }
1096     #endif //GLIBMM_EXCEPTIONS_ENABLED
1097   }
1098
1099   typedef gboolean RType;
1100   return RType();
1101 }
1102
1103 static gboolean Widget_signal_event_notify_callback(GtkWidget* self, GdkEvent* p0, void* data)
1104 {
1105   using namespace Gtk;
1106   typedef sigc::slot< void,GdkEvent* > SlotType;
1107
1108   // Do not try to call a signal on a disassociated wrapper.
1109   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1110   {
1111     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1112     try
1113     {
1114     #endif //GLIBMM_EXCEPTIONS_ENABLED
1115       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1116         (*static_cast<SlotType*>(slot))(p0);
1117     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1118     }
1119     catch(...)
1120     {
1121       Glib::exception_handlers_invoke();
1122     }
1123     #endif //GLIBMM_EXCEPTIONS_ENABLED
1124   }
1125
1126   typedef gboolean RType;
1127   return RType();
1128 }
1129
1130 static const Glib::SignalProxyInfo Widget_signal_event_info =
1131 {
1132   "event",
1133   (GCallback) &Widget_signal_event_callback,
1134   (GCallback) &Widget_signal_event_notify_callback
1135 };
1136
1137
1138 static void Widget_signal_event_after_callback(GtkWidget* self, GdkEvent* p0,void* data)
1139 {
1140   using namespace Gtk;
1141   typedef sigc::slot< void,GdkEvent* > SlotType;
1142
1143   // Do not try to call a signal on a disassociated wrapper.
1144   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1145   {
1146     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1147     try
1148     {
1149     #endif //GLIBMM_EXCEPTIONS_ENABLED
1150       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1151         (*static_cast<SlotType*>(slot))(p0);
1152     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1153     }
1154     catch(...)
1155     {
1156       Glib::exception_handlers_invoke();
1157     }
1158     #endif //GLIBMM_EXCEPTIONS_ENABLED
1159   }
1160 }
1161
1162 static const Glib::SignalProxyInfo Widget_signal_event_after_info =
1163 {
1164   "event_after",
1165   (GCallback) &Widget_signal_event_after_callback,
1166   (GCallback) &Widget_signal_event_after_callback
1167 };
1168
1169
1170 static gboolean Widget_signal_button_press_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
1171 {
1172   using namespace Gtk;
1173   typedef sigc::slot< bool,GdkEventButton* > SlotType;
1174
1175   // Do not try to call a signal on a disassociated wrapper.
1176   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1177   {
1178     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1179     try
1180     {
1181     #endif //GLIBMM_EXCEPTIONS_ENABLED
1182       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1183         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1184     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1185     }
1186     catch(...)
1187     {
1188       Glib::exception_handlers_invoke();
1189     }
1190     #endif //GLIBMM_EXCEPTIONS_ENABLED
1191   }
1192
1193   typedef gboolean RType;
1194   return RType();
1195 }
1196
1197 static gboolean Widget_signal_button_press_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
1198 {
1199   using namespace Gtk;
1200   typedef sigc::slot< void,GdkEventButton* > SlotType;
1201
1202   // Do not try to call a signal on a disassociated wrapper.
1203   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1204   {
1205     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1206     try
1207     {
1208     #endif //GLIBMM_EXCEPTIONS_ENABLED
1209       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1210         (*static_cast<SlotType*>(slot))(p0);
1211     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1212     }
1213     catch(...)
1214     {
1215       Glib::exception_handlers_invoke();
1216     }
1217     #endif //GLIBMM_EXCEPTIONS_ENABLED
1218   }
1219
1220   typedef gboolean RType;
1221   return RType();
1222 }
1223
1224 static const Glib::SignalProxyInfo Widget_signal_button_press_event_info =
1225 {
1226   "button_press_event",
1227   (GCallback) &Widget_signal_button_press_event_callback,
1228   (GCallback) &Widget_signal_button_press_event_notify_callback
1229 };
1230
1231
1232 static gboolean Widget_signal_button_release_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
1233 {
1234   using namespace Gtk;
1235   typedef sigc::slot< bool,GdkEventButton* > SlotType;
1236
1237   // Do not try to call a signal on a disassociated wrapper.
1238   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1239   {
1240     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1241     try
1242     {
1243     #endif //GLIBMM_EXCEPTIONS_ENABLED
1244       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1245         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1246     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1247     }
1248     catch(...)
1249     {
1250       Glib::exception_handlers_invoke();
1251     }
1252     #endif //GLIBMM_EXCEPTIONS_ENABLED
1253   }
1254
1255   typedef gboolean RType;
1256   return RType();
1257 }
1258
1259 static gboolean Widget_signal_button_release_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
1260 {
1261   using namespace Gtk;
1262   typedef sigc::slot< void,GdkEventButton* > SlotType;
1263
1264   // Do not try to call a signal on a disassociated wrapper.
1265   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1266   {
1267     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1268     try
1269     {
1270     #endif //GLIBMM_EXCEPTIONS_ENABLED
1271       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1272         (*static_cast<SlotType*>(slot))(p0);
1273     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1274     }
1275     catch(...)
1276     {
1277       Glib::exception_handlers_invoke();
1278     }
1279     #endif //GLIBMM_EXCEPTIONS_ENABLED
1280   }
1281
1282   typedef gboolean RType;
1283   return RType();
1284 }
1285
1286 static const Glib::SignalProxyInfo Widget_signal_button_release_event_info =
1287 {
1288   "button_release_event",
1289   (GCallback) &Widget_signal_button_release_event_callback,
1290   (GCallback) &Widget_signal_button_release_event_notify_callback
1291 };
1292
1293
1294 static gboolean Widget_signal_scroll_event_callback(GtkWidget* self, GdkEventScroll* p0,void* data)
1295 {
1296   using namespace Gtk;
1297   typedef sigc::slot< bool,GdkEventScroll* > SlotType;
1298
1299   // Do not try to call a signal on a disassociated wrapper.
1300   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1301   {
1302     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1303     try
1304     {
1305     #endif //GLIBMM_EXCEPTIONS_ENABLED
1306       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1307         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1308     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1309     }
1310     catch(...)
1311     {
1312       Glib::exception_handlers_invoke();
1313     }
1314     #endif //GLIBMM_EXCEPTIONS_ENABLED
1315   }
1316
1317   typedef gboolean RType;
1318   return RType();
1319 }
1320
1321 static gboolean Widget_signal_scroll_event_notify_callback(GtkWidget* self, GdkEventScroll* p0, void* data)
1322 {
1323   using namespace Gtk;
1324   typedef sigc::slot< void,GdkEventScroll* > SlotType;
1325
1326   // Do not try to call a signal on a disassociated wrapper.
1327   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1328   {
1329     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1330     try
1331     {
1332     #endif //GLIBMM_EXCEPTIONS_ENABLED
1333       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1334         (*static_cast<SlotType*>(slot))(p0);
1335     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1336     }
1337     catch(...)
1338     {
1339       Glib::exception_handlers_invoke();
1340     }
1341     #endif //GLIBMM_EXCEPTIONS_ENABLED
1342   }
1343
1344   typedef gboolean RType;
1345   return RType();
1346 }
1347
1348 static const Glib::SignalProxyInfo Widget_signal_scroll_event_info =
1349 {
1350   "scroll_event",
1351   (GCallback) &Widget_signal_scroll_event_callback,
1352   (GCallback) &Widget_signal_scroll_event_notify_callback
1353 };
1354
1355
1356 static gboolean Widget_signal_motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0,void* data)
1357 {
1358   using namespace Gtk;
1359   typedef sigc::slot< bool,GdkEventMotion* > SlotType;
1360
1361   // Do not try to call a signal on a disassociated wrapper.
1362   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1363   {
1364     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1365     try
1366     {
1367     #endif //GLIBMM_EXCEPTIONS_ENABLED
1368       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1369         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1370     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1371     }
1372     catch(...)
1373     {
1374       Glib::exception_handlers_invoke();
1375     }
1376     #endif //GLIBMM_EXCEPTIONS_ENABLED
1377   }
1378
1379   typedef gboolean RType;
1380   return RType();
1381 }
1382
1383 static gboolean Widget_signal_motion_notify_event_notify_callback(GtkWidget* self, GdkEventMotion* p0, void* data)
1384 {
1385   using namespace Gtk;
1386   typedef sigc::slot< void,GdkEventMotion* > SlotType;
1387
1388   // Do not try to call a signal on a disassociated wrapper.
1389   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1390   {
1391     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1392     try
1393     {
1394     #endif //GLIBMM_EXCEPTIONS_ENABLED
1395       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1396         (*static_cast<SlotType*>(slot))(p0);
1397     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1398     }
1399     catch(...)
1400     {
1401       Glib::exception_handlers_invoke();
1402     }
1403     #endif //GLIBMM_EXCEPTIONS_ENABLED
1404   }
1405
1406   typedef gboolean RType;
1407   return RType();
1408 }
1409
1410 static const Glib::SignalProxyInfo Widget_signal_motion_notify_event_info =
1411 {
1412   "motion_notify_event",
1413   (GCallback) &Widget_signal_motion_notify_event_callback,
1414   (GCallback) &Widget_signal_motion_notify_event_notify_callback
1415 };
1416
1417
1418 static gboolean Widget_signal_delete_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
1419 {
1420   using namespace Gtk;
1421   typedef sigc::slot< bool,GdkEventAny* > SlotType;
1422
1423   // Do not try to call a signal on a disassociated wrapper.
1424   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1425   {
1426     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1427     try
1428     {
1429     #endif //GLIBMM_EXCEPTIONS_ENABLED
1430       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1431         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1432     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1433     }
1434     catch(...)
1435     {
1436       Glib::exception_handlers_invoke();
1437     }
1438     #endif //GLIBMM_EXCEPTIONS_ENABLED
1439   }
1440
1441   typedef gboolean RType;
1442   return RType();
1443 }
1444
1445 static gboolean Widget_signal_delete_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
1446 {
1447   using namespace Gtk;
1448   typedef sigc::slot< void,GdkEventAny* > SlotType;
1449
1450   // Do not try to call a signal on a disassociated wrapper.
1451   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1452   {
1453     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1454     try
1455     {
1456     #endif //GLIBMM_EXCEPTIONS_ENABLED
1457       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1458         (*static_cast<SlotType*>(slot))(p0);
1459     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1460     }
1461     catch(...)
1462     {
1463       Glib::exception_handlers_invoke();
1464     }
1465     #endif //GLIBMM_EXCEPTIONS_ENABLED
1466   }
1467
1468   typedef gboolean RType;
1469   return RType();
1470 }
1471
1472 static const Glib::SignalProxyInfo Widget_signal_delete_event_info =
1473 {
1474   "delete_event",
1475   (GCallback) &Widget_signal_delete_event_callback,
1476   (GCallback) &Widget_signal_delete_event_notify_callback
1477 };
1478
1479
1480 static gboolean Widget_signal_expose_event_callback(GtkWidget* self, GdkEventExpose* p0,void* data)
1481 {
1482   using namespace Gtk;
1483   typedef sigc::slot< bool,GdkEventExpose* > SlotType;
1484
1485   // Do not try to call a signal on a disassociated wrapper.
1486   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1487   {
1488     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1489     try
1490     {
1491     #endif //GLIBMM_EXCEPTIONS_ENABLED
1492       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1493         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1494     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1495     }
1496     catch(...)
1497     {
1498       Glib::exception_handlers_invoke();
1499     }
1500     #endif //GLIBMM_EXCEPTIONS_ENABLED
1501   }
1502
1503   typedef gboolean RType;
1504   return RType();
1505 }
1506
1507 static gboolean Widget_signal_expose_event_notify_callback(GtkWidget* self, GdkEventExpose* p0, void* data)
1508 {
1509   using namespace Gtk;
1510   typedef sigc::slot< void,GdkEventExpose* > SlotType;
1511
1512   // Do not try to call a signal on a disassociated wrapper.
1513   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1514   {
1515     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1516     try
1517     {
1518     #endif //GLIBMM_EXCEPTIONS_ENABLED
1519       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1520         (*static_cast<SlotType*>(slot))(p0);
1521     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1522     }
1523     catch(...)
1524     {
1525       Glib::exception_handlers_invoke();
1526     }
1527     #endif //GLIBMM_EXCEPTIONS_ENABLED
1528   }
1529
1530   typedef gboolean RType;
1531   return RType();
1532 }
1533
1534 static const Glib::SignalProxyInfo Widget_signal_expose_event_info =
1535 {
1536   "expose_event",
1537   (GCallback) &Widget_signal_expose_event_callback,
1538   (GCallback) &Widget_signal_expose_event_notify_callback
1539 };
1540
1541
1542 static gboolean Widget_signal_key_press_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
1543 {
1544   using namespace Gtk;
1545   typedef sigc::slot< bool,GdkEventKey* > SlotType;
1546
1547   // Do not try to call a signal on a disassociated wrapper.
1548   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1549   {
1550     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1551     try
1552     {
1553     #endif //GLIBMM_EXCEPTIONS_ENABLED
1554       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1555         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1556     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1557     }
1558     catch(...)
1559     {
1560       Glib::exception_handlers_invoke();
1561     }
1562     #endif //GLIBMM_EXCEPTIONS_ENABLED
1563   }
1564
1565   typedef gboolean RType;
1566   return RType();
1567 }
1568
1569 static gboolean Widget_signal_key_press_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
1570 {
1571   using namespace Gtk;
1572   typedef sigc::slot< void,GdkEventKey* > SlotType;
1573
1574   // Do not try to call a signal on a disassociated wrapper.
1575   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1576   {
1577     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1578     try
1579     {
1580     #endif //GLIBMM_EXCEPTIONS_ENABLED
1581       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1582         (*static_cast<SlotType*>(slot))(p0);
1583     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1584     }
1585     catch(...)
1586     {
1587       Glib::exception_handlers_invoke();
1588     }
1589     #endif //GLIBMM_EXCEPTIONS_ENABLED
1590   }
1591
1592   typedef gboolean RType;
1593   return RType();
1594 }
1595
1596 static const Glib::SignalProxyInfo Widget_signal_key_press_event_info =
1597 {
1598   "key_press_event",
1599   (GCallback) &Widget_signal_key_press_event_callback,
1600   (GCallback) &Widget_signal_key_press_event_notify_callback
1601 };
1602
1603
1604 static gboolean Widget_signal_key_release_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
1605 {
1606   using namespace Gtk;
1607   typedef sigc::slot< bool,GdkEventKey* > SlotType;
1608
1609   // Do not try to call a signal on a disassociated wrapper.
1610   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1611   {
1612     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1613     try
1614     {
1615     #endif //GLIBMM_EXCEPTIONS_ENABLED
1616       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1617         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1618     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1619     }
1620     catch(...)
1621     {
1622       Glib::exception_handlers_invoke();
1623     }
1624     #endif //GLIBMM_EXCEPTIONS_ENABLED
1625   }
1626
1627   typedef gboolean RType;
1628   return RType();
1629 }
1630
1631 static gboolean Widget_signal_key_release_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
1632 {
1633   using namespace Gtk;
1634   typedef sigc::slot< void,GdkEventKey* > SlotType;
1635
1636   // Do not try to call a signal on a disassociated wrapper.
1637   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1638   {
1639     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1640     try
1641     {
1642     #endif //GLIBMM_EXCEPTIONS_ENABLED
1643       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1644         (*static_cast<SlotType*>(slot))(p0);
1645     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1646     }
1647     catch(...)
1648     {
1649       Glib::exception_handlers_invoke();
1650     }
1651     #endif //GLIBMM_EXCEPTIONS_ENABLED
1652   }
1653
1654   typedef gboolean RType;
1655   return RType();
1656 }
1657
1658 static const Glib::SignalProxyInfo Widget_signal_key_release_event_info =
1659 {
1660   "key_release_event",
1661   (GCallback) &Widget_signal_key_release_event_callback,
1662   (GCallback) &Widget_signal_key_release_event_notify_callback
1663 };
1664
1665
1666 static gboolean Widget_signal_enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
1667 {
1668   using namespace Gtk;
1669   typedef sigc::slot< bool,GdkEventCrossing* > SlotType;
1670
1671   // Do not try to call a signal on a disassociated wrapper.
1672   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1673   {
1674     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1675     try
1676     {
1677     #endif //GLIBMM_EXCEPTIONS_ENABLED
1678       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1679         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1680     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1681     }
1682     catch(...)
1683     {
1684       Glib::exception_handlers_invoke();
1685     }
1686     #endif //GLIBMM_EXCEPTIONS_ENABLED
1687   }
1688
1689   typedef gboolean RType;
1690   return RType();
1691 }
1692
1693 static gboolean Widget_signal_enter_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
1694 {
1695   using namespace Gtk;
1696   typedef sigc::slot< void,GdkEventCrossing* > SlotType;
1697
1698   // Do not try to call a signal on a disassociated wrapper.
1699   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1700   {
1701     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1702     try
1703     {
1704     #endif //GLIBMM_EXCEPTIONS_ENABLED
1705       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1706         (*static_cast<SlotType*>(slot))(p0);
1707     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1708     }
1709     catch(...)
1710     {
1711       Glib::exception_handlers_invoke();
1712     }
1713     #endif //GLIBMM_EXCEPTIONS_ENABLED
1714   }
1715
1716   typedef gboolean RType;
1717   return RType();
1718 }
1719
1720 static const Glib::SignalProxyInfo Widget_signal_enter_notify_event_info =
1721 {
1722   "enter_notify_event",
1723   (GCallback) &Widget_signal_enter_notify_event_callback,
1724   (GCallback) &Widget_signal_enter_notify_event_notify_callback
1725 };
1726
1727
1728 static gboolean Widget_signal_leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
1729 {
1730   using namespace Gtk;
1731   typedef sigc::slot< bool,GdkEventCrossing* > SlotType;
1732
1733   // Do not try to call a signal on a disassociated wrapper.
1734   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1735   {
1736     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1737     try
1738     {
1739     #endif //GLIBMM_EXCEPTIONS_ENABLED
1740       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1741         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1742     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1743     }
1744     catch(...)
1745     {
1746       Glib::exception_handlers_invoke();
1747     }
1748     #endif //GLIBMM_EXCEPTIONS_ENABLED
1749   }
1750
1751   typedef gboolean RType;
1752   return RType();
1753 }
1754
1755 static gboolean Widget_signal_leave_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
1756 {
1757   using namespace Gtk;
1758   typedef sigc::slot< void,GdkEventCrossing* > SlotType;
1759
1760   // Do not try to call a signal on a disassociated wrapper.
1761   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1762   {
1763     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1764     try
1765     {
1766     #endif //GLIBMM_EXCEPTIONS_ENABLED
1767       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1768         (*static_cast<SlotType*>(slot))(p0);
1769     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1770     }
1771     catch(...)
1772     {
1773       Glib::exception_handlers_invoke();
1774     }
1775     #endif //GLIBMM_EXCEPTIONS_ENABLED
1776   }
1777
1778   typedef gboolean RType;
1779   return RType();
1780 }
1781
1782 static const Glib::SignalProxyInfo Widget_signal_leave_notify_event_info =
1783 {
1784   "leave_notify_event",
1785   (GCallback) &Widget_signal_leave_notify_event_callback,
1786   (GCallback) &Widget_signal_leave_notify_event_notify_callback
1787 };
1788
1789
1790 static gboolean Widget_signal_configure_event_callback(GtkWidget* self, GdkEventConfigure* p0,void* data)
1791 {
1792   using namespace Gtk;
1793   typedef sigc::slot< bool,GdkEventConfigure* > SlotType;
1794
1795   // Do not try to call a signal on a disassociated wrapper.
1796   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1797   {
1798     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1799     try
1800     {
1801     #endif //GLIBMM_EXCEPTIONS_ENABLED
1802       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1803         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1804     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1805     }
1806     catch(...)
1807     {
1808       Glib::exception_handlers_invoke();
1809     }
1810     #endif //GLIBMM_EXCEPTIONS_ENABLED
1811   }
1812
1813   typedef gboolean RType;
1814   return RType();
1815 }
1816
1817 static gboolean Widget_signal_configure_event_notify_callback(GtkWidget* self, GdkEventConfigure* p0, void* data)
1818 {
1819   using namespace Gtk;
1820   typedef sigc::slot< void,GdkEventConfigure* > SlotType;
1821
1822   // Do not try to call a signal on a disassociated wrapper.
1823   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1824   {
1825     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1826     try
1827     {
1828     #endif //GLIBMM_EXCEPTIONS_ENABLED
1829       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1830         (*static_cast<SlotType*>(slot))(p0);
1831     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1832     }
1833     catch(...)
1834     {
1835       Glib::exception_handlers_invoke();
1836     }
1837     #endif //GLIBMM_EXCEPTIONS_ENABLED
1838   }
1839
1840   typedef gboolean RType;
1841   return RType();
1842 }
1843
1844 static const Glib::SignalProxyInfo Widget_signal_configure_event_info =
1845 {
1846   "configure_event",
1847   (GCallback) &Widget_signal_configure_event_callback,
1848   (GCallback) &Widget_signal_configure_event_notify_callback
1849 };
1850
1851
1852 static gboolean Widget_signal_focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
1853 {
1854   using namespace Gtk;
1855   typedef sigc::slot< bool,GdkEventFocus* > SlotType;
1856
1857   // Do not try to call a signal on a disassociated wrapper.
1858   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1859   {
1860     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1861     try
1862     {
1863     #endif //GLIBMM_EXCEPTIONS_ENABLED
1864       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1865         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1866     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1867     }
1868     catch(...)
1869     {
1870       Glib::exception_handlers_invoke();
1871     }
1872     #endif //GLIBMM_EXCEPTIONS_ENABLED
1873   }
1874
1875   typedef gboolean RType;
1876   return RType();
1877 }
1878
1879 static gboolean Widget_signal_focus_in_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
1880 {
1881   using namespace Gtk;
1882   typedef sigc::slot< void,GdkEventFocus* > SlotType;
1883
1884   // Do not try to call a signal on a disassociated wrapper.
1885   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1886   {
1887     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1888     try
1889     {
1890     #endif //GLIBMM_EXCEPTIONS_ENABLED
1891       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1892         (*static_cast<SlotType*>(slot))(p0);
1893     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1894     }
1895     catch(...)
1896     {
1897       Glib::exception_handlers_invoke();
1898     }
1899     #endif //GLIBMM_EXCEPTIONS_ENABLED
1900   }
1901
1902   typedef gboolean RType;
1903   return RType();
1904 }
1905
1906 static const Glib::SignalProxyInfo Widget_signal_focus_in_event_info =
1907 {
1908   "focus_in_event",
1909   (GCallback) &Widget_signal_focus_in_event_callback,
1910   (GCallback) &Widget_signal_focus_in_event_notify_callback
1911 };
1912
1913
1914 static gboolean Widget_signal_focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
1915 {
1916   using namespace Gtk;
1917   typedef sigc::slot< bool,GdkEventFocus* > SlotType;
1918
1919   // Do not try to call a signal on a disassociated wrapper.
1920   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1921   {
1922     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1923     try
1924     {
1925     #endif //GLIBMM_EXCEPTIONS_ENABLED
1926       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1927         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1928     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1929     }
1930     catch(...)
1931     {
1932       Glib::exception_handlers_invoke();
1933     }
1934     #endif //GLIBMM_EXCEPTIONS_ENABLED
1935   }
1936
1937   typedef gboolean RType;
1938   return RType();
1939 }
1940
1941 static gboolean Widget_signal_focus_out_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
1942 {
1943   using namespace Gtk;
1944   typedef sigc::slot< void,GdkEventFocus* > SlotType;
1945
1946   // Do not try to call a signal on a disassociated wrapper.
1947   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1948   {
1949     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1950     try
1951     {
1952     #endif //GLIBMM_EXCEPTIONS_ENABLED
1953       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1954         (*static_cast<SlotType*>(slot))(p0);
1955     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1956     }
1957     catch(...)
1958     {
1959       Glib::exception_handlers_invoke();
1960     }
1961     #endif //GLIBMM_EXCEPTIONS_ENABLED
1962   }
1963
1964   typedef gboolean RType;
1965   return RType();
1966 }
1967
1968 static const Glib::SignalProxyInfo Widget_signal_focus_out_event_info =
1969 {
1970   "focus_out_event",
1971   (GCallback) &Widget_signal_focus_out_event_callback,
1972   (GCallback) &Widget_signal_focus_out_event_notify_callback
1973 };
1974
1975
1976 static gboolean Widget_signal_map_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
1977 {
1978   using namespace Gtk;
1979   typedef sigc::slot< bool,GdkEventAny* > SlotType;
1980
1981   // Do not try to call a signal on a disassociated wrapper.
1982   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
1983   {
1984     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1985     try
1986     {
1987     #endif //GLIBMM_EXCEPTIONS_ENABLED
1988       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
1989         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
1990     #ifdef GLIBMM_EXCEPTIONS_ENABLED
1991     }
1992     catch(...)
1993     {
1994       Glib::exception_handlers_invoke();
1995     }
1996     #endif //GLIBMM_EXCEPTIONS_ENABLED
1997   }
1998
1999   typedef gboolean RType;
2000   return RType();
2001 }
2002
2003 static gboolean Widget_signal_map_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
2004 {
2005   using namespace Gtk;
2006   typedef sigc::slot< void,GdkEventAny* > SlotType;
2007
2008   // Do not try to call a signal on a disassociated wrapper.
2009   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2010   {
2011     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2012     try
2013     {
2014     #endif //GLIBMM_EXCEPTIONS_ENABLED
2015       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2016         (*static_cast<SlotType*>(slot))(p0);
2017     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2018     }
2019     catch(...)
2020     {
2021       Glib::exception_handlers_invoke();
2022     }
2023     #endif //GLIBMM_EXCEPTIONS_ENABLED
2024   }
2025
2026   typedef gboolean RType;
2027   return RType();
2028 }
2029
2030 static const Glib::SignalProxyInfo Widget_signal_map_event_info =
2031 {
2032   "map_event",
2033   (GCallback) &Widget_signal_map_event_callback,
2034   (GCallback) &Widget_signal_map_event_notify_callback
2035 };
2036
2037
2038 static gboolean Widget_signal_unmap_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
2039 {
2040   using namespace Gtk;
2041   typedef sigc::slot< bool,GdkEventAny* > SlotType;
2042
2043   // Do not try to call a signal on a disassociated wrapper.
2044   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2045   {
2046     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2047     try
2048     {
2049     #endif //GLIBMM_EXCEPTIONS_ENABLED
2050       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2051         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2052     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2053     }
2054     catch(...)
2055     {
2056       Glib::exception_handlers_invoke();
2057     }
2058     #endif //GLIBMM_EXCEPTIONS_ENABLED
2059   }
2060
2061   typedef gboolean RType;
2062   return RType();
2063 }
2064
2065 static gboolean Widget_signal_unmap_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
2066 {
2067   using namespace Gtk;
2068   typedef sigc::slot< void,GdkEventAny* > SlotType;
2069
2070   // Do not try to call a signal on a disassociated wrapper.
2071   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2072   {
2073     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2074     try
2075     {
2076     #endif //GLIBMM_EXCEPTIONS_ENABLED
2077       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2078         (*static_cast<SlotType*>(slot))(p0);
2079     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2080     }
2081     catch(...)
2082     {
2083       Glib::exception_handlers_invoke();
2084     }
2085     #endif //GLIBMM_EXCEPTIONS_ENABLED
2086   }
2087
2088   typedef gboolean RType;
2089   return RType();
2090 }
2091
2092 static const Glib::SignalProxyInfo Widget_signal_unmap_event_info =
2093 {
2094   "unmap_event",
2095   (GCallback) &Widget_signal_unmap_event_callback,
2096   (GCallback) &Widget_signal_unmap_event_notify_callback
2097 };
2098
2099
2100 static gboolean Widget_signal_property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0,void* data)
2101 {
2102   using namespace Gtk;
2103   typedef sigc::slot< bool,GdkEventProperty* > SlotType;
2104
2105   // Do not try to call a signal on a disassociated wrapper.
2106   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2107   {
2108     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2109     try
2110     {
2111     #endif //GLIBMM_EXCEPTIONS_ENABLED
2112       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2113         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2114     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2115     }
2116     catch(...)
2117     {
2118       Glib::exception_handlers_invoke();
2119     }
2120     #endif //GLIBMM_EXCEPTIONS_ENABLED
2121   }
2122
2123   typedef gboolean RType;
2124   return RType();
2125 }
2126
2127 static gboolean Widget_signal_property_notify_event_notify_callback(GtkWidget* self, GdkEventProperty* p0, void* data)
2128 {
2129   using namespace Gtk;
2130   typedef sigc::slot< void,GdkEventProperty* > SlotType;
2131
2132   // Do not try to call a signal on a disassociated wrapper.
2133   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2134   {
2135     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2136     try
2137     {
2138     #endif //GLIBMM_EXCEPTIONS_ENABLED
2139       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2140         (*static_cast<SlotType*>(slot))(p0);
2141     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2142     }
2143     catch(...)
2144     {
2145       Glib::exception_handlers_invoke();
2146     }
2147     #endif //GLIBMM_EXCEPTIONS_ENABLED
2148   }
2149
2150   typedef gboolean RType;
2151   return RType();
2152 }
2153
2154 static const Glib::SignalProxyInfo Widget_signal_property_notify_event_info =
2155 {
2156   "property_notify_event",
2157   (GCallback) &Widget_signal_property_notify_event_callback,
2158   (GCallback) &Widget_signal_property_notify_event_notify_callback
2159 };
2160
2161
2162 static gboolean Widget_signal_selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
2163 {
2164   using namespace Gtk;
2165   typedef sigc::slot< bool,GdkEventSelection* > SlotType;
2166
2167   // Do not try to call a signal on a disassociated wrapper.
2168   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2169   {
2170     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2171     try
2172     {
2173     #endif //GLIBMM_EXCEPTIONS_ENABLED
2174       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2175         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2176     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2177     }
2178     catch(...)
2179     {
2180       Glib::exception_handlers_invoke();
2181     }
2182     #endif //GLIBMM_EXCEPTIONS_ENABLED
2183   }
2184
2185   typedef gboolean RType;
2186   return RType();
2187 }
2188
2189 static gboolean Widget_signal_selection_clear_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
2190 {
2191   using namespace Gtk;
2192   typedef sigc::slot< void,GdkEventSelection* > SlotType;
2193
2194   // Do not try to call a signal on a disassociated wrapper.
2195   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2196   {
2197     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2198     try
2199     {
2200     #endif //GLIBMM_EXCEPTIONS_ENABLED
2201       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2202         (*static_cast<SlotType*>(slot))(p0);
2203     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2204     }
2205     catch(...)
2206     {
2207       Glib::exception_handlers_invoke();
2208     }
2209     #endif //GLIBMM_EXCEPTIONS_ENABLED
2210   }
2211
2212   typedef gboolean RType;
2213   return RType();
2214 }
2215
2216 static const Glib::SignalProxyInfo Widget_signal_selection_clear_event_info =
2217 {
2218   "selection_clear_event",
2219   (GCallback) &Widget_signal_selection_clear_event_callback,
2220   (GCallback) &Widget_signal_selection_clear_event_notify_callback
2221 };
2222
2223
2224 static gboolean Widget_signal_selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
2225 {
2226   using namespace Gtk;
2227   typedef sigc::slot< bool,GdkEventSelection* > SlotType;
2228
2229   // Do not try to call a signal on a disassociated wrapper.
2230   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2231   {
2232     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2233     try
2234     {
2235     #endif //GLIBMM_EXCEPTIONS_ENABLED
2236       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2237         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2238     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2239     }
2240     catch(...)
2241     {
2242       Glib::exception_handlers_invoke();
2243     }
2244     #endif //GLIBMM_EXCEPTIONS_ENABLED
2245   }
2246
2247   typedef gboolean RType;
2248   return RType();
2249 }
2250
2251 static gboolean Widget_signal_selection_request_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
2252 {
2253   using namespace Gtk;
2254   typedef sigc::slot< void,GdkEventSelection* > SlotType;
2255
2256   // Do not try to call a signal on a disassociated wrapper.
2257   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2258   {
2259     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2260     try
2261     {
2262     #endif //GLIBMM_EXCEPTIONS_ENABLED
2263       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2264         (*static_cast<SlotType*>(slot))(p0);
2265     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2266     }
2267     catch(...)
2268     {
2269       Glib::exception_handlers_invoke();
2270     }
2271     #endif //GLIBMM_EXCEPTIONS_ENABLED
2272   }
2273
2274   typedef gboolean RType;
2275   return RType();
2276 }
2277
2278 static const Glib::SignalProxyInfo Widget_signal_selection_request_event_info =
2279 {
2280   "selection_request_event",
2281   (GCallback) &Widget_signal_selection_request_event_callback,
2282   (GCallback) &Widget_signal_selection_request_event_notify_callback
2283 };
2284
2285
2286 static gboolean Widget_signal_selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
2287 {
2288   using namespace Gtk;
2289   typedef sigc::slot< bool,GdkEventSelection* > SlotType;
2290
2291   // Do not try to call a signal on a disassociated wrapper.
2292   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2293   {
2294     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2295     try
2296     {
2297     #endif //GLIBMM_EXCEPTIONS_ENABLED
2298       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2299         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2300     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2301     }
2302     catch(...)
2303     {
2304       Glib::exception_handlers_invoke();
2305     }
2306     #endif //GLIBMM_EXCEPTIONS_ENABLED
2307   }
2308
2309   typedef gboolean RType;
2310   return RType();
2311 }
2312
2313 static gboolean Widget_signal_selection_notify_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
2314 {
2315   using namespace Gtk;
2316   typedef sigc::slot< void,GdkEventSelection* > SlotType;
2317
2318   // Do not try to call a signal on a disassociated wrapper.
2319   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2320   {
2321     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2322     try
2323     {
2324     #endif //GLIBMM_EXCEPTIONS_ENABLED
2325       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2326         (*static_cast<SlotType*>(slot))(p0);
2327     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2328     }
2329     catch(...)
2330     {
2331       Glib::exception_handlers_invoke();
2332     }
2333     #endif //GLIBMM_EXCEPTIONS_ENABLED
2334   }
2335
2336   typedef gboolean RType;
2337   return RType();
2338 }
2339
2340 static const Glib::SignalProxyInfo Widget_signal_selection_notify_event_info =
2341 {
2342   "selection_notify_event",
2343   (GCallback) &Widget_signal_selection_notify_event_callback,
2344   (GCallback) &Widget_signal_selection_notify_event_notify_callback
2345 };
2346
2347
2348 static gboolean Widget_signal_proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
2349 {
2350   using namespace Gtk;
2351   typedef sigc::slot< bool,GdkEventProximity* > SlotType;
2352
2353   // Do not try to call a signal on a disassociated wrapper.
2354   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2355   {
2356     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2357     try
2358     {
2359     #endif //GLIBMM_EXCEPTIONS_ENABLED
2360       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2361         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2362     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2363     }
2364     catch(...)
2365     {
2366       Glib::exception_handlers_invoke();
2367     }
2368     #endif //GLIBMM_EXCEPTIONS_ENABLED
2369   }
2370
2371   typedef gboolean RType;
2372   return RType();
2373 }
2374
2375 static gboolean Widget_signal_proximity_in_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
2376 {
2377   using namespace Gtk;
2378   typedef sigc::slot< void,GdkEventProximity* > SlotType;
2379
2380   // Do not try to call a signal on a disassociated wrapper.
2381   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2382   {
2383     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2384     try
2385     {
2386     #endif //GLIBMM_EXCEPTIONS_ENABLED
2387       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2388         (*static_cast<SlotType*>(slot))(p0);
2389     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2390     }
2391     catch(...)
2392     {
2393       Glib::exception_handlers_invoke();
2394     }
2395     #endif //GLIBMM_EXCEPTIONS_ENABLED
2396   }
2397
2398   typedef gboolean RType;
2399   return RType();
2400 }
2401
2402 static const Glib::SignalProxyInfo Widget_signal_proximity_in_event_info =
2403 {
2404   "proximity_in_event",
2405   (GCallback) &Widget_signal_proximity_in_event_callback,
2406   (GCallback) &Widget_signal_proximity_in_event_notify_callback
2407 };
2408
2409
2410 static gboolean Widget_signal_proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
2411 {
2412   using namespace Gtk;
2413   typedef sigc::slot< bool,GdkEventProximity* > SlotType;
2414
2415   // Do not try to call a signal on a disassociated wrapper.
2416   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2417   {
2418     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2419     try
2420     {
2421     #endif //GLIBMM_EXCEPTIONS_ENABLED
2422       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2423         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2424     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2425     }
2426     catch(...)
2427     {
2428       Glib::exception_handlers_invoke();
2429     }
2430     #endif //GLIBMM_EXCEPTIONS_ENABLED
2431   }
2432
2433   typedef gboolean RType;
2434   return RType();
2435 }
2436
2437 static gboolean Widget_signal_proximity_out_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
2438 {
2439   using namespace Gtk;
2440   typedef sigc::slot< void,GdkEventProximity* > SlotType;
2441
2442   // Do not try to call a signal on a disassociated wrapper.
2443   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2444   {
2445     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2446     try
2447     {
2448     #endif //GLIBMM_EXCEPTIONS_ENABLED
2449       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2450         (*static_cast<SlotType*>(slot))(p0);
2451     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2452     }
2453     catch(...)
2454     {
2455       Glib::exception_handlers_invoke();
2456     }
2457     #endif //GLIBMM_EXCEPTIONS_ENABLED
2458   }
2459
2460   typedef gboolean RType;
2461   return RType();
2462 }
2463
2464 static const Glib::SignalProxyInfo Widget_signal_proximity_out_event_info =
2465 {
2466   "proximity_out_event",
2467   (GCallback) &Widget_signal_proximity_out_event_callback,
2468   (GCallback) &Widget_signal_proximity_out_event_notify_callback
2469 };
2470
2471
2472 static gboolean Widget_signal_visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0,void* data)
2473 {
2474   using namespace Gtk;
2475   typedef sigc::slot< bool,GdkEventVisibility* > SlotType;
2476
2477   // Do not try to call a signal on a disassociated wrapper.
2478   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2479   {
2480     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2481     try
2482     {
2483     #endif //GLIBMM_EXCEPTIONS_ENABLED
2484       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2485         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2486     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2487     }
2488     catch(...)
2489     {
2490       Glib::exception_handlers_invoke();
2491     }
2492     #endif //GLIBMM_EXCEPTIONS_ENABLED
2493   }
2494
2495   typedef gboolean RType;
2496   return RType();
2497 }
2498
2499 static gboolean Widget_signal_visibility_notify_event_notify_callback(GtkWidget* self, GdkEventVisibility* p0, void* data)
2500 {
2501   using namespace Gtk;
2502   typedef sigc::slot< void,GdkEventVisibility* > SlotType;
2503
2504   // Do not try to call a signal on a disassociated wrapper.
2505   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2506   {
2507     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2508     try
2509     {
2510     #endif //GLIBMM_EXCEPTIONS_ENABLED
2511       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2512         (*static_cast<SlotType*>(slot))(p0);
2513     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2514     }
2515     catch(...)
2516     {
2517       Glib::exception_handlers_invoke();
2518     }
2519     #endif //GLIBMM_EXCEPTIONS_ENABLED
2520   }
2521
2522   typedef gboolean RType;
2523   return RType();
2524 }
2525
2526 static const Glib::SignalProxyInfo Widget_signal_visibility_notify_event_info =
2527 {
2528   "visibility_notify_event",
2529   (GCallback) &Widget_signal_visibility_notify_event_callback,
2530   (GCallback) &Widget_signal_visibility_notify_event_notify_callback
2531 };
2532
2533
2534 static gboolean Widget_signal_client_event_callback(GtkWidget* self, GdkEventClient* p0,void* data)
2535 {
2536   using namespace Gtk;
2537   typedef sigc::slot< bool,GdkEventClient* > SlotType;
2538
2539   // Do not try to call a signal on a disassociated wrapper.
2540   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2541   {
2542     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2543     try
2544     {
2545     #endif //GLIBMM_EXCEPTIONS_ENABLED
2546       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2547         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2548     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2549     }
2550     catch(...)
2551     {
2552       Glib::exception_handlers_invoke();
2553     }
2554     #endif //GLIBMM_EXCEPTIONS_ENABLED
2555   }
2556
2557   typedef gboolean RType;
2558   return RType();
2559 }
2560
2561 static gboolean Widget_signal_client_event_notify_callback(GtkWidget* self, GdkEventClient* p0, void* data)
2562 {
2563   using namespace Gtk;
2564   typedef sigc::slot< void,GdkEventClient* > SlotType;
2565
2566   // Do not try to call a signal on a disassociated wrapper.
2567   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2568   {
2569     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2570     try
2571     {
2572     #endif //GLIBMM_EXCEPTIONS_ENABLED
2573       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2574         (*static_cast<SlotType*>(slot))(p0);
2575     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2576     }
2577     catch(...)
2578     {
2579       Glib::exception_handlers_invoke();
2580     }
2581     #endif //GLIBMM_EXCEPTIONS_ENABLED
2582   }
2583
2584   typedef gboolean RType;
2585   return RType();
2586 }
2587
2588 static const Glib::SignalProxyInfo Widget_signal_client_event_info =
2589 {
2590   "client_event",
2591   (GCallback) &Widget_signal_client_event_callback,
2592   (GCallback) &Widget_signal_client_event_notify_callback
2593 };
2594
2595
2596 static gboolean Widget_signal_no_expose_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
2597 {
2598   using namespace Gtk;
2599   typedef sigc::slot< bool,GdkEventAny* > SlotType;
2600
2601   // Do not try to call a signal on a disassociated wrapper.
2602   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2603   {
2604     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2605     try
2606     {
2607     #endif //GLIBMM_EXCEPTIONS_ENABLED
2608       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2609         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2610     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2611     }
2612     catch(...)
2613     {
2614       Glib::exception_handlers_invoke();
2615     }
2616     #endif //GLIBMM_EXCEPTIONS_ENABLED
2617   }
2618
2619   typedef gboolean RType;
2620   return RType();
2621 }
2622
2623 static gboolean Widget_signal_no_expose_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
2624 {
2625   using namespace Gtk;
2626   typedef sigc::slot< void,GdkEventAny* > SlotType;
2627
2628   // Do not try to call a signal on a disassociated wrapper.
2629   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2630   {
2631     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2632     try
2633     {
2634     #endif //GLIBMM_EXCEPTIONS_ENABLED
2635       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2636         (*static_cast<SlotType*>(slot))(p0);
2637     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2638     }
2639     catch(...)
2640     {
2641       Glib::exception_handlers_invoke();
2642     }
2643     #endif //GLIBMM_EXCEPTIONS_ENABLED
2644   }
2645
2646   typedef gboolean RType;
2647   return RType();
2648 }
2649
2650 static const Glib::SignalProxyInfo Widget_signal_no_expose_event_info =
2651 {
2652   "no_expose_event",
2653   (GCallback) &Widget_signal_no_expose_event_callback,
2654   (GCallback) &Widget_signal_no_expose_event_notify_callback
2655 };
2656
2657
2658 static gboolean Widget_signal_window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0,void* data)
2659 {
2660   using namespace Gtk;
2661   typedef sigc::slot< bool,GdkEventWindowState* > SlotType;
2662
2663   // Do not try to call a signal on a disassociated wrapper.
2664   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2665   {
2666     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2667     try
2668     {
2669     #endif //GLIBMM_EXCEPTIONS_ENABLED
2670       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2671         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
2672     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2673     }
2674     catch(...)
2675     {
2676       Glib::exception_handlers_invoke();
2677     }
2678     #endif //GLIBMM_EXCEPTIONS_ENABLED
2679   }
2680
2681   typedef gboolean RType;
2682   return RType();
2683 }
2684
2685 static gboolean Widget_signal_window_state_event_notify_callback(GtkWidget* self, GdkEventWindowState* p0, void* data)
2686 {
2687   using namespace Gtk;
2688   typedef sigc::slot< void,GdkEventWindowState* > SlotType;
2689
2690   // Do not try to call a signal on a disassociated wrapper.
2691   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2692   {
2693     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2694     try
2695     {
2696     #endif //GLIBMM_EXCEPTIONS_ENABLED
2697       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2698         (*static_cast<SlotType*>(slot))(p0);
2699     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2700     }
2701     catch(...)
2702     {
2703       Glib::exception_handlers_invoke();
2704     }
2705     #endif //GLIBMM_EXCEPTIONS_ENABLED
2706   }
2707
2708   typedef gboolean RType;
2709   return RType();
2710 }
2711
2712 static const Glib::SignalProxyInfo Widget_signal_window_state_event_info =
2713 {
2714   "window_state_event",
2715   (GCallback) &Widget_signal_window_state_event_callback,
2716   (GCallback) &Widget_signal_window_state_event_notify_callback
2717 };
2718
2719
2720 static const Glib::SignalProxyInfo Widget_signal_selection_get_info =
2721 {
2722   "selection_get",
2723   (GCallback) &Widget_signal_selection_get_callback,
2724   (GCallback) &Widget_signal_selection_get_callback
2725 };
2726
2727
2728 static void Widget_signal_selection_received_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,void* data)
2729 {
2730   using namespace Gtk;
2731   typedef sigc::slot< void,const SelectionData&,guint > SlotType;
2732
2733   // Do not try to call a signal on a disassociated wrapper.
2734   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2735   {
2736     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2737     try
2738     {
2739     #endif //GLIBMM_EXCEPTIONS_ENABLED
2740       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2741         (*static_cast<SlotType*>(slot))(SelectionData_WithoutOwnership(p0)
2742 , p1);
2743     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2744     }
2745     catch(...)
2746     {
2747       Glib::exception_handlers_invoke();
2748     }
2749     #endif //GLIBMM_EXCEPTIONS_ENABLED
2750   }
2751 }
2752
2753 static const Glib::SignalProxyInfo Widget_signal_selection_received_info =
2754 {
2755   "selection_received",
2756   (GCallback) &Widget_signal_selection_received_callback,
2757   (GCallback) &Widget_signal_selection_received_callback
2758 };
2759
2760
2761 static void Widget_signal_drag_begin_callback(GtkWidget* self, GdkDragContext* p0,void* data)
2762 {
2763   using namespace Gtk;
2764   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
2765
2766   // Do not try to call a signal on a disassociated wrapper.
2767   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2768   {
2769     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2770     try
2771     {
2772     #endif //GLIBMM_EXCEPTIONS_ENABLED
2773       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2774         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2775 );
2776     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2777     }
2778     catch(...)
2779     {
2780       Glib::exception_handlers_invoke();
2781     }
2782     #endif //GLIBMM_EXCEPTIONS_ENABLED
2783   }
2784 }
2785
2786 static const Glib::SignalProxyInfo Widget_signal_drag_begin_info =
2787 {
2788   "drag_begin",
2789   (GCallback) &Widget_signal_drag_begin_callback,
2790   (GCallback) &Widget_signal_drag_begin_callback
2791 };
2792
2793
2794 static void Widget_signal_drag_end_callback(GtkWidget* self, GdkDragContext* p0,void* data)
2795 {
2796   using namespace Gtk;
2797   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
2798
2799   // Do not try to call a signal on a disassociated wrapper.
2800   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2801   {
2802     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2803     try
2804     {
2805     #endif //GLIBMM_EXCEPTIONS_ENABLED
2806       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2807         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2808 );
2809     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2810     }
2811     catch(...)
2812     {
2813       Glib::exception_handlers_invoke();
2814     }
2815     #endif //GLIBMM_EXCEPTIONS_ENABLED
2816   }
2817 }
2818
2819 static const Glib::SignalProxyInfo Widget_signal_drag_end_info =
2820 {
2821   "drag_end",
2822   (GCallback) &Widget_signal_drag_end_callback,
2823   (GCallback) &Widget_signal_drag_end_callback
2824 };
2825
2826
2827 static const Glib::SignalProxyInfo Widget_signal_drag_data_get_info =
2828 {
2829   "drag_data_get",
2830   (GCallback) &Widget_signal_drag_data_get_callback,
2831   (GCallback) &Widget_signal_drag_data_get_callback
2832 };
2833
2834
2835 static void Widget_signal_drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0,void* data)
2836 {
2837   using namespace Gtk;
2838   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
2839
2840   // Do not try to call a signal on a disassociated wrapper.
2841   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2842   {
2843     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2844     try
2845     {
2846     #endif //GLIBMM_EXCEPTIONS_ENABLED
2847       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2848         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2849 );
2850     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2851     }
2852     catch(...)
2853     {
2854       Glib::exception_handlers_invoke();
2855     }
2856     #endif //GLIBMM_EXCEPTIONS_ENABLED
2857   }
2858 }
2859
2860 static const Glib::SignalProxyInfo Widget_signal_drag_data_delete_info =
2861 {
2862   "drag_data_delete",
2863   (GCallback) &Widget_signal_drag_data_delete_callback,
2864   (GCallback) &Widget_signal_drag_data_delete_callback
2865 };
2866
2867
2868 static void Widget_signal_drag_leave_callback(GtkWidget* self, GdkDragContext* p0,guint p1,void* data)
2869 {
2870   using namespace Gtk;
2871   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,guint > SlotType;
2872
2873   // Do not try to call a signal on a disassociated wrapper.
2874   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2875   {
2876     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2877     try
2878     {
2879     #endif //GLIBMM_EXCEPTIONS_ENABLED
2880       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2881         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2882 , p1);
2883     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2884     }
2885     catch(...)
2886     {
2887       Glib::exception_handlers_invoke();
2888     }
2889     #endif //GLIBMM_EXCEPTIONS_ENABLED
2890   }
2891 }
2892
2893 static const Glib::SignalProxyInfo Widget_signal_drag_leave_info =
2894 {
2895   "drag_leave",
2896   (GCallback) &Widget_signal_drag_leave_callback,
2897   (GCallback) &Widget_signal_drag_leave_callback
2898 };
2899
2900
2901 static gboolean Widget_signal_drag_motion_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
2902 {
2903   using namespace Gtk;
2904   typedef sigc::slot< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
2905
2906   // Do not try to call a signal on a disassociated wrapper.
2907   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2908   {
2909     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2910     try
2911     {
2912     #endif //GLIBMM_EXCEPTIONS_ENABLED
2913       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2914         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2915 , p1
2916 , p2
2917 , p3));
2918     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2919     }
2920     catch(...)
2921     {
2922       Glib::exception_handlers_invoke();
2923     }
2924     #endif //GLIBMM_EXCEPTIONS_ENABLED
2925   }
2926
2927   typedef gboolean RType;
2928   return RType();
2929 }
2930
2931 static gboolean Widget_signal_drag_motion_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
2932 {
2933   using namespace Gtk;
2934   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
2935
2936   // Do not try to call a signal on a disassociated wrapper.
2937   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2938   {
2939     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2940     try
2941     {
2942     #endif //GLIBMM_EXCEPTIONS_ENABLED
2943       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2944         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2945 , p1
2946 , p2
2947 , p3);
2948     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2949     }
2950     catch(...)
2951     {
2952       Glib::exception_handlers_invoke();
2953     }
2954     #endif //GLIBMM_EXCEPTIONS_ENABLED
2955   }
2956
2957   typedef gboolean RType;
2958   return RType();
2959 }
2960
2961 static const Glib::SignalProxyInfo Widget_signal_drag_motion_info =
2962 {
2963   "drag_motion",
2964   (GCallback) &Widget_signal_drag_motion_callback,
2965   (GCallback) &Widget_signal_drag_motion_notify_callback
2966 };
2967
2968
2969 static gboolean Widget_signal_drag_drop_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
2970 {
2971   using namespace Gtk;
2972   typedef sigc::slot< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
2973
2974   // Do not try to call a signal on a disassociated wrapper.
2975   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
2976   {
2977     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2978     try
2979     {
2980     #endif //GLIBMM_EXCEPTIONS_ENABLED
2981       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
2982         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
2983 , p1
2984 , p2
2985 , p3));
2986     #ifdef GLIBMM_EXCEPTIONS_ENABLED
2987     }
2988     catch(...)
2989     {
2990       Glib::exception_handlers_invoke();
2991     }
2992     #endif //GLIBMM_EXCEPTIONS_ENABLED
2993   }
2994
2995   typedef gboolean RType;
2996   return RType();
2997 }
2998
2999 static gboolean Widget_signal_drag_drop_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
3000 {
3001   using namespace Gtk;
3002   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
3003
3004   // Do not try to call a signal on a disassociated wrapper.
3005   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3006   {
3007     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3008     try
3009     {
3010     #endif //GLIBMM_EXCEPTIONS_ENABLED
3011       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3012         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
3013 , p1
3014 , p2
3015 , p3);
3016     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3017     }
3018     catch(...)
3019     {
3020       Glib::exception_handlers_invoke();
3021     }
3022     #endif //GLIBMM_EXCEPTIONS_ENABLED
3023   }
3024
3025   typedef gboolean RType;
3026   return RType();
3027 }
3028
3029 static const Glib::SignalProxyInfo Widget_signal_drag_drop_info =
3030 {
3031   "drag_drop",
3032   (GCallback) &Widget_signal_drag_drop_callback,
3033   (GCallback) &Widget_signal_drag_drop_notify_callback
3034 };
3035
3036
3037 static void Widget_signal_drag_data_received_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,GtkSelectionData* p3,guint p4,guint p5,void* data)
3038 {
3039   using namespace Gtk;
3040   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > SlotType;
3041
3042   // Do not try to call a signal on a disassociated wrapper.
3043   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3044   {
3045     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3046     try
3047     {
3048     #endif //GLIBMM_EXCEPTIONS_ENABLED
3049       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3050         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
3051 , p1
3052 , p2
3053 , SelectionData_WithoutOwnership(p3)
3054 , p4, p5);
3055     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3056     }
3057     catch(...)
3058     {
3059       Glib::exception_handlers_invoke();
3060     }
3061     #endif //GLIBMM_EXCEPTIONS_ENABLED
3062   }
3063 }
3064
3065 static const Glib::SignalProxyInfo Widget_signal_drag_data_received_info =
3066 {
3067   "drag_data_received",
3068   (GCallback) &Widget_signal_drag_data_received_callback,
3069   (GCallback) &Widget_signal_drag_data_received_callback
3070 };
3071
3072
3073 #ifdef GTKMM_ATKMM_ENABLED
3074
3075 static AtkObject* Widget_signal_get_accessible_callback(GtkWidget* self, void* data)
3076 {
3077   using namespace Gtk;
3078   typedef sigc::slot< Glib::RefPtr<Atk::Object> > SlotType;
3079
3080   // Do not try to call a signal on a disassociated wrapper.
3081   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3082   {
3083     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3084     try
3085     {
3086     #endif //GLIBMM_EXCEPTIONS_ENABLED
3087       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3088         return Glib::unwrap((*static_cast<SlotType*>(slot))());
3089     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3090     }
3091     catch(...)
3092     {
3093       Glib::exception_handlers_invoke();
3094     }
3095     #endif //GLIBMM_EXCEPTIONS_ENABLED
3096   }
3097
3098   typedef AtkObject* RType;
3099   return RType();
3100 }
3101
3102 static AtkObject* Widget_signal_get_accessible_notify_callback(GtkWidget* self,  void* data)
3103 {
3104   using namespace Gtk;
3105   typedef sigc::slot< void > SlotType;
3106
3107   // Do not try to call a signal on a disassociated wrapper.
3108   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3109   {
3110     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3111     try
3112     {
3113     #endif //GLIBMM_EXCEPTIONS_ENABLED
3114       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3115         (*static_cast<SlotType*>(slot))();
3116     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3117     }
3118     catch(...)
3119     {
3120       Glib::exception_handlers_invoke();
3121     }
3122     #endif //GLIBMM_EXCEPTIONS_ENABLED
3123   }
3124
3125   typedef AtkObject* RType;
3126   return RType();
3127 }
3128
3129 static const Glib::SignalProxyInfo Widget_signal_get_accessible_info =
3130 {
3131   "get_accessible",
3132   (GCallback) &Widget_signal_get_accessible_callback,
3133   (GCallback) &Widget_signal_get_accessible_notify_callback
3134 };
3135
3136 #endif // GTKMM_ATKMM_ENABLED
3137
3138
3139 static void Widget_signal_screen_changed_callback(GtkWidget* self, GdkScreen* p0,void* data)
3140 {
3141   using namespace Gtk;
3142   typedef sigc::slot< void,const Glib::RefPtr<Gdk::Screen>& > SlotType;
3143
3144   // Do not try to call a signal on a disassociated wrapper.
3145   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3146   {
3147     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3148     try
3149     {
3150     #endif //GLIBMM_EXCEPTIONS_ENABLED
3151       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3152         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
3153 );
3154     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3155     }
3156     catch(...)
3157     {
3158       Glib::exception_handlers_invoke();
3159     }
3160     #endif //GLIBMM_EXCEPTIONS_ENABLED
3161   }
3162 }
3163
3164 static const Glib::SignalProxyInfo Widget_signal_screen_changed_info =
3165 {
3166   "screen_changed",
3167   (GCallback) &Widget_signal_screen_changed_callback,
3168   (GCallback) &Widget_signal_screen_changed_callback
3169 };
3170
3171
3172 static const Glib::SignalProxyInfo Widget_signal_composited_changed_info =
3173 {
3174   "composited_changed",
3175   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
3176   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
3177 };
3178
3179
3180 static gboolean Widget_signal_query_tooltip_callback(GtkWidget* self, gint p0,gint p1,gboolean p2,GtkTooltip* p3,void* data)
3181 {
3182   using namespace Gtk;
3183   typedef sigc::slot< bool,int,int,bool,const Glib::RefPtr<Tooltip>& > SlotType;
3184
3185   // Do not try to call a signal on a disassociated wrapper.
3186   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3187   {
3188     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3189     try
3190     {
3191     #endif //GLIBMM_EXCEPTIONS_ENABLED
3192       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3193         return static_cast<int>((*static_cast<SlotType*>(slot))(p0
3194 , p1
3195 , p2
3196 , Glib::wrap(p3, true)
3197 ));
3198     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3199     }
3200     catch(...)
3201     {
3202       Glib::exception_handlers_invoke();
3203     }
3204     #endif //GLIBMM_EXCEPTIONS_ENABLED
3205   }
3206
3207   typedef gboolean RType;
3208   return RType();
3209 }
3210
3211 static gboolean Widget_signal_query_tooltip_notify_callback(GtkWidget* self, gint p0,gint p1,gboolean p2,GtkTooltip* p3, void* data)
3212 {
3213   using namespace Gtk;
3214   typedef sigc::slot< void,int,int,bool,const Glib::RefPtr<Tooltip>& > SlotType;
3215
3216   // Do not try to call a signal on a disassociated wrapper.
3217   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
3218   {
3219     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3220     try
3221     {
3222     #endif //GLIBMM_EXCEPTIONS_ENABLED
3223       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
3224         (*static_cast<SlotType*>(slot))(p0
3225 , p1
3226 , p2
3227 , Glib::wrap(p3, true)
3228 );
3229     #ifdef GLIBMM_EXCEPTIONS_ENABLED
3230     }
3231     catch(...)
3232     {
3233       Glib::exception_handlers_invoke();
3234     }
3235     #endif //GLIBMM_EXCEPTIONS_ENABLED
3236   }
3237
3238   typedef gboolean RType;
3239   return RType();
3240 }
3241
3242 static const Glib::SignalProxyInfo Widget_signal_query_tooltip_info =
3243 {
3244   "query_tooltip",
3245   (GCallback) &Widget_signal_query_tooltip_callback,
3246   (GCallback) &Widget_signal_query_tooltip_notify_callback
3247 };
3248
3249
3250 } // anonymous namespace
3251
3252 // static
3253 GType Glib::Value<Gtk::DestDefaults>::value_type()
3254 {
3255   return gtk_dest_defaults_get_type();
3256 }
3257
3258 // static
3259 GType Glib::Value<Gtk::WidgetFlags>::value_type()
3260 {
3261   return gtk_widget_flags_get_type();
3262 }
3263
3264 // static
3265 GType Glib::Value<Gtk::WidgetHelpType>::value_type()
3266 {
3267   return gtk_widget_help_type_get_type();
3268 }
3269
3270
3271 namespace Glib
3272 {
3273
3274 Gtk::Widget* wrap(GtkWidget* object, bool take_copy)
3275 {
3276   return dynamic_cast<Gtk::Widget *> (Glib::wrap_auto ((GObject*)(object), take_copy));
3277 }
3278
3279 } /* namespace Glib */
3280
3281 namespace Gtk
3282 {
3283
3284
3285 /* The *_Class implementation: */
3286
3287 const Glib::Class& Widget_Class::init()
3288 {
3289   if(!gtype_) // create the GType if necessary
3290   {
3291     // Glib::Class has to know the class init function to clone custom types.
3292     class_init_func_ = &Widget_Class::class_init_function;
3293
3294     // This is actually just optimized away, apparently with no harm.
3295     // Make sure that the parent type has been created.
3296     //CppClassParent::CppObjectType::get_type();
3297
3298     // Create the wrapper type, with the same class/instance size as the base type.
3299     register_derived_type(gtk_widget_get_type());
3300
3301     // Add derived versions of interfaces, if the C type implements any interfaces:
3302 #ifdef GTKMM_ATKMM_ENABLED
3303   Atk::Implementor::add_interface(get_type());
3304
3305 #endif // GTKMM_ATKMM_ENABLED
3306   }
3307
3308   return *this;
3309 }
3310
3311 void Widget_Class::class_init_function(void* g_class, void* class_data)
3312 {
3313   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
3314   CppClassParent::class_init_function(klass, class_data);
3315
3316 #ifdef GLIBMM_VFUNCS_ENABLED
3317 #endif //GLIBMM_VFUNCS_ENABLED //We always need dispose_vfunc_callback
3318     reinterpret_cast<GObjectClass*>(klass)->dispose = &dispose_vfunc_callback;
3319 #ifdef GLIBMM_VFUNCS_ENABLED
3320     klass->dispatch_child_properties_changed = &dispatch_child_properties_changed_vfunc_callback;
3321   klass->show_all = &show_all_vfunc_callback;
3322   klass->hide_all = &hide_all_vfunc_callback;
3323 #ifdef GTKMM_ATKMM_ENABLED
3324   klass->get_accessible = &get_accessible_vfunc_callback;
3325 #endif // GTKMM_ATKMM_ENABLED
3326 #endif //GLIBMM_VFUNCS_ENABLED
3327
3328 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
3329   klass->show = &show_callback;
3330   klass->hide = &hide_callback;
3331   klass->map = &map_callback;
3332   klass->unmap = &unmap_callback;
3333   klass->realize = &realize_callback;
3334   klass->unrealize = &unrealize_callback;
3335   klass->size_request = &size_request_callback;
3336   klass->size_allocate = &size_allocate_callback;
3337   klass->state_changed = &state_changed_callback;
3338   klass->parent_set = &parent_set_callback;
3339   klass->hierarchy_changed = &hierarchy_changed_callback;
3340   klass->style_set = &style_set_callback;
3341   klass->direction_changed = &direction_changed_callback;
3342   klass->grab_notify = &grab_notify_callback;
3343   klass->child_notify = &child_notify_callback;
3344   klass->mnemonic_activate = &mnemonic_activate_callback;
3345   klass->grab_focus = &grab_focus_callback;
3346   klass->focus = &focus_callback;
3347   klass->event = &event_callback;
3348   klass->button_press_event = &button_press_event_callback;
3349   klass->button_release_event = &button_release_event_callback;
3350   klass->scroll_event = &scroll_event_callback;
3351   klass->motion_notify_event = &motion_notify_event_callback;
3352   klass->delete_event = &delete_event_callback;
3353   klass->expose_event = &expose_event_callback;
3354   klass->key_press_event = &key_press_event_callback;
3355   klass->key_release_event = &key_release_event_callback;
3356   klass->enter_notify_event = &enter_notify_event_callback;
3357   klass->leave_notify_event = &leave_notify_event_callback;
3358   klass->configure_event = &configure_event_callback;
3359   klass->focus_in_event = &focus_in_event_callback;
3360   klass->focus_out_event = &focus_out_event_callback;
3361   klass->map_event = &map_event_callback;
3362   klass->unmap_event = &unmap_event_callback;
3363   klass->property_notify_event = &property_notify_event_callback;
3364   klass->selection_clear_event = &selection_clear_event_callback;
3365   klass->selection_request_event = &selection_request_event_callback;
3366   klass->selection_notify_event = &selection_notify_event_callback;
3367   klass->proximity_in_event = &proximity_in_event_callback;
3368   klass->proximity_out_event = &proximity_out_event_callback;
3369   klass->visibility_notify_event = &visibility_notify_event_callback;
3370   klass->client_event = &client_event_callback;
3371   klass->no_expose_event = &no_expose_event_callback;
3372   klass->window_state_event = &window_state_event_callback;
3373   klass->selection_get = &selection_get_callback;
3374   klass->selection_received = &selection_received_callback;
3375   klass->drag_begin = &drag_begin_callback;
3376   klass->drag_end = &drag_end_callback;
3377   klass->drag_data_get = &drag_data_get_callback;
3378   klass->drag_data_delete = &drag_data_delete_callback;
3379   klass->drag_leave = &drag_leave_callback;
3380   klass->drag_motion = &drag_motion_callback;
3381   klass->drag_drop = &drag_drop_callback;
3382   klass->drag_data_received = &drag_data_received_callback;
3383 #ifdef GTKMM_ATKMM_ENABLED
3384   klass->get_accessible = &get_accessible_callback;
3385 #endif // GTKMM_ATKMM_ENABLED
3386   klass->screen_changed = &screen_changed_callback;
3387     klass->hierarchy_changed = &hierarchy_changed_callback_custom;
3388       klass->parent_set = &parent_set_callback_custom;
3389   #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
3390 }
3391
3392 #ifdef GLIBMM_VFUNCS_ENABLED
3393 void Widget_Class::dispatch_child_properties_changed_vfunc_callback(GtkWidget* self, guint n_pspecs, GParamSpec** pspecs)
3394 {
3395   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3396       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3397
3398   // Non-gtkmmproc-generated custom classes implicitly call the default
3399   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3400   // generated classes can use this optimisation, which avoids the unnecessary
3401   // parameter conversions if there is no possibility of the virtual function
3402   // being overridden:
3403   if(obj_base && obj_base->is_derived_())
3404   {
3405     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3406     if(obj) // This can be NULL during destruction.
3407     {
3408       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3409       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3410       {
3411       #endif //GLIBMM_EXCEPTIONS_ENABLED
3412         // Call the virtual member method, which derived classes might override.
3413         obj->dispatch_child_properties_changed_vfunc(n_pspecs, pspecs);
3414         return;
3415       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3416       }
3417       catch(...)
3418       {
3419         Glib::exception_handlers_invoke();
3420       }
3421       #endif //GLIBMM_EXCEPTIONS_ENABLED
3422     }
3423   }
3424
3425   BaseClassType *const base = static_cast<BaseClassType*>(
3426       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3427   );
3428
3429   // Call the original underlying C function:
3430   if(base && base->dispatch_child_properties_changed)
3431     (*base->dispatch_child_properties_changed)(self, n_pspecs, pspecs);
3432
3433 }
3434 void Widget_Class::show_all_vfunc_callback(GtkWidget* self)
3435 {
3436   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3437       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3438
3439   // Non-gtkmmproc-generated custom classes implicitly call the default
3440   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3441   // generated classes can use this optimisation, which avoids the unnecessary
3442   // parameter conversions if there is no possibility of the virtual function
3443   // being overridden:
3444   if(obj_base && obj_base->is_derived_())
3445   {
3446     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3447     if(obj) // This can be NULL during destruction.
3448     {
3449       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3450       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3451       {
3452       #endif //GLIBMM_EXCEPTIONS_ENABLED
3453         // Call the virtual member method, which derived classes might override.
3454         obj->show_all_vfunc();
3455         return;
3456       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3457       }
3458       catch(...)
3459       {
3460         Glib::exception_handlers_invoke();
3461       }
3462       #endif //GLIBMM_EXCEPTIONS_ENABLED
3463     }
3464   }
3465
3466   BaseClassType *const base = static_cast<BaseClassType*>(
3467       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3468   );
3469
3470   // Call the original underlying C function:
3471   if(base && base->show_all)
3472     (*base->show_all)(self);
3473
3474 }
3475 void Widget_Class::hide_all_vfunc_callback(GtkWidget* self)
3476 {
3477   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3478       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3479
3480   // Non-gtkmmproc-generated custom classes implicitly call the default
3481   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3482   // generated classes can use this optimisation, which avoids the unnecessary
3483   // parameter conversions if there is no possibility of the virtual function
3484   // being overridden:
3485   if(obj_base && obj_base->is_derived_())
3486   {
3487     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3488     if(obj) // This can be NULL during destruction.
3489     {
3490       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3491       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3492       {
3493       #endif //GLIBMM_EXCEPTIONS_ENABLED
3494         // Call the virtual member method, which derived classes might override.
3495         obj->hide_all_vfunc();
3496         return;
3497       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3498       }
3499       catch(...)
3500       {
3501         Glib::exception_handlers_invoke();
3502       }
3503       #endif //GLIBMM_EXCEPTIONS_ENABLED
3504     }
3505   }
3506
3507   BaseClassType *const base = static_cast<BaseClassType*>(
3508       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3509   );
3510
3511   // Call the original underlying C function:
3512   if(base && base->hide_all)
3513     (*base->hide_all)(self);
3514
3515 }
3516 #ifdef GTKMM_ATKMM_ENABLED
3517 AtkObject* Widget_Class::get_accessible_vfunc_callback(GtkWidget* self)
3518 {
3519   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3520       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3521
3522   // Non-gtkmmproc-generated custom classes implicitly call the default
3523   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3524   // generated classes can use this optimisation, which avoids the unnecessary
3525   // parameter conversions if there is no possibility of the virtual function
3526   // being overridden:
3527   if(obj_base && obj_base->is_derived_())
3528   {
3529     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3530     if(obj) // This can be NULL during destruction.
3531     {
3532       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3533       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3534       {
3535       #endif //GLIBMM_EXCEPTIONS_ENABLED
3536         // Call the virtual member method, which derived classes might override.
3537         return Glib::unwrap(obj->get_accessible_vfunc());
3538       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3539       }
3540       catch(...)
3541       {
3542         Glib::exception_handlers_invoke();
3543       }
3544       #endif //GLIBMM_EXCEPTIONS_ENABLED
3545     }
3546   }
3547
3548   BaseClassType *const base = static_cast<BaseClassType*>(
3549       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3550   );
3551
3552   // Call the original underlying C function:
3553   if(base && base->get_accessible)
3554     return (*base->get_accessible)(self);
3555
3556
3557   typedef AtkObject* RType;
3558   return RType();
3559 }
3560 #endif // GTKMM_ATKMM_ENABLED
3561 #endif //GLIBMM_VFUNCS_ENABLED
3562
3563 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
3564 void Widget_Class::show_callback(GtkWidget* self)
3565 {
3566   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3567       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3568
3569   // Non-gtkmmproc-generated custom classes implicitly call the default
3570   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3571   // generated classes can use this optimisation, which avoids the unnecessary
3572   // parameter conversions if there is no possibility of the virtual function
3573   // being overridden:
3574   if(obj_base && obj_base->is_derived_())
3575   {
3576     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3577     if(obj) // This can be NULL during destruction.
3578     {
3579       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3580       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3581       {
3582       #endif //GLIBMM_EXCEPTIONS_ENABLED
3583         // Call the virtual member method, which derived classes might override.
3584         obj->on_show();
3585         return;
3586       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3587       }
3588       catch(...)
3589       {
3590         Glib::exception_handlers_invoke();
3591       }
3592       #endif //GLIBMM_EXCEPTIONS_ENABLED
3593     }
3594   }
3595
3596   BaseClassType *const base = static_cast<BaseClassType*>(
3597         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3598     );
3599
3600   // Call the original underlying C function:
3601   if(base && base->show)
3602     (*base->show)(self);
3603 }
3604 void Widget_Class::hide_callback(GtkWidget* self)
3605 {
3606   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3607       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3608
3609   // Non-gtkmmproc-generated custom classes implicitly call the default
3610   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3611   // generated classes can use this optimisation, which avoids the unnecessary
3612   // parameter conversions if there is no possibility of the virtual function
3613   // being overridden:
3614   if(obj_base && obj_base->is_derived_())
3615   {
3616     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3617     if(obj) // This can be NULL during destruction.
3618     {
3619       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3620       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3621       {
3622       #endif //GLIBMM_EXCEPTIONS_ENABLED
3623         // Call the virtual member method, which derived classes might override.
3624         obj->on_hide();
3625         return;
3626       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3627       }
3628       catch(...)
3629       {
3630         Glib::exception_handlers_invoke();
3631       }
3632       #endif //GLIBMM_EXCEPTIONS_ENABLED
3633     }
3634   }
3635
3636   BaseClassType *const base = static_cast<BaseClassType*>(
3637         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3638     );
3639
3640   // Call the original underlying C function:
3641   if(base && base->hide)
3642     (*base->hide)(self);
3643 }
3644 void Widget_Class::map_callback(GtkWidget* self)
3645 {
3646   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3647       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3648
3649   // Non-gtkmmproc-generated custom classes implicitly call the default
3650   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3651   // generated classes can use this optimisation, which avoids the unnecessary
3652   // parameter conversions if there is no possibility of the virtual function
3653   // being overridden:
3654   if(obj_base && obj_base->is_derived_())
3655   {
3656     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3657     if(obj) // This can be NULL during destruction.
3658     {
3659       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3660       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3661       {
3662       #endif //GLIBMM_EXCEPTIONS_ENABLED
3663         // Call the virtual member method, which derived classes might override.
3664         obj->on_map();
3665         return;
3666       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3667       }
3668       catch(...)
3669       {
3670         Glib::exception_handlers_invoke();
3671       }
3672       #endif //GLIBMM_EXCEPTIONS_ENABLED
3673     }
3674   }
3675
3676   BaseClassType *const base = static_cast<BaseClassType*>(
3677         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3678     );
3679
3680   // Call the original underlying C function:
3681   if(base && base->map)
3682     (*base->map)(self);
3683 }
3684 void Widget_Class::unmap_callback(GtkWidget* self)
3685 {
3686   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3687       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3688
3689   // Non-gtkmmproc-generated custom classes implicitly call the default
3690   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3691   // generated classes can use this optimisation, which avoids the unnecessary
3692   // parameter conversions if there is no possibility of the virtual function
3693   // being overridden:
3694   if(obj_base && obj_base->is_derived_())
3695   {
3696     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3697     if(obj) // This can be NULL during destruction.
3698     {
3699       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3700       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3701       {
3702       #endif //GLIBMM_EXCEPTIONS_ENABLED
3703         // Call the virtual member method, which derived classes might override.
3704         obj->on_unmap();
3705         return;
3706       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3707       }
3708       catch(...)
3709       {
3710         Glib::exception_handlers_invoke();
3711       }
3712       #endif //GLIBMM_EXCEPTIONS_ENABLED
3713     }
3714   }
3715
3716   BaseClassType *const base = static_cast<BaseClassType*>(
3717         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3718     );
3719
3720   // Call the original underlying C function:
3721   if(base && base->unmap)
3722     (*base->unmap)(self);
3723 }
3724 void Widget_Class::realize_callback(GtkWidget* self)
3725 {
3726   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3727       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3728
3729   // Non-gtkmmproc-generated custom classes implicitly call the default
3730   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3731   // generated classes can use this optimisation, which avoids the unnecessary
3732   // parameter conversions if there is no possibility of the virtual function
3733   // being overridden:
3734   if(obj_base && obj_base->is_derived_())
3735   {
3736     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3737     if(obj) // This can be NULL during destruction.
3738     {
3739       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3740       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3741       {
3742       #endif //GLIBMM_EXCEPTIONS_ENABLED
3743         // Call the virtual member method, which derived classes might override.
3744         obj->on_realize();
3745         return;
3746       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3747       }
3748       catch(...)
3749       {
3750         Glib::exception_handlers_invoke();
3751       }
3752       #endif //GLIBMM_EXCEPTIONS_ENABLED
3753     }
3754   }
3755
3756   BaseClassType *const base = static_cast<BaseClassType*>(
3757         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3758     );
3759
3760   // Call the original underlying C function:
3761   if(base && base->realize)
3762     (*base->realize)(self);
3763 }
3764 void Widget_Class::unrealize_callback(GtkWidget* self)
3765 {
3766   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3767       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3768
3769   // Non-gtkmmproc-generated custom classes implicitly call the default
3770   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3771   // generated classes can use this optimisation, which avoids the unnecessary
3772   // parameter conversions if there is no possibility of the virtual function
3773   // being overridden:
3774   if(obj_base && obj_base->is_derived_())
3775   {
3776     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3777     if(obj) // This can be NULL during destruction.
3778     {
3779       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3780       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3781       {
3782       #endif //GLIBMM_EXCEPTIONS_ENABLED
3783         // Call the virtual member method, which derived classes might override.
3784         obj->on_unrealize();
3785         return;
3786       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3787       }
3788       catch(...)
3789       {
3790         Glib::exception_handlers_invoke();
3791       }
3792       #endif //GLIBMM_EXCEPTIONS_ENABLED
3793     }
3794   }
3795
3796   BaseClassType *const base = static_cast<BaseClassType*>(
3797         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3798     );
3799
3800   // Call the original underlying C function:
3801   if(base && base->unrealize)
3802     (*base->unrealize)(self);
3803 }
3804 void Widget_Class::size_request_callback(GtkWidget* self, GtkRequisition* p0)
3805 {
3806   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3807       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3808
3809   // Non-gtkmmproc-generated custom classes implicitly call the default
3810   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3811   // generated classes can use this optimisation, which avoids the unnecessary
3812   // parameter conversions if there is no possibility of the virtual function
3813   // being overridden:
3814   if(obj_base && obj_base->is_derived_())
3815   {
3816     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3817     if(obj) // This can be NULL during destruction.
3818     {
3819       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3820       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3821       {
3822       #endif //GLIBMM_EXCEPTIONS_ENABLED
3823         // Call the virtual member method, which derived classes might override.
3824         obj->on_size_request((Requisition*)(p0)
3825 );
3826         return;
3827       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3828       }
3829       catch(...)
3830       {
3831         Glib::exception_handlers_invoke();
3832       }
3833       #endif //GLIBMM_EXCEPTIONS_ENABLED
3834     }
3835   }
3836
3837   BaseClassType *const base = static_cast<BaseClassType*>(
3838         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3839     );
3840
3841   // Call the original underlying C function:
3842   if(base && base->size_request)
3843     (*base->size_request)(self, p0);
3844 }
3845 void Widget_Class::size_allocate_callback(GtkWidget* self, GtkAllocation* p0)
3846 {
3847   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3848       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3849
3850   // Non-gtkmmproc-generated custom classes implicitly call the default
3851   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3852   // generated classes can use this optimisation, which avoids the unnecessary
3853   // parameter conversions if there is no possibility of the virtual function
3854   // being overridden:
3855   if(obj_base && obj_base->is_derived_())
3856   {
3857     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3858     if(obj) // This can be NULL during destruction.
3859     {
3860       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3861       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3862       {
3863       #endif //GLIBMM_EXCEPTIONS_ENABLED
3864         // Call the virtual member method, which derived classes might override.
3865         obj->on_size_allocate((Allocation&)(Glib::wrap(p0))
3866 );
3867         return;
3868       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3869       }
3870       catch(...)
3871       {
3872         Glib::exception_handlers_invoke();
3873       }
3874       #endif //GLIBMM_EXCEPTIONS_ENABLED
3875     }
3876   }
3877
3878   BaseClassType *const base = static_cast<BaseClassType*>(
3879         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3880     );
3881
3882   // Call the original underlying C function:
3883   if(base && base->size_allocate)
3884     (*base->size_allocate)(self, p0);
3885 }
3886 void Widget_Class::state_changed_callback(GtkWidget* self, GtkStateType p0)
3887 {
3888   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3889       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3890
3891   // Non-gtkmmproc-generated custom classes implicitly call the default
3892   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3893   // generated classes can use this optimisation, which avoids the unnecessary
3894   // parameter conversions if there is no possibility of the virtual function
3895   // being overridden:
3896   if(obj_base && obj_base->is_derived_())
3897   {
3898     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3899     if(obj) // This can be NULL during destruction.
3900     {
3901       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3902       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3903       {
3904       #endif //GLIBMM_EXCEPTIONS_ENABLED
3905         // Call the virtual member method, which derived classes might override.
3906         obj->on_state_changed(((Gtk::StateType)(p0))
3907 );
3908         return;
3909       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3910       }
3911       catch(...)
3912       {
3913         Glib::exception_handlers_invoke();
3914       }
3915       #endif //GLIBMM_EXCEPTIONS_ENABLED
3916     }
3917   }
3918
3919   BaseClassType *const base = static_cast<BaseClassType*>(
3920         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3921     );
3922
3923   // Call the original underlying C function:
3924   if(base && base->state_changed)
3925     (*base->state_changed)(self, p0);
3926 }
3927 void Widget_Class::parent_set_callback(GtkWidget* self, GtkWidget* p0)
3928 {
3929   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3930       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3931
3932   // Non-gtkmmproc-generated custom classes implicitly call the default
3933   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3934   // generated classes can use this optimisation, which avoids the unnecessary
3935   // parameter conversions if there is no possibility of the virtual function
3936   // being overridden:
3937   if(obj_base && obj_base->is_derived_())
3938   {
3939     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3940     if(obj) // This can be NULL during destruction.
3941     {
3942       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3943       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3944       {
3945       #endif //GLIBMM_EXCEPTIONS_ENABLED
3946         // Call the virtual member method, which derived classes might override.
3947         obj->on_parent_changed(Glib::wrap(p0)
3948 );
3949         return;
3950       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3951       }
3952       catch(...)
3953       {
3954         Glib::exception_handlers_invoke();
3955       }
3956       #endif //GLIBMM_EXCEPTIONS_ENABLED
3957     }
3958   }
3959
3960   BaseClassType *const base = static_cast<BaseClassType*>(
3961         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
3962     );
3963
3964   // Call the original underlying C function:
3965   if(base && base->parent_set)
3966     (*base->parent_set)(self, p0);
3967 }
3968 void Widget_Class::hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0)
3969 {
3970   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
3971       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
3972
3973   // Non-gtkmmproc-generated custom classes implicitly call the default
3974   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
3975   // generated classes can use this optimisation, which avoids the unnecessary
3976   // parameter conversions if there is no possibility of the virtual function
3977   // being overridden:
3978   if(obj_base && obj_base->is_derived_())
3979   {
3980     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
3981     if(obj) // This can be NULL during destruction.
3982     {
3983       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3984       try // Trap C++ exceptions which would normally be lost because this is a C callback.
3985       {
3986       #endif //GLIBMM_EXCEPTIONS_ENABLED
3987         // Call the virtual member method, which derived classes might override.
3988         obj->on_hierarchy_changed(Glib::wrap(p0)
3989 );
3990         return;
3991       #ifdef GLIBMM_EXCEPTIONS_ENABLED
3992       }
3993       catch(...)
3994       {
3995         Glib::exception_handlers_invoke();
3996       }
3997       #endif //GLIBMM_EXCEPTIONS_ENABLED
3998     }
3999   }
4000
4001   BaseClassType *const base = static_cast<BaseClassType*>(
4002         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4003     );
4004
4005   // Call the original underlying C function:
4006   if(base && base->hierarchy_changed)
4007     (*base->hierarchy_changed)(self, p0);
4008 }
4009 void Widget_Class::style_set_callback(GtkWidget* self, GtkStyle* p0)
4010 {
4011   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4012       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4013
4014   // Non-gtkmmproc-generated custom classes implicitly call the default
4015   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4016   // generated classes can use this optimisation, which avoids the unnecessary
4017   // parameter conversions if there is no possibility of the virtual function
4018   // being overridden:
4019   if(obj_base && obj_base->is_derived_())
4020   {
4021     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4022     if(obj) // This can be NULL during destruction.
4023     {
4024       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4025       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4026       {
4027       #endif //GLIBMM_EXCEPTIONS_ENABLED
4028         // Call the virtual member method, which derived classes might override.
4029         obj->on_style_changed(Glib::wrap(p0, true)
4030 );
4031         return;
4032       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4033       }
4034       catch(...)
4035       {
4036         Glib::exception_handlers_invoke();
4037       }
4038       #endif //GLIBMM_EXCEPTIONS_ENABLED
4039     }
4040   }
4041
4042   BaseClassType *const base = static_cast<BaseClassType*>(
4043         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4044     );
4045
4046   // Call the original underlying C function:
4047   if(base && base->style_set)
4048     (*base->style_set)(self, p0);
4049 }
4050 void Widget_Class::direction_changed_callback(GtkWidget* self, GtkTextDirection p0)
4051 {
4052   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4053       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4054
4055   // Non-gtkmmproc-generated custom classes implicitly call the default
4056   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4057   // generated classes can use this optimisation, which avoids the unnecessary
4058   // parameter conversions if there is no possibility of the virtual function
4059   // being overridden:
4060   if(obj_base && obj_base->is_derived_())
4061   {
4062     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4063     if(obj) // This can be NULL during destruction.
4064     {
4065       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4066       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4067       {
4068       #endif //GLIBMM_EXCEPTIONS_ENABLED
4069         // Call the virtual member method, which derived classes might override.
4070         obj->on_direction_changed(((TextDirection)(p0))
4071 );
4072         return;
4073       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4074       }
4075       catch(...)
4076       {
4077         Glib::exception_handlers_invoke();
4078       }
4079       #endif //GLIBMM_EXCEPTIONS_ENABLED
4080     }
4081   }
4082
4083   BaseClassType *const base = static_cast<BaseClassType*>(
4084         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4085     );
4086
4087   // Call the original underlying C function:
4088   if(base && base->direction_changed)
4089     (*base->direction_changed)(self, p0);
4090 }
4091 void Widget_Class::grab_notify_callback(GtkWidget* self, gboolean p0)
4092 {
4093   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4094       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4095
4096   // Non-gtkmmproc-generated custom classes implicitly call the default
4097   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4098   // generated classes can use this optimisation, which avoids the unnecessary
4099   // parameter conversions if there is no possibility of the virtual function
4100   // being overridden:
4101   if(obj_base && obj_base->is_derived_())
4102   {
4103     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4104     if(obj) // This can be NULL during destruction.
4105     {
4106       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4107       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4108       {
4109       #endif //GLIBMM_EXCEPTIONS_ENABLED
4110         // Call the virtual member method, which derived classes might override.
4111         obj->on_grab_notify(p0
4112 );
4113         return;
4114       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4115       }
4116       catch(...)
4117       {
4118         Glib::exception_handlers_invoke();
4119       }
4120       #endif //GLIBMM_EXCEPTIONS_ENABLED
4121     }
4122   }
4123
4124   BaseClassType *const base = static_cast<BaseClassType*>(
4125         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4126     );
4127
4128   // Call the original underlying C function:
4129   if(base && base->grab_notify)
4130     (*base->grab_notify)(self, p0);
4131 }
4132 void Widget_Class::child_notify_callback(GtkWidget* self, GParamSpec* p0)
4133 {
4134   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4135       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4136
4137   // Non-gtkmmproc-generated custom classes implicitly call the default
4138   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4139   // generated classes can use this optimisation, which avoids the unnecessary
4140   // parameter conversions if there is no possibility of the virtual function
4141   // being overridden:
4142   if(obj_base && obj_base->is_derived_())
4143   {
4144     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4145     if(obj) // This can be NULL during destruction.
4146     {
4147       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4148       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4149       {
4150       #endif //GLIBMM_EXCEPTIONS_ENABLED
4151         // Call the virtual member method, which derived classes might override.
4152         obj->on_child_notify(p0);
4153         return;
4154       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4155       }
4156       catch(...)
4157       {
4158         Glib::exception_handlers_invoke();
4159       }
4160       #endif //GLIBMM_EXCEPTIONS_ENABLED
4161     }
4162   }
4163
4164   BaseClassType *const base = static_cast<BaseClassType*>(
4165         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4166     );
4167
4168   // Call the original underlying C function:
4169   if(base && base->child_notify)
4170     (*base->child_notify)(self, p0);
4171 }
4172 gboolean Widget_Class::mnemonic_activate_callback(GtkWidget* self, gboolean p0)
4173 {
4174   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4175       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4176
4177   // Non-gtkmmproc-generated custom classes implicitly call the default
4178   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4179   // generated classes can use this optimisation, which avoids the unnecessary
4180   // parameter conversions if there is no possibility of the virtual function
4181   // being overridden:
4182   if(obj_base && obj_base->is_derived_())
4183   {
4184     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4185     if(obj) // This can be NULL during destruction.
4186     {
4187       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4188       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4189       {
4190       #endif //GLIBMM_EXCEPTIONS_ENABLED
4191         // Call the virtual member method, which derived classes might override.
4192         return static_cast<int>(obj->on_mnemonic_activate(p0
4193 ));
4194       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4195       }
4196       catch(...)
4197       {
4198         Glib::exception_handlers_invoke();
4199       }
4200       #endif //GLIBMM_EXCEPTIONS_ENABLED
4201     }
4202   }
4203
4204   BaseClassType *const base = static_cast<BaseClassType*>(
4205         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4206     );
4207
4208   // Call the original underlying C function:
4209   if(base && base->mnemonic_activate)
4210     return (*base->mnemonic_activate)(self, p0);
4211
4212   typedef gboolean RType;
4213   return RType();
4214 }
4215 void Widget_Class::grab_focus_callback(GtkWidget* self)
4216 {
4217   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4218       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4219
4220   // Non-gtkmmproc-generated custom classes implicitly call the default
4221   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4222   // generated classes can use this optimisation, which avoids the unnecessary
4223   // parameter conversions if there is no possibility of the virtual function
4224   // being overridden:
4225   if(obj_base && obj_base->is_derived_())
4226   {
4227     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4228     if(obj) // This can be NULL during destruction.
4229     {
4230       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4231       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4232       {
4233       #endif //GLIBMM_EXCEPTIONS_ENABLED
4234         // Call the virtual member method, which derived classes might override.
4235         obj->on_grab_focus();
4236         return;
4237       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4238       }
4239       catch(...)
4240       {
4241         Glib::exception_handlers_invoke();
4242       }
4243       #endif //GLIBMM_EXCEPTIONS_ENABLED
4244     }
4245   }
4246
4247   BaseClassType *const base = static_cast<BaseClassType*>(
4248         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4249     );
4250
4251   // Call the original underlying C function:
4252   if(base && base->grab_focus)
4253     (*base->grab_focus)(self);
4254 }
4255 gboolean Widget_Class::focus_callback(GtkWidget* self, GtkDirectionType p0)
4256 {
4257   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4258       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4259
4260   // Non-gtkmmproc-generated custom classes implicitly call the default
4261   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4262   // generated classes can use this optimisation, which avoids the unnecessary
4263   // parameter conversions if there is no possibility of the virtual function
4264   // being overridden:
4265   if(obj_base && obj_base->is_derived_())
4266   {
4267     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4268     if(obj) // This can be NULL during destruction.
4269     {
4270       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4271       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4272       {
4273       #endif //GLIBMM_EXCEPTIONS_ENABLED
4274         // Call the virtual member method, which derived classes might override.
4275         return static_cast<int>(obj->on_focus(((DirectionType)(p0))
4276 ));
4277       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4278       }
4279       catch(...)
4280       {
4281         Glib::exception_handlers_invoke();
4282       }
4283       #endif //GLIBMM_EXCEPTIONS_ENABLED
4284     }
4285   }
4286
4287   BaseClassType *const base = static_cast<BaseClassType*>(
4288         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4289     );
4290
4291   // Call the original underlying C function:
4292   if(base && base->focus)
4293     return (*base->focus)(self, p0);
4294
4295   typedef gboolean RType;
4296   return RType();
4297 }
4298 gboolean Widget_Class::event_callback(GtkWidget* self, GdkEvent* p0)
4299 {
4300   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4301       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4302
4303   // Non-gtkmmproc-generated custom classes implicitly call the default
4304   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4305   // generated classes can use this optimisation, which avoids the unnecessary
4306   // parameter conversions if there is no possibility of the virtual function
4307   // being overridden:
4308   if(obj_base && obj_base->is_derived_())
4309   {
4310     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4311     if(obj) // This can be NULL during destruction.
4312     {
4313       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4314       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4315       {
4316       #endif //GLIBMM_EXCEPTIONS_ENABLED
4317         // Call the virtual member method, which derived classes might override.
4318         return static_cast<int>(obj->on_event(p0));
4319       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4320       }
4321       catch(...)
4322       {
4323         Glib::exception_handlers_invoke();
4324       }
4325       #endif //GLIBMM_EXCEPTIONS_ENABLED
4326     }
4327   }
4328
4329   BaseClassType *const base = static_cast<BaseClassType*>(
4330         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4331     );
4332
4333   // Call the original underlying C function:
4334   if(base && base->event)
4335     return (*base->event)(self, p0);
4336
4337   typedef gboolean RType;
4338   return RType();
4339 }
4340 gboolean Widget_Class::button_press_event_callback(GtkWidget* self, GdkEventButton* p0)
4341 {
4342   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4343       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4344
4345   // Non-gtkmmproc-generated custom classes implicitly call the default
4346   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4347   // generated classes can use this optimisation, which avoids the unnecessary
4348   // parameter conversions if there is no possibility of the virtual function
4349   // being overridden:
4350   if(obj_base && obj_base->is_derived_())
4351   {
4352     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4353     if(obj) // This can be NULL during destruction.
4354     {
4355       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4356       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4357       {
4358       #endif //GLIBMM_EXCEPTIONS_ENABLED
4359         // Call the virtual member method, which derived classes might override.
4360         return static_cast<int>(obj->on_button_press_event(p0));
4361       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4362       }
4363       catch(...)
4364       {
4365         Glib::exception_handlers_invoke();
4366       }
4367       #endif //GLIBMM_EXCEPTIONS_ENABLED
4368     }
4369   }
4370
4371   BaseClassType *const base = static_cast<BaseClassType*>(
4372         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4373     );
4374
4375   // Call the original underlying C function:
4376   if(base && base->button_press_event)
4377     return (*base->button_press_event)(self, p0);
4378
4379   typedef gboolean RType;
4380   return RType();
4381 }
4382 gboolean Widget_Class::button_release_event_callback(GtkWidget* self, GdkEventButton* p0)
4383 {
4384   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4385       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4386
4387   // Non-gtkmmproc-generated custom classes implicitly call the default
4388   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4389   // generated classes can use this optimisation, which avoids the unnecessary
4390   // parameter conversions if there is no possibility of the virtual function
4391   // being overridden:
4392   if(obj_base && obj_base->is_derived_())
4393   {
4394     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4395     if(obj) // This can be NULL during destruction.
4396     {
4397       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4398       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4399       {
4400       #endif //GLIBMM_EXCEPTIONS_ENABLED
4401         // Call the virtual member method, which derived classes might override.
4402         return static_cast<int>(obj->on_button_release_event(p0));
4403       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4404       }
4405       catch(...)
4406       {
4407         Glib::exception_handlers_invoke();
4408       }
4409       #endif //GLIBMM_EXCEPTIONS_ENABLED
4410     }
4411   }
4412
4413   BaseClassType *const base = static_cast<BaseClassType*>(
4414         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4415     );
4416
4417   // Call the original underlying C function:
4418   if(base && base->button_release_event)
4419     return (*base->button_release_event)(self, p0);
4420
4421   typedef gboolean RType;
4422   return RType();
4423 }
4424 gboolean Widget_Class::scroll_event_callback(GtkWidget* self, GdkEventScroll* p0)
4425 {
4426   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4427       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4428
4429   // Non-gtkmmproc-generated custom classes implicitly call the default
4430   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4431   // generated classes can use this optimisation, which avoids the unnecessary
4432   // parameter conversions if there is no possibility of the virtual function
4433   // being overridden:
4434   if(obj_base && obj_base->is_derived_())
4435   {
4436     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4437     if(obj) // This can be NULL during destruction.
4438     {
4439       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4440       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4441       {
4442       #endif //GLIBMM_EXCEPTIONS_ENABLED
4443         // Call the virtual member method, which derived classes might override.
4444         return static_cast<int>(obj->on_scroll_event(p0));
4445       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4446       }
4447       catch(...)
4448       {
4449         Glib::exception_handlers_invoke();
4450       }
4451       #endif //GLIBMM_EXCEPTIONS_ENABLED
4452     }
4453   }
4454
4455   BaseClassType *const base = static_cast<BaseClassType*>(
4456         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4457     );
4458
4459   // Call the original underlying C function:
4460   if(base && base->scroll_event)
4461     return (*base->scroll_event)(self, p0);
4462
4463   typedef gboolean RType;
4464   return RType();
4465 }
4466 gboolean Widget_Class::motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0)
4467 {
4468   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4469       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4470
4471   // Non-gtkmmproc-generated custom classes implicitly call the default
4472   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4473   // generated classes can use this optimisation, which avoids the unnecessary
4474   // parameter conversions if there is no possibility of the virtual function
4475   // being overridden:
4476   if(obj_base && obj_base->is_derived_())
4477   {
4478     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4479     if(obj) // This can be NULL during destruction.
4480     {
4481       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4482       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4483       {
4484       #endif //GLIBMM_EXCEPTIONS_ENABLED
4485         // Call the virtual member method, which derived classes might override.
4486         return static_cast<int>(obj->on_motion_notify_event(p0));
4487       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4488       }
4489       catch(...)
4490       {
4491         Glib::exception_handlers_invoke();
4492       }
4493       #endif //GLIBMM_EXCEPTIONS_ENABLED
4494     }
4495   }
4496
4497   BaseClassType *const base = static_cast<BaseClassType*>(
4498         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4499     );
4500
4501   // Call the original underlying C function:
4502   if(base && base->motion_notify_event)
4503     return (*base->motion_notify_event)(self, p0);
4504
4505   typedef gboolean RType;
4506   return RType();
4507 }
4508 gboolean Widget_Class::delete_event_callback(GtkWidget* self, GdkEventAny* p0)
4509 {
4510   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4511       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4512
4513   // Non-gtkmmproc-generated custom classes implicitly call the default
4514   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4515   // generated classes can use this optimisation, which avoids the unnecessary
4516   // parameter conversions if there is no possibility of the virtual function
4517   // being overridden:
4518   if(obj_base && obj_base->is_derived_())
4519   {
4520     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4521     if(obj) // This can be NULL during destruction.
4522     {
4523       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4524       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4525       {
4526       #endif //GLIBMM_EXCEPTIONS_ENABLED
4527         // Call the virtual member method, which derived classes might override.
4528         return static_cast<int>(obj->on_delete_event(p0));
4529       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4530       }
4531       catch(...)
4532       {
4533         Glib::exception_handlers_invoke();
4534       }
4535       #endif //GLIBMM_EXCEPTIONS_ENABLED
4536     }
4537   }
4538
4539   BaseClassType *const base = static_cast<BaseClassType*>(
4540         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4541     );
4542
4543   // Call the original underlying C function:
4544   if(base && base->delete_event)
4545     return (*base->delete_event)(self, p0);
4546
4547   typedef gboolean RType;
4548   return RType();
4549 }
4550 gboolean Widget_Class::expose_event_callback(GtkWidget* self, GdkEventExpose* p0)
4551 {
4552   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4553       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4554
4555   // Non-gtkmmproc-generated custom classes implicitly call the default
4556   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4557   // generated classes can use this optimisation, which avoids the unnecessary
4558   // parameter conversions if there is no possibility of the virtual function
4559   // being overridden:
4560   if(obj_base && obj_base->is_derived_())
4561   {
4562     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4563     if(obj) // This can be NULL during destruction.
4564     {
4565       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4566       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4567       {
4568       #endif //GLIBMM_EXCEPTIONS_ENABLED
4569         // Call the virtual member method, which derived classes might override.
4570         return static_cast<int>(obj->on_expose_event(p0));
4571       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4572       }
4573       catch(...)
4574       {
4575         Glib::exception_handlers_invoke();
4576       }
4577       #endif //GLIBMM_EXCEPTIONS_ENABLED
4578     }
4579   }
4580
4581   BaseClassType *const base = static_cast<BaseClassType*>(
4582         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4583     );
4584
4585   // Call the original underlying C function:
4586   if(base && base->expose_event)
4587     return (*base->expose_event)(self, p0);
4588
4589   typedef gboolean RType;
4590   return RType();
4591 }
4592 gboolean Widget_Class::key_press_event_callback(GtkWidget* self, GdkEventKey* p0)
4593 {
4594   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4595       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4596
4597   // Non-gtkmmproc-generated custom classes implicitly call the default
4598   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4599   // generated classes can use this optimisation, which avoids the unnecessary
4600   // parameter conversions if there is no possibility of the virtual function
4601   // being overridden:
4602   if(obj_base && obj_base->is_derived_())
4603   {
4604     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4605     if(obj) // This can be NULL during destruction.
4606     {
4607       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4608       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4609       {
4610       #endif //GLIBMM_EXCEPTIONS_ENABLED
4611         // Call the virtual member method, which derived classes might override.
4612         return static_cast<int>(obj->on_key_press_event(p0));
4613       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4614       }
4615       catch(...)
4616       {
4617         Glib::exception_handlers_invoke();
4618       }
4619       #endif //GLIBMM_EXCEPTIONS_ENABLED
4620     }
4621   }
4622
4623   BaseClassType *const base = static_cast<BaseClassType*>(
4624         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4625     );
4626
4627   // Call the original underlying C function:
4628   if(base && base->key_press_event)
4629     return (*base->key_press_event)(self, p0);
4630
4631   typedef gboolean RType;
4632   return RType();
4633 }
4634 gboolean Widget_Class::key_release_event_callback(GtkWidget* self, GdkEventKey* p0)
4635 {
4636   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4637       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4638
4639   // Non-gtkmmproc-generated custom classes implicitly call the default
4640   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4641   // generated classes can use this optimisation, which avoids the unnecessary
4642   // parameter conversions if there is no possibility of the virtual function
4643   // being overridden:
4644   if(obj_base && obj_base->is_derived_())
4645   {
4646     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4647     if(obj) // This can be NULL during destruction.
4648     {
4649       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4650       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4651       {
4652       #endif //GLIBMM_EXCEPTIONS_ENABLED
4653         // Call the virtual member method, which derived classes might override.
4654         return static_cast<int>(obj->on_key_release_event(p0));
4655       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4656       }
4657       catch(...)
4658       {
4659         Glib::exception_handlers_invoke();
4660       }
4661       #endif //GLIBMM_EXCEPTIONS_ENABLED
4662     }
4663   }
4664
4665   BaseClassType *const base = static_cast<BaseClassType*>(
4666         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4667     );
4668
4669   // Call the original underlying C function:
4670   if(base && base->key_release_event)
4671     return (*base->key_release_event)(self, p0);
4672
4673   typedef gboolean RType;
4674   return RType();
4675 }
4676 gboolean Widget_Class::enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0)
4677 {
4678   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4679       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4680
4681   // Non-gtkmmproc-generated custom classes implicitly call the default
4682   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4683   // generated classes can use this optimisation, which avoids the unnecessary
4684   // parameter conversions if there is no possibility of the virtual function
4685   // being overridden:
4686   if(obj_base && obj_base->is_derived_())
4687   {
4688     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4689     if(obj) // This can be NULL during destruction.
4690     {
4691       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4692       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4693       {
4694       #endif //GLIBMM_EXCEPTIONS_ENABLED
4695         // Call the virtual member method, which derived classes might override.
4696         return static_cast<int>(obj->on_enter_notify_event(p0));
4697       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4698       }
4699       catch(...)
4700       {
4701         Glib::exception_handlers_invoke();
4702       }
4703       #endif //GLIBMM_EXCEPTIONS_ENABLED
4704     }
4705   }
4706
4707   BaseClassType *const base = static_cast<BaseClassType*>(
4708         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4709     );
4710
4711   // Call the original underlying C function:
4712   if(base && base->enter_notify_event)
4713     return (*base->enter_notify_event)(self, p0);
4714
4715   typedef gboolean RType;
4716   return RType();
4717 }
4718 gboolean Widget_Class::leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0)
4719 {
4720   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4721       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4722
4723   // Non-gtkmmproc-generated custom classes implicitly call the default
4724   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4725   // generated classes can use this optimisation, which avoids the unnecessary
4726   // parameter conversions if there is no possibility of the virtual function
4727   // being overridden:
4728   if(obj_base && obj_base->is_derived_())
4729   {
4730     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4731     if(obj) // This can be NULL during destruction.
4732     {
4733       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4734       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4735       {
4736       #endif //GLIBMM_EXCEPTIONS_ENABLED
4737         // Call the virtual member method, which derived classes might override.
4738         return static_cast<int>(obj->on_leave_notify_event(p0));
4739       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4740       }
4741       catch(...)
4742       {
4743         Glib::exception_handlers_invoke();
4744       }
4745       #endif //GLIBMM_EXCEPTIONS_ENABLED
4746     }
4747   }
4748
4749   BaseClassType *const base = static_cast<BaseClassType*>(
4750         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4751     );
4752
4753   // Call the original underlying C function:
4754   if(base && base->leave_notify_event)
4755     return (*base->leave_notify_event)(self, p0);
4756
4757   typedef gboolean RType;
4758   return RType();
4759 }
4760 gboolean Widget_Class::configure_event_callback(GtkWidget* self, GdkEventConfigure* p0)
4761 {
4762   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4763       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4764
4765   // Non-gtkmmproc-generated custom classes implicitly call the default
4766   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4767   // generated classes can use this optimisation, which avoids the unnecessary
4768   // parameter conversions if there is no possibility of the virtual function
4769   // being overridden:
4770   if(obj_base && obj_base->is_derived_())
4771   {
4772     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4773     if(obj) // This can be NULL during destruction.
4774     {
4775       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4776       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4777       {
4778       #endif //GLIBMM_EXCEPTIONS_ENABLED
4779         // Call the virtual member method, which derived classes might override.
4780         return static_cast<int>(obj->on_configure_event(p0));
4781       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4782       }
4783       catch(...)
4784       {
4785         Glib::exception_handlers_invoke();
4786       }
4787       #endif //GLIBMM_EXCEPTIONS_ENABLED
4788     }
4789   }
4790
4791   BaseClassType *const base = static_cast<BaseClassType*>(
4792         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4793     );
4794
4795   // Call the original underlying C function:
4796   if(base && base->configure_event)
4797     return (*base->configure_event)(self, p0);
4798
4799   typedef gboolean RType;
4800   return RType();
4801 }
4802 gboolean Widget_Class::focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0)
4803 {
4804   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4805       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4806
4807   // Non-gtkmmproc-generated custom classes implicitly call the default
4808   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4809   // generated classes can use this optimisation, which avoids the unnecessary
4810   // parameter conversions if there is no possibility of the virtual function
4811   // being overridden:
4812   if(obj_base && obj_base->is_derived_())
4813   {
4814     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4815     if(obj) // This can be NULL during destruction.
4816     {
4817       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4818       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4819       {
4820       #endif //GLIBMM_EXCEPTIONS_ENABLED
4821         // Call the virtual member method, which derived classes might override.
4822         return static_cast<int>(obj->on_focus_in_event(p0));
4823       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4824       }
4825       catch(...)
4826       {
4827         Glib::exception_handlers_invoke();
4828       }
4829       #endif //GLIBMM_EXCEPTIONS_ENABLED
4830     }
4831   }
4832
4833   BaseClassType *const base = static_cast<BaseClassType*>(
4834         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4835     );
4836
4837   // Call the original underlying C function:
4838   if(base && base->focus_in_event)
4839     return (*base->focus_in_event)(self, p0);
4840
4841   typedef gboolean RType;
4842   return RType();
4843 }
4844 gboolean Widget_Class::focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0)
4845 {
4846   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4847       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4848
4849   // Non-gtkmmproc-generated custom classes implicitly call the default
4850   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4851   // generated classes can use this optimisation, which avoids the unnecessary
4852   // parameter conversions if there is no possibility of the virtual function
4853   // being overridden:
4854   if(obj_base && obj_base->is_derived_())
4855   {
4856     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4857     if(obj) // This can be NULL during destruction.
4858     {
4859       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4860       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4861       {
4862       #endif //GLIBMM_EXCEPTIONS_ENABLED
4863         // Call the virtual member method, which derived classes might override.
4864         return static_cast<int>(obj->on_focus_out_event(p0));
4865       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4866       }
4867       catch(...)
4868       {
4869         Glib::exception_handlers_invoke();
4870       }
4871       #endif //GLIBMM_EXCEPTIONS_ENABLED
4872     }
4873   }
4874
4875   BaseClassType *const base = static_cast<BaseClassType*>(
4876         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4877     );
4878
4879   // Call the original underlying C function:
4880   if(base && base->focus_out_event)
4881     return (*base->focus_out_event)(self, p0);
4882
4883   typedef gboolean RType;
4884   return RType();
4885 }
4886 gboolean Widget_Class::map_event_callback(GtkWidget* self, GdkEventAny* p0)
4887 {
4888   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4889       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4890
4891   // Non-gtkmmproc-generated custom classes implicitly call the default
4892   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4893   // generated classes can use this optimisation, which avoids the unnecessary
4894   // parameter conversions if there is no possibility of the virtual function
4895   // being overridden:
4896   if(obj_base && obj_base->is_derived_())
4897   {
4898     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4899     if(obj) // This can be NULL during destruction.
4900     {
4901       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4902       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4903       {
4904       #endif //GLIBMM_EXCEPTIONS_ENABLED
4905         // Call the virtual member method, which derived classes might override.
4906         return static_cast<int>(obj->on_map_event(p0));
4907       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4908       }
4909       catch(...)
4910       {
4911         Glib::exception_handlers_invoke();
4912       }
4913       #endif //GLIBMM_EXCEPTIONS_ENABLED
4914     }
4915   }
4916
4917   BaseClassType *const base = static_cast<BaseClassType*>(
4918         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4919     );
4920
4921   // Call the original underlying C function:
4922   if(base && base->map_event)
4923     return (*base->map_event)(self, p0);
4924
4925   typedef gboolean RType;
4926   return RType();
4927 }
4928 gboolean Widget_Class::unmap_event_callback(GtkWidget* self, GdkEventAny* p0)
4929 {
4930   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4931       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4932
4933   // Non-gtkmmproc-generated custom classes implicitly call the default
4934   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4935   // generated classes can use this optimisation, which avoids the unnecessary
4936   // parameter conversions if there is no possibility of the virtual function
4937   // being overridden:
4938   if(obj_base && obj_base->is_derived_())
4939   {
4940     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4941     if(obj) // This can be NULL during destruction.
4942     {
4943       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4944       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4945       {
4946       #endif //GLIBMM_EXCEPTIONS_ENABLED
4947         // Call the virtual member method, which derived classes might override.
4948         return static_cast<int>(obj->on_unmap_event(p0));
4949       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4950       }
4951       catch(...)
4952       {
4953         Glib::exception_handlers_invoke();
4954       }
4955       #endif //GLIBMM_EXCEPTIONS_ENABLED
4956     }
4957   }
4958
4959   BaseClassType *const base = static_cast<BaseClassType*>(
4960         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
4961     );
4962
4963   // Call the original underlying C function:
4964   if(base && base->unmap_event)
4965     return (*base->unmap_event)(self, p0);
4966
4967   typedef gboolean RType;
4968   return RType();
4969 }
4970 gboolean Widget_Class::property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0)
4971 {
4972   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
4973       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
4974
4975   // Non-gtkmmproc-generated custom classes implicitly call the default
4976   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
4977   // generated classes can use this optimisation, which avoids the unnecessary
4978   // parameter conversions if there is no possibility of the virtual function
4979   // being overridden:
4980   if(obj_base && obj_base->is_derived_())
4981   {
4982     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
4983     if(obj) // This can be NULL during destruction.
4984     {
4985       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4986       try // Trap C++ exceptions which would normally be lost because this is a C callback.
4987       {
4988       #endif //GLIBMM_EXCEPTIONS_ENABLED
4989         // Call the virtual member method, which derived classes might override.
4990         return static_cast<int>(obj->on_property_notify_event(p0));
4991       #ifdef GLIBMM_EXCEPTIONS_ENABLED
4992       }
4993       catch(...)
4994       {
4995         Glib::exception_handlers_invoke();
4996       }
4997       #endif //GLIBMM_EXCEPTIONS_ENABLED
4998     }
4999   }
5000
5001   BaseClassType *const base = static_cast<BaseClassType*>(
5002         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5003     );
5004
5005   // Call the original underlying C function:
5006   if(base && base->property_notify_event)
5007     return (*base->property_notify_event)(self, p0);
5008
5009   typedef gboolean RType;
5010   return RType();
5011 }
5012 gboolean Widget_Class::selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0)
5013 {
5014   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5015       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5016
5017   // Non-gtkmmproc-generated custom classes implicitly call the default
5018   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5019   // generated classes can use this optimisation, which avoids the unnecessary
5020   // parameter conversions if there is no possibility of the virtual function
5021   // being overridden:
5022   if(obj_base && obj_base->is_derived_())
5023   {
5024     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5025     if(obj) // This can be NULL during destruction.
5026     {
5027       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5028       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5029       {
5030       #endif //GLIBMM_EXCEPTIONS_ENABLED
5031         // Call the virtual member method, which derived classes might override.
5032         return static_cast<int>(obj->on_selection_clear_event(p0));
5033       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5034       }
5035       catch(...)
5036       {
5037         Glib::exception_handlers_invoke();
5038       }
5039       #endif //GLIBMM_EXCEPTIONS_ENABLED
5040     }
5041   }
5042
5043   BaseClassType *const base = static_cast<BaseClassType*>(
5044         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5045     );
5046
5047   // Call the original underlying C function:
5048   if(base && base->selection_clear_event)
5049     return (*base->selection_clear_event)(self, p0);
5050
5051   typedef gboolean RType;
5052   return RType();
5053 }
5054 gboolean Widget_Class::selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0)
5055 {
5056   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5057       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5058
5059   // Non-gtkmmproc-generated custom classes implicitly call the default
5060   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5061   // generated classes can use this optimisation, which avoids the unnecessary
5062   // parameter conversions if there is no possibility of the virtual function
5063   // being overridden:
5064   if(obj_base && obj_base->is_derived_())
5065   {
5066     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5067     if(obj) // This can be NULL during destruction.
5068     {
5069       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5070       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5071       {
5072       #endif //GLIBMM_EXCEPTIONS_ENABLED
5073         // Call the virtual member method, which derived classes might override.
5074         return static_cast<int>(obj->on_selection_request_event(p0));
5075       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5076       }
5077       catch(...)
5078       {
5079         Glib::exception_handlers_invoke();
5080       }
5081       #endif //GLIBMM_EXCEPTIONS_ENABLED
5082     }
5083   }
5084
5085   BaseClassType *const base = static_cast<BaseClassType*>(
5086         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5087     );
5088
5089   // Call the original underlying C function:
5090   if(base && base->selection_request_event)
5091     return (*base->selection_request_event)(self, p0);
5092
5093   typedef gboolean RType;
5094   return RType();
5095 }
5096 gboolean Widget_Class::selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0)
5097 {
5098   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5099       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5100
5101   // Non-gtkmmproc-generated custom classes implicitly call the default
5102   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5103   // generated classes can use this optimisation, which avoids the unnecessary
5104   // parameter conversions if there is no possibility of the virtual function
5105   // being overridden:
5106   if(obj_base && obj_base->is_derived_())
5107   {
5108     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5109     if(obj) // This can be NULL during destruction.
5110     {
5111       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5112       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5113       {
5114       #endif //GLIBMM_EXCEPTIONS_ENABLED
5115         // Call the virtual member method, which derived classes might override.
5116         return static_cast<int>(obj->on_selection_notify_event(p0));
5117       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5118       }
5119       catch(...)
5120       {
5121         Glib::exception_handlers_invoke();
5122       }
5123       #endif //GLIBMM_EXCEPTIONS_ENABLED
5124     }
5125   }
5126
5127   BaseClassType *const base = static_cast<BaseClassType*>(
5128         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5129     );
5130
5131   // Call the original underlying C function:
5132   if(base && base->selection_notify_event)
5133     return (*base->selection_notify_event)(self, p0);
5134
5135   typedef gboolean RType;
5136   return RType();
5137 }
5138 gboolean Widget_Class::proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0)
5139 {
5140   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5141       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5142
5143   // Non-gtkmmproc-generated custom classes implicitly call the default
5144   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5145   // generated classes can use this optimisation, which avoids the unnecessary
5146   // parameter conversions if there is no possibility of the virtual function
5147   // being overridden:
5148   if(obj_base && obj_base->is_derived_())
5149   {
5150     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5151     if(obj) // This can be NULL during destruction.
5152     {
5153       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5154       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5155       {
5156       #endif //GLIBMM_EXCEPTIONS_ENABLED
5157         // Call the virtual member method, which derived classes might override.
5158         return static_cast<int>(obj->on_proximity_in_event(p0));
5159       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5160       }
5161       catch(...)
5162       {
5163         Glib::exception_handlers_invoke();
5164       }
5165       #endif //GLIBMM_EXCEPTIONS_ENABLED
5166     }
5167   }
5168
5169   BaseClassType *const base = static_cast<BaseClassType*>(
5170         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5171     );
5172
5173   // Call the original underlying C function:
5174   if(base && base->proximity_in_event)
5175     return (*base->proximity_in_event)(self, p0);
5176
5177   typedef gboolean RType;
5178   return RType();
5179 }
5180 gboolean Widget_Class::proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0)
5181 {
5182   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5183       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5184
5185   // Non-gtkmmproc-generated custom classes implicitly call the default
5186   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5187   // generated classes can use this optimisation, which avoids the unnecessary
5188   // parameter conversions if there is no possibility of the virtual function
5189   // being overridden:
5190   if(obj_base && obj_base->is_derived_())
5191   {
5192     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5193     if(obj) // This can be NULL during destruction.
5194     {
5195       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5196       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5197       {
5198       #endif //GLIBMM_EXCEPTIONS_ENABLED
5199         // Call the virtual member method, which derived classes might override.
5200         return static_cast<int>(obj->on_proximity_out_event(p0));
5201       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5202       }
5203       catch(...)
5204       {
5205         Glib::exception_handlers_invoke();
5206       }
5207       #endif //GLIBMM_EXCEPTIONS_ENABLED
5208     }
5209   }
5210
5211   BaseClassType *const base = static_cast<BaseClassType*>(
5212         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5213     );
5214
5215   // Call the original underlying C function:
5216   if(base && base->proximity_out_event)
5217     return (*base->proximity_out_event)(self, p0);
5218
5219   typedef gboolean RType;
5220   return RType();
5221 }
5222 gboolean Widget_Class::visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0)
5223 {
5224   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5225       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5226
5227   // Non-gtkmmproc-generated custom classes implicitly call the default
5228   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5229   // generated classes can use this optimisation, which avoids the unnecessary
5230   // parameter conversions if there is no possibility of the virtual function
5231   // being overridden:
5232   if(obj_base && obj_base->is_derived_())
5233   {
5234     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5235     if(obj) // This can be NULL during destruction.
5236     {
5237       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5238       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5239       {
5240       #endif //GLIBMM_EXCEPTIONS_ENABLED
5241         // Call the virtual member method, which derived classes might override.
5242         return static_cast<int>(obj->on_visibility_notify_event(p0));
5243       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5244       }
5245       catch(...)
5246       {
5247         Glib::exception_handlers_invoke();
5248       }
5249       #endif //GLIBMM_EXCEPTIONS_ENABLED
5250     }
5251   }
5252
5253   BaseClassType *const base = static_cast<BaseClassType*>(
5254         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5255     );
5256
5257   // Call the original underlying C function:
5258   if(base && base->visibility_notify_event)
5259     return (*base->visibility_notify_event)(self, p0);
5260
5261   typedef gboolean RType;
5262   return RType();
5263 }
5264 gboolean Widget_Class::client_event_callback(GtkWidget* self, GdkEventClient* p0)
5265 {
5266   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5267       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5268
5269   // Non-gtkmmproc-generated custom classes implicitly call the default
5270   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5271   // generated classes can use this optimisation, which avoids the unnecessary
5272   // parameter conversions if there is no possibility of the virtual function
5273   // being overridden:
5274   if(obj_base && obj_base->is_derived_())
5275   {
5276     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5277     if(obj) // This can be NULL during destruction.
5278     {
5279       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5280       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5281       {
5282       #endif //GLIBMM_EXCEPTIONS_ENABLED
5283         // Call the virtual member method, which derived classes might override.
5284         return static_cast<int>(obj->on_client_event(p0));
5285       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5286       }
5287       catch(...)
5288       {
5289         Glib::exception_handlers_invoke();
5290       }
5291       #endif //GLIBMM_EXCEPTIONS_ENABLED
5292     }
5293   }
5294
5295   BaseClassType *const base = static_cast<BaseClassType*>(
5296         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5297     );
5298
5299   // Call the original underlying C function:
5300   if(base && base->client_event)
5301     return (*base->client_event)(self, p0);
5302
5303   typedef gboolean RType;
5304   return RType();
5305 }
5306 gboolean Widget_Class::no_expose_event_callback(GtkWidget* self, GdkEventAny* p0)
5307 {
5308   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5309       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5310
5311   // Non-gtkmmproc-generated custom classes implicitly call the default
5312   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5313   // generated classes can use this optimisation, which avoids the unnecessary
5314   // parameter conversions if there is no possibility of the virtual function
5315   // being overridden:
5316   if(obj_base && obj_base->is_derived_())
5317   {
5318     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5319     if(obj) // This can be NULL during destruction.
5320     {
5321       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5322       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5323       {
5324       #endif //GLIBMM_EXCEPTIONS_ENABLED
5325         // Call the virtual member method, which derived classes might override.
5326         return static_cast<int>(obj->on_no_expose_event(p0));
5327       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5328       }
5329       catch(...)
5330       {
5331         Glib::exception_handlers_invoke();
5332       }
5333       #endif //GLIBMM_EXCEPTIONS_ENABLED
5334     }
5335   }
5336
5337   BaseClassType *const base = static_cast<BaseClassType*>(
5338         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5339     );
5340
5341   // Call the original underlying C function:
5342   if(base && base->no_expose_event)
5343     return (*base->no_expose_event)(self, p0);
5344
5345   typedef gboolean RType;
5346   return RType();
5347 }
5348 gboolean Widget_Class::window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0)
5349 {
5350   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5351       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5352
5353   // Non-gtkmmproc-generated custom classes implicitly call the default
5354   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5355   // generated classes can use this optimisation, which avoids the unnecessary
5356   // parameter conversions if there is no possibility of the virtual function
5357   // being overridden:
5358   if(obj_base && obj_base->is_derived_())
5359   {
5360     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5361     if(obj) // This can be NULL during destruction.
5362     {
5363       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5364       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5365       {
5366       #endif //GLIBMM_EXCEPTIONS_ENABLED
5367         // Call the virtual member method, which derived classes might override.
5368         return static_cast<int>(obj->on_window_state_event(p0));
5369       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5370       }
5371       catch(...)
5372       {
5373         Glib::exception_handlers_invoke();
5374       }
5375       #endif //GLIBMM_EXCEPTIONS_ENABLED
5376     }
5377   }
5378
5379   BaseClassType *const base = static_cast<BaseClassType*>(
5380         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5381     );
5382
5383   // Call the original underlying C function:
5384   if(base && base->window_state_event)
5385     return (*base->window_state_event)(self, p0);
5386
5387   typedef gboolean RType;
5388   return RType();
5389 }
5390 void Widget_Class::selection_received_callback(GtkWidget* self, GtkSelectionData* p0, guint p1)
5391 {
5392   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5393       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5394
5395   // Non-gtkmmproc-generated custom classes implicitly call the default
5396   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5397   // generated classes can use this optimisation, which avoids the unnecessary
5398   // parameter conversions if there is no possibility of the virtual function
5399   // being overridden:
5400   if(obj_base && obj_base->is_derived_())
5401   {
5402     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5403     if(obj) // This can be NULL during destruction.
5404     {
5405       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5406       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5407       {
5408       #endif //GLIBMM_EXCEPTIONS_ENABLED
5409         // Call the virtual member method, which derived classes might override.
5410         obj->on_selection_received(SelectionData_WithoutOwnership(p0)
5411 , p1);
5412         return;
5413       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5414       }
5415       catch(...)
5416       {
5417         Glib::exception_handlers_invoke();
5418       }
5419       #endif //GLIBMM_EXCEPTIONS_ENABLED
5420     }
5421   }
5422
5423   BaseClassType *const base = static_cast<BaseClassType*>(
5424         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5425     );
5426
5427   // Call the original underlying C function:
5428   if(base && base->selection_received)
5429     (*base->selection_received)(self, p0, p1);
5430 }
5431 void Widget_Class::drag_begin_callback(GtkWidget* self, GdkDragContext* p0)
5432 {
5433   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5434       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5435
5436   // Non-gtkmmproc-generated custom classes implicitly call the default
5437   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5438   // generated classes can use this optimisation, which avoids the unnecessary
5439   // parameter conversions if there is no possibility of the virtual function
5440   // being overridden:
5441   if(obj_base && obj_base->is_derived_())
5442   {
5443     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5444     if(obj) // This can be NULL during destruction.
5445     {
5446       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5447       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5448       {
5449       #endif //GLIBMM_EXCEPTIONS_ENABLED
5450         // Call the virtual member method, which derived classes might override.
5451         obj->on_drag_begin(Glib::wrap(p0, true)
5452 );
5453         return;
5454       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5455       }
5456       catch(...)
5457       {
5458         Glib::exception_handlers_invoke();
5459       }
5460       #endif //GLIBMM_EXCEPTIONS_ENABLED
5461     }
5462   }
5463
5464   BaseClassType *const base = static_cast<BaseClassType*>(
5465         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5466     );
5467
5468   // Call the original underlying C function:
5469   if(base && base->drag_begin)
5470     (*base->drag_begin)(self, p0);
5471 }
5472 void Widget_Class::drag_end_callback(GtkWidget* self, GdkDragContext* p0)
5473 {
5474   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5475       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5476
5477   // Non-gtkmmproc-generated custom classes implicitly call the default
5478   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5479   // generated classes can use this optimisation, which avoids the unnecessary
5480   // parameter conversions if there is no possibility of the virtual function
5481   // being overridden:
5482   if(obj_base && obj_base->is_derived_())
5483   {
5484     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5485     if(obj) // This can be NULL during destruction.
5486     {
5487       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5488       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5489       {
5490       #endif //GLIBMM_EXCEPTIONS_ENABLED
5491         // Call the virtual member method, which derived classes might override.
5492         obj->on_drag_end(Glib::wrap(p0, true)
5493 );
5494         return;
5495       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5496       }
5497       catch(...)
5498       {
5499         Glib::exception_handlers_invoke();
5500       }
5501       #endif //GLIBMM_EXCEPTIONS_ENABLED
5502     }
5503   }
5504
5505   BaseClassType *const base = static_cast<BaseClassType*>(
5506         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5507     );
5508
5509   // Call the original underlying C function:
5510   if(base && base->drag_end)
5511     (*base->drag_end)(self, p0);
5512 }
5513 void Widget_Class::drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0)
5514 {
5515   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5516       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5517
5518   // Non-gtkmmproc-generated custom classes implicitly call the default
5519   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5520   // generated classes can use this optimisation, which avoids the unnecessary
5521   // parameter conversions if there is no possibility of the virtual function
5522   // being overridden:
5523   if(obj_base && obj_base->is_derived_())
5524   {
5525     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5526     if(obj) // This can be NULL during destruction.
5527     {
5528       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5529       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5530       {
5531       #endif //GLIBMM_EXCEPTIONS_ENABLED
5532         // Call the virtual member method, which derived classes might override.
5533         obj->on_drag_data_delete(Glib::wrap(p0, true)
5534 );
5535         return;
5536       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5537       }
5538       catch(...)
5539       {
5540         Glib::exception_handlers_invoke();
5541       }
5542       #endif //GLIBMM_EXCEPTIONS_ENABLED
5543     }
5544   }
5545
5546   BaseClassType *const base = static_cast<BaseClassType*>(
5547         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5548     );
5549
5550   // Call the original underlying C function:
5551   if(base && base->drag_data_delete)
5552     (*base->drag_data_delete)(self, p0);
5553 }
5554 void Widget_Class::drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guint p1)
5555 {
5556   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5557       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5558
5559   // Non-gtkmmproc-generated custom classes implicitly call the default
5560   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5561   // generated classes can use this optimisation, which avoids the unnecessary
5562   // parameter conversions if there is no possibility of the virtual function
5563   // being overridden:
5564   if(obj_base && obj_base->is_derived_())
5565   {
5566     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5567     if(obj) // This can be NULL during destruction.
5568     {
5569       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5570       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5571       {
5572       #endif //GLIBMM_EXCEPTIONS_ENABLED
5573         // Call the virtual member method, which derived classes might override.
5574         obj->on_drag_leave(Glib::wrap(p0, true)
5575 , p1);
5576         return;
5577       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5578       }
5579       catch(...)
5580       {
5581         Glib::exception_handlers_invoke();
5582       }
5583       #endif //GLIBMM_EXCEPTIONS_ENABLED
5584     }
5585   }
5586
5587   BaseClassType *const base = static_cast<BaseClassType*>(
5588         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5589     );
5590
5591   // Call the original underlying C function:
5592   if(base && base->drag_leave)
5593     (*base->drag_leave)(self, p0, p1);
5594 }
5595 gboolean Widget_Class::drag_motion_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3)
5596 {
5597   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5598       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5599
5600   // Non-gtkmmproc-generated custom classes implicitly call the default
5601   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5602   // generated classes can use this optimisation, which avoids the unnecessary
5603   // parameter conversions if there is no possibility of the virtual function
5604   // being overridden:
5605   if(obj_base && obj_base->is_derived_())
5606   {
5607     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5608     if(obj) // This can be NULL during destruction.
5609     {
5610       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5611       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5612       {
5613       #endif //GLIBMM_EXCEPTIONS_ENABLED
5614         // Call the virtual member method, which derived classes might override.
5615         return static_cast<int>(obj->on_drag_motion(Glib::wrap(p0, true)
5616 , p1
5617 , p2
5618 , p3));
5619       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5620       }
5621       catch(...)
5622       {
5623         Glib::exception_handlers_invoke();
5624       }
5625       #endif //GLIBMM_EXCEPTIONS_ENABLED
5626     }
5627   }
5628
5629   BaseClassType *const base = static_cast<BaseClassType*>(
5630         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5631     );
5632
5633   // Call the original underlying C function:
5634   if(base && base->drag_motion)
5635     return (*base->drag_motion)(self, p0, p1, p2, p3);
5636
5637   typedef gboolean RType;
5638   return RType();
5639 }
5640 gboolean Widget_Class::drag_drop_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3)
5641 {
5642   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5643       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5644
5645   // Non-gtkmmproc-generated custom classes implicitly call the default
5646   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5647   // generated classes can use this optimisation, which avoids the unnecessary
5648   // parameter conversions if there is no possibility of the virtual function
5649   // being overridden:
5650   if(obj_base && obj_base->is_derived_())
5651   {
5652     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5653     if(obj) // This can be NULL during destruction.
5654     {
5655       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5656       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5657       {
5658       #endif //GLIBMM_EXCEPTIONS_ENABLED
5659         // Call the virtual member method, which derived classes might override.
5660         return static_cast<int>(obj->on_drag_drop(Glib::wrap(p0, true)
5661 , p1
5662 , p2
5663 , p3));
5664       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5665       }
5666       catch(...)
5667       {
5668         Glib::exception_handlers_invoke();
5669       }
5670       #endif //GLIBMM_EXCEPTIONS_ENABLED
5671     }
5672   }
5673
5674   BaseClassType *const base = static_cast<BaseClassType*>(
5675         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5676     );
5677
5678   // Call the original underlying C function:
5679   if(base && base->drag_drop)
5680     return (*base->drag_drop)(self, p0, p1, p2, p3);
5681
5682   typedef gboolean RType;
5683   return RType();
5684 }
5685 void Widget_Class::drag_data_received_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, GtkSelectionData* p3, guint p4, guint p5)
5686 {
5687   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5688       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5689
5690   // Non-gtkmmproc-generated custom classes implicitly call the default
5691   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5692   // generated classes can use this optimisation, which avoids the unnecessary
5693   // parameter conversions if there is no possibility of the virtual function
5694   // being overridden:
5695   if(obj_base && obj_base->is_derived_())
5696   {
5697     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5698     if(obj) // This can be NULL during destruction.
5699     {
5700       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5701       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5702       {
5703       #endif //GLIBMM_EXCEPTIONS_ENABLED
5704         // Call the virtual member method, which derived classes might override.
5705         obj->on_drag_data_received(Glib::wrap(p0, true)
5706 , p1
5707 , p2
5708 , SelectionData_WithoutOwnership(p3)
5709 , p4, p5);
5710         return;
5711       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5712       }
5713       catch(...)
5714       {
5715         Glib::exception_handlers_invoke();
5716       }
5717       #endif //GLIBMM_EXCEPTIONS_ENABLED
5718     }
5719   }
5720
5721   BaseClassType *const base = static_cast<BaseClassType*>(
5722         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5723     );
5724
5725   // Call the original underlying C function:
5726   if(base && base->drag_data_received)
5727     (*base->drag_data_received)(self, p0, p1, p2, p3, p4, p5);
5728 }
5729 #ifdef GTKMM_ATKMM_ENABLED
5730 AtkObject* Widget_Class::get_accessible_callback(GtkWidget* self)
5731 {
5732   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5733       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5734
5735   // Non-gtkmmproc-generated custom classes implicitly call the default
5736   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5737   // generated classes can use this optimisation, which avoids the unnecessary
5738   // parameter conversions if there is no possibility of the virtual function
5739   // being overridden:
5740   if(obj_base && obj_base->is_derived_())
5741   {
5742     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5743     if(obj) // This can be NULL during destruction.
5744     {
5745       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5746       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5747       {
5748       #endif //GLIBMM_EXCEPTIONS_ENABLED
5749         // Call the virtual member method, which derived classes might override.
5750         return Glib::unwrap(obj->on_get_accessible());
5751       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5752       }
5753       catch(...)
5754       {
5755         Glib::exception_handlers_invoke();
5756       }
5757       #endif //GLIBMM_EXCEPTIONS_ENABLED
5758     }
5759   }
5760
5761   BaseClassType *const base = static_cast<BaseClassType*>(
5762         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5763     );
5764
5765   // Call the original underlying C function:
5766   if(base && base->get_accessible)
5767     return (*base->get_accessible)(self);
5768
5769   typedef AtkObject* RType;
5770   return RType();
5771 }
5772 #endif // GTKMM_ATKMM_ENABLED
5773 void Widget_Class::screen_changed_callback(GtkWidget* self, GdkScreen* p0)
5774 {
5775   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
5776       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
5777
5778   // Non-gtkmmproc-generated custom classes implicitly call the default
5779   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
5780   // generated classes can use this optimisation, which avoids the unnecessary
5781   // parameter conversions if there is no possibility of the virtual function
5782   // being overridden:
5783   if(obj_base && obj_base->is_derived_())
5784   {
5785     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
5786     if(obj) // This can be NULL during destruction.
5787     {
5788       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5789       try // Trap C++ exceptions which would normally be lost because this is a C callback.
5790       {
5791       #endif //GLIBMM_EXCEPTIONS_ENABLED
5792         // Call the virtual member method, which derived classes might override.
5793         obj->on_screen_changed(Glib::wrap(p0, true)
5794 );
5795         return;
5796       #ifdef GLIBMM_EXCEPTIONS_ENABLED
5797       }
5798       catch(...)
5799       {
5800         Glib::exception_handlers_invoke();
5801       }
5802       #endif //GLIBMM_EXCEPTIONS_ENABLED
5803     }
5804   }
5805
5806   BaseClassType *const base = static_cast<BaseClassType*>(
5807         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
5808     );
5809
5810   // Call the original underlying C function:
5811   if(base && base->screen_changed)
5812     (*base->screen_changed)(self, p0);
5813 }
5814 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
5815
5816
5817 Glib::ObjectBase* Widget_Class::wrap_new(GObject* o)
5818 {
5819   return manage(new Widget((GtkWidget*)(o)));
5820
5821 }
5822
5823
5824 /* The implementation: */
5825
5826 Widget::Widget(const Glib::ConstructParams& construct_params)
5827 :
5828   Gtk::Object(construct_params)
5829 {
5830   }
5831
5832 Widget::Widget(GtkWidget* castitem)
5833 :
5834   Gtk::Object((GtkObject*)(castitem))
5835 {
5836   }
5837
5838 Widget::CppClassType Widget::widget_class_; // initialize static member
5839
5840 GType Widget::get_type()
5841 {
5842   return widget_class_.init().get_type();
5843 }
5844
5845 GType Widget::get_base_type()
5846 {
5847   return gtk_widget_get_type();
5848 }
5849
5850
5851 bool Widget::set_scroll_adjustments(Adjustment& hadjustment, Adjustment& vadjustment)
5852 {
5853   return gtk_widget_set_scroll_adjustments(gobj(), (hadjustment).gobj(), (vadjustment).gobj());
5854 }
5855
5856 void Widget::show()
5857 {
5858 gtk_widget_show(gobj());
5859 }
5860
5861 void Widget::show_now()
5862 {
5863 gtk_widget_show_now(gobj());
5864 }
5865
5866 void Widget::hide()
5867 {
5868 gtk_widget_hide(gobj());
5869 }
5870
5871 void Widget::show_all()
5872 {
5873 gtk_widget_show_all(gobj());
5874 }
5875
5876 void Widget::hide_all()
5877 {
5878 gtk_widget_hide_all(gobj());
5879 }
5880
5881 void Widget::queue_draw()
5882 {
5883 gtk_widget_queue_draw(gobj());
5884 }
5885
5886 void Widget::queue_draw_area(int x, int y, int width, int height)
5887 {
5888 gtk_widget_queue_draw_area(gobj(), x, y, width, height);
5889 }
5890
5891 void Widget::queue_resize()
5892 {
5893 gtk_widget_queue_resize(gobj());
5894 }
5895
5896 #ifndef GTKMM_DISABLE_DEPRECATED
5897
5898 void Widget::size_request(const Requisition& requisition)
5899 {
5900 gtk_widget_size_request(gobj(), (GtkRequisition*)(&requisition));
5901 }
5902
5903 #endif // GTKMM_DISABLE_DEPRECATED
5904
5905 void Widget::size_allocate(const Allocation& allocation)
5906 {
5907 gtk_widget_size_allocate(gobj(), (GtkAllocation*)(allocation.gobj()));
5908 }
5909
5910 void Widget::add_accelerator(const Glib::ustring& accel_signal, const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods, AccelFlags accel_flags)
5911 {
5912 gtk_widget_add_accelerator(gobj(), accel_signal.c_str(), Glib::unwrap(accel_group), accel_key, ((GdkModifierType)(accel_mods)), ((GtkAccelFlags)(accel_flags)));
5913 }
5914
5915 bool Widget::remove_accelerator(const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods)
5916 {
5917   return gtk_widget_remove_accelerator(gobj(), Glib::unwrap(accel_group), accel_key, ((GdkModifierType)(accel_mods)));
5918 }
5919
5920 void Widget::set_accel_path(const Glib::ustring& accel_path, const Glib::RefPtr<AccelGroup>& accel_group)
5921 {
5922 gtk_widget_set_accel_path(gobj(), accel_path.c_str(), Glib::unwrap(accel_group));
5923 }
5924
5925 bool Widget::mnemonic_activate(bool group_cycling)
5926 {
5927   return gtk_widget_mnemonic_activate(gobj(), static_cast<int>(group_cycling));
5928 }
5929
5930 bool Widget::event(GdkEvent* event)
5931 {
5932   return gtk_widget_event(gobj(), event);
5933 }
5934
5935 int Widget::send_expose(GdkEvent* event)
5936 {
5937   return gtk_widget_send_expose(gobj(), event);
5938 }
5939
5940 bool Widget::activate()
5941 {
5942   return gtk_widget_activate(gobj());
5943 }
5944
5945 void Widget::reparent(Widget & new_parent)
5946 {
5947 gtk_widget_reparent(gobj(), (new_parent).gobj());
5948 }
5949
5950 bool Widget::intersect(const Gdk::Rectangle& area, Gdk::Rectangle& intersection) const
5951 {
5952   return gtk_widget_intersect(const_cast<GtkWidget*>(gobj()), const_cast<GdkRectangle*>(area.gobj()), (intersection).gobj());
5953 }
5954
5955 Gdk::Region Widget::region_intersect(const Gdk::Region& region) const
5956 {
5957   return Gdk::Region(gtk_widget_region_intersect(const_cast<GtkWidget*>(gobj()), const_cast<GdkRegion*>((region).gobj())));
5958 }
5959
5960 void Widget::freeze_child_notify()
5961 {
5962 gtk_widget_freeze_child_notify(gobj());
5963 }
5964
5965 void Widget::child_notify(const Glib::ustring& child_property)
5966 {
5967 gtk_widget_child_notify(gobj(), child_property.c_str());
5968 }
5969
5970 void Widget::thaw_child_notify()
5971 {
5972 gtk_widget_thaw_child_notify(gobj());
5973 }
5974
5975 bool Widget::is_focus() const
5976 {
5977   return gtk_widget_is_focus(const_cast<GtkWidget*>(gobj()));
5978 }
5979
5980 void Widget::grab_focus()
5981 {
5982 gtk_widget_grab_focus(gobj());
5983 }
5984
5985 void Widget::grab_default()
5986 {
5987 gtk_widget_grab_default(gobj());
5988 }
5989
5990 void Widget::set_name(const Glib::ustring& name)
5991 {
5992 gtk_widget_set_name(gobj(), name.c_str());
5993 }
5994
5995 Glib::ustring Widget::get_name() const
5996 {
5997   return Glib::convert_const_gchar_ptr_to_ustring(gtk_widget_get_name(const_cast<GtkWidget*>(gobj())));
5998 }
5999
6000 void Widget::set_state(Gtk::StateType state)
6001 {
6002 gtk_widget_set_state(gobj(), ((GtkStateType)(state)));
6003 }
6004
6005 void Widget::set_sensitive(bool sensitive)
6006 {
6007 gtk_widget_set_sensitive(gobj(), static_cast<int>(sensitive));
6008 }
6009
6010 void Widget::set_app_paintable(bool app_paintable)
6011 {
6012 gtk_widget_set_app_paintable(gobj(), static_cast<int>(app_paintable));
6013 }
6014
6015 void Widget::set_double_buffered(bool double_buffered)
6016 {
6017 gtk_widget_set_double_buffered(gobj(), static_cast<int>(double_buffered));
6018 }
6019
6020 void Widget::set_redraw_on_allocate(bool redraw_on_allocate)
6021 {
6022 gtk_widget_set_redraw_on_allocate(gobj(), static_cast<int>(redraw_on_allocate));
6023 }
6024
6025 void Widget::set_child_visible(bool is_visible)
6026 {
6027 gtk_widget_set_child_visible(gobj(), static_cast<int>(is_visible));
6028 }
6029
6030 bool Widget::get_child_visible() const
6031 {
6032   return gtk_widget_get_child_visible(const_cast<GtkWidget*>(gobj()));
6033 }
6034
6035 Container* Widget::get_parent()
6036 {
6037   return Glib::wrap((GtkContainer*)(gtk_widget_get_parent(gobj())));
6038 }
6039
6040 const Container* Widget::get_parent() const
6041 {
6042   return const_cast<Widget*>(this)->get_parent();
6043 }
6044
6045 Glib::RefPtr<Gdk::Window> Widget::get_parent_window()
6046 {
6047
6048   Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_parent_window(gobj())));
6049   if(retvalue)
6050     retvalue->reference(); //The function does not do a ref for us.
6051   return retvalue;
6052
6053 }
6054
6055 Glib::RefPtr<const Gdk::Window> Widget::get_parent_window() const
6056 {
6057   return const_cast<Widget*>(this)->get_parent_window();
6058 }
6059
6060 void Widget::set_parent_window(const Glib::RefPtr<const Gdk::Window>& parent_window)
6061 {
6062 gtk_widget_set_parent_window(gobj(), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(parent_window)));
6063 }
6064
6065 bool Widget::child_focus(DirectionType direction)
6066 {
6067   return gtk_widget_child_focus(gobj(), ((GtkDirectionType)(direction)));
6068 }
6069
6070 bool Widget::keynav_failed(DirectionType direction)
6071 {
6072   return gtk_widget_keynav_failed(gobj(), ((GtkDirectionType)(direction)));
6073 }
6074
6075 void Widget::error_bell()
6076 {
6077 gtk_widget_error_bell(gobj());
6078 }
6079
6080 void Widget::set_size_request(int width, int height)
6081 {
6082 gtk_widget_set_size_request(gobj(), width, height);
6083 }
6084
6085 void Widget::get_size_request(int& width, int& height) const
6086 {
6087 gtk_widget_get_size_request(const_cast<GtkWidget*>(gobj()), &width, &height);
6088 }
6089
6090 void Widget::set_events(Gdk::EventMask events)
6091 {
6092 gtk_widget_set_events(gobj(), events);
6093 }
6094
6095 void Widget::add_events(Gdk::EventMask events)
6096 {
6097 gtk_widget_add_events(gobj(), events);
6098 }
6099
6100 void Widget::set_extension_events(Gdk::ExtensionMode mode)
6101 {
6102 gtk_widget_set_extension_events(gobj(), ((GdkExtensionMode)(mode)));
6103 }
6104
6105 Gdk::ExtensionMode Widget::get_extension_events() const
6106 {
6107   return ((Gdk::ExtensionMode)(gtk_widget_get_extension_events(const_cast<GtkWidget*>(gobj()))));
6108 }
6109
6110 Container* Widget::get_toplevel()
6111 {
6112   return Glib::wrap((GtkContainer*)(gtk_widget_get_toplevel(gobj())));
6113 }
6114
6115 const Container* Widget::get_toplevel() const
6116 {
6117   return const_cast<Widget*>(this)->get_toplevel();
6118 }
6119
6120 Widget* Widget::get_ancestor(GType widget_type)
6121 {
6122   return Glib::wrap(gtk_widget_get_ancestor(gobj(), widget_type));
6123 }
6124
6125 const Widget* Widget::get_ancestor(GType widget_type) const
6126 {
6127   return const_cast<Widget*>(this)->get_ancestor(widget_type);
6128 }
6129
6130 Glib::RefPtr<Gdk::Colormap> Widget::get_colormap()
6131 {
6132
6133   Glib::RefPtr<Gdk::Colormap> retvalue = Glib::wrap(gtk_widget_get_colormap(gobj()));
6134   if(retvalue)
6135     retvalue->reference(); //The function does not do a ref for us.
6136   return retvalue;
6137
6138 }
6139
6140 Glib::RefPtr<Gdk::Visual> Widget::get_visual()
6141 {
6142
6143   Glib::RefPtr<Gdk::Visual> retvalue = Glib::wrap(gtk_widget_get_visual(gobj()));
6144   if(retvalue)
6145     retvalue->reference(); //The function does not do a ref for us.
6146   return retvalue;
6147
6148 }
6149
6150 Glib::RefPtr<Gdk::Screen> Widget::get_screen()
6151 {
6152
6153   Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_widget_get_screen(gobj()));
6154   if(retvalue)
6155     retvalue->reference(); //The function does not do a ref for us.
6156   return retvalue;
6157
6158 }
6159
6160 Glib::RefPtr<const Gdk::Screen> Widget::get_screen() const
6161 {
6162   return const_cast<Widget*>(this)->get_screen();
6163 }
6164
6165 bool Widget::has_screen() const
6166 {
6167   return gtk_widget_has_screen(const_cast<GtkWidget*>(gobj()));
6168 }
6169
6170 Glib::RefPtr<Gdk::Display> Widget::get_display()
6171 {
6172
6173   Glib::RefPtr<Gdk::Display> retvalue = Glib::wrap(gtk_widget_get_display(gobj()));
6174   if(retvalue)
6175     retvalue->reference(); //The function does not do a ref for us.
6176   return retvalue;
6177
6178 }
6179
6180 Glib::RefPtr<const Gdk::Display> Widget::get_display() const
6181 {
6182   return const_cast<Widget*>(this)->get_display();
6183 }
6184
6185 Glib::RefPtr<Gdk::Window> Widget::get_root_window()
6186 {
6187
6188   Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_root_window(gobj())));
6189   if(retvalue)
6190     retvalue->reference(); //The function does not do a ref for us.
6191   return retvalue;
6192
6193 }
6194
6195 Glib::RefPtr<const Gdk::Window> Widget::get_root_window() const
6196 {
6197   return const_cast<Widget*>(this)->get_root_window();
6198 }
6199
6200 Glib::RefPtr<Settings> Widget::get_settings()
6201 {
6202
6203   Glib::RefPtr<Settings> retvalue = Glib::wrap(gtk_widget_get_settings(gobj()));
6204   if(retvalue)
6205     retvalue->reference(); //The function does not do a ref for us.
6206   return retvalue;
6207
6208 }
6209
6210 Glib::RefPtr<Clipboard> Widget::get_clipboard(const Glib::ustring& selection)
6211 {
6212
6213   Glib::RefPtr<Clipboard> retvalue = Glib::wrap(gtk_widget_get_clipboard(gobj(), Gdk::AtomString::to_c_type(selection)));
6214   if(retvalue)
6215     retvalue->reference(); //The function does not do a ref for us.
6216   return retvalue;
6217
6218 }
6219
6220 Glib::RefPtr<const Clipboard> Widget::get_clipboard(const Glib::ustring& selection) const
6221 {
6222   return const_cast<Widget*>(this)->get_clipboard(selection);
6223 }
6224
6225 #ifdef GTKMM_ATKMM_ENABLED
6226 Glib::RefPtr<Atk::Object> Widget::get_accessible()
6227 {
6228
6229   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(gtk_widget_get_accessible(gobj()));
6230   if(retvalue)
6231     retvalue->reference(); //The function does not do a ref for us.
6232   return retvalue;
6233
6234 }
6235
6236
6237 #endif // GTKMM_ATKMM_ENABLED
6238 void Widget::set_colormap(const Glib::RefPtr<const Gdk::Colormap> & colormap)
6239 {
6240 gtk_widget_set_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
6241 }
6242
6243 Gdk::EventMask Widget::get_events() const
6244 {
6245   return static_cast<Gdk::EventMask>(gtk_widget_get_events(const_cast<GtkWidget*>(gobj())));
6246 }
6247
6248 void Widget::get_pointer(int & x, int & y) const
6249 {
6250 gtk_widget_get_pointer(const_cast<GtkWidget*>(gobj()), &x, &y);
6251 }
6252
6253 bool Widget::is_ancestor(Widget & ancestor) const
6254 {
6255   return gtk_widget_is_ancestor(const_cast<GtkWidget*>(gobj()), (ancestor).gobj());
6256 }
6257
6258 bool Widget::translate_coordinates(Widget& dest_widget, int src_x, int src_y, int& dest_x, int& dest_y)
6259 {
6260   return gtk_widget_translate_coordinates(gobj(), (dest_widget).gobj(), src_x, src_y, &dest_x, &dest_y);
6261 }
6262
6263 void Widget::set_style(const Glib::RefPtr<Style>& style)
6264 {
6265 gtk_widget_set_style(gobj(), Glib::unwrap(style));
6266 }
6267
6268 void Widget::ensure_style()
6269 {
6270 gtk_widget_ensure_style(gobj());
6271 }
6272
6273 Glib::RefPtr<Style> Widget::get_style()
6274 {
6275
6276   Glib::RefPtr<Style> retvalue = Glib::wrap(gtk_widget_get_style(gobj()));
6277   if(retvalue)
6278     retvalue->reference(); //The function does not do a ref for us.
6279   return retvalue;
6280
6281 }
6282
6283 Glib::RefPtr<const Style> Widget::get_style() const
6284 {
6285   return const_cast<Widget*>(this)->get_style();
6286 }
6287
6288 void Widget::modify_style(const Glib::RefPtr<RcStyle>& style)
6289 {
6290 gtk_widget_modify_style(gobj(), Glib::unwrap(style));
6291 }
6292
6293 Glib::RefPtr<RcStyle> Widget::get_modifier_style()
6294 {
6295
6296   Glib::RefPtr<RcStyle> retvalue = Glib::wrap(gtk_widget_get_modifier_style(gobj()));
6297   if(retvalue)
6298     retvalue->reference(); //The function does not do a ref for us.
6299   return retvalue;
6300
6301 }
6302
6303 Glib::RefPtr<const RcStyle> Widget::get_modifier_style() const
6304 {
6305   return const_cast<Widget*>(this)->get_modifier_style();
6306 }
6307
6308 void Widget::modify_fg(StateType state, const Gdk::Color& color)
6309 {
6310 gtk_widget_modify_fg(gobj(), ((GtkStateType)(state)), (color).gobj());
6311 }
6312
6313 void Widget::modify_bg(StateType state, const Gdk::Color& color)
6314 {
6315 gtk_widget_modify_bg(gobj(), ((GtkStateType)(state)), (color).gobj());
6316 }
6317
6318 void Widget::modify_text(StateType state, const Gdk::Color& color)
6319 {
6320 gtk_widget_modify_text(gobj(), ((GtkStateType)(state)), (color).gobj());
6321 }
6322
6323 void Widget::modify_base(StateType state, const Gdk::Color& color)
6324 {
6325 gtk_widget_modify_base(gobj(), ((GtkStateType)(state)), (color).gobj());
6326 }
6327
6328 void Widget::modify_cursor(const Gdk::Color& primary, const Gdk::Color& secondary)
6329 {
6330 gtk_widget_modify_cursor(gobj(), (primary).gobj(), (secondary).gobj());
6331 }
6332
6333 void Widget::modify_font(const Pango::FontDescription& font_desc)
6334 {
6335 gtk_widget_modify_font(gobj(), const_cast<PangoFontDescription*>((font_desc).gobj()));
6336 }
6337
6338 Glib::RefPtr<Pango::Context> Widget::create_pango_context()
6339 {
6340   return Glib::wrap(gtk_widget_create_pango_context(gobj()));
6341 }
6342
6343 Glib::RefPtr<Pango::Context> Widget::get_pango_context()
6344 {
6345
6346   Glib::RefPtr<Pango::Context> retvalue = Glib::wrap(gtk_widget_get_pango_context(gobj()));
6347   if(retvalue)
6348     retvalue->reference(); //The function does not do a ref for us.
6349   return retvalue;
6350
6351 }
6352
6353 Glib::RefPtr<Pango::Layout> Widget::create_pango_layout(const Glib::ustring& text)
6354 {
6355   return Glib::wrap(gtk_widget_create_pango_layout(gobj(), text.c_str()));
6356 }
6357
6358 Glib::RefPtr<Gdk::Pixbuf> Widget::render_icon(const StockID& stock_id, IconSize size, const Glib::ustring& detail)
6359 {
6360   return Glib::wrap(gtk_widget_render_icon(gobj(), (stock_id).get_c_str(), static_cast<GtkIconSize>(int(size)), detail.c_str()));
6361 }
6362
6363 void Widget::set_composite_name(const Glib::ustring& name)
6364 {
6365 gtk_widget_set_composite_name(gobj(), name.c_str());
6366 }
6367
6368 Glib::ustring Widget::get_composite_name() const
6369 {
6370   return Glib::convert_return_gchar_ptr_to_ustring(gtk_widget_get_composite_name(const_cast<GtkWidget*>(gobj())));
6371 }
6372
6373 void Widget::reset_rc_styles()
6374 {
6375 gtk_widget_reset_rc_styles(gobj());
6376 }
6377
6378 void Widget::push_colormap(const Glib::RefPtr<const Gdk::Colormap>& cmap)
6379 {
6380 gtk_widget_push_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(cmap)));
6381 }
6382
6383
6384 void Widget::pop_colormap()
6385 {
6386 gtk_widget_pop_colormap();
6387 }
6388
6389
6390 void Widget::push_composite_child()
6391 {
6392 gtk_widget_push_composite_child();
6393 }
6394
6395
6396 void Widget::pop_composite_child()
6397 {
6398 gtk_widget_pop_composite_child();
6399 }
6400
6401
6402 void Widget::set_default_colormap(const Glib::RefPtr<const Gdk::Colormap>& colormap)
6403 {
6404 gtk_widget_set_default_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
6405 }
6406
6407
6408 Glib::RefPtr<Style> Widget::get_default_style()
6409 {
6410
6411   Glib::RefPtr<Style> retvalue = Glib::wrap(gtk_widget_get_default_style());
6412
6413   if(retvalue)
6414     retvalue->reference(); //The function does not do a ref for us.
6415   return retvalue;
6416 }
6417
6418
6419 Glib::RefPtr<Gdk::Colormap> Widget::get_default_colormap()
6420 {
6421
6422   Glib::RefPtr<Gdk::Colormap> retvalue = Glib::wrap(gtk_widget_get_default_colormap());
6423
6424   if(retvalue)
6425     retvalue->reference(); //The function does not do a ref for us.
6426   return retvalue;
6427 }
6428
6429
6430 Glib::RefPtr<Gdk::Visual> Widget::get_default_visual()
6431 {
6432
6433   Glib::RefPtr<Gdk::Visual> retvalue = Glib::wrap(gtk_widget_get_default_visual());
6434
6435   if(retvalue)
6436     retvalue->reference(); //The function does not do a ref for us.
6437   return retvalue;
6438 }
6439
6440
6441 void Widget::set_direction(TextDirection dir)
6442 {
6443 gtk_widget_set_direction(gobj(), ((GtkTextDirection)(dir)));
6444 }
6445
6446 TextDirection Widget::get_direction()
6447 {
6448   return ((TextDirection)(gtk_widget_get_direction(gobj())));
6449 }
6450
6451 void Widget::set_default_direction(TextDirection dir)
6452 {
6453 gtk_widget_set_default_direction(((GtkTextDirection)(dir)));
6454 }
6455
6456
6457 TextDirection Widget::get_default_direction()
6458 {
6459   return ((TextDirection)(gtk_widget_get_default_direction()));
6460 }
6461
6462
6463 void Widget::shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y)
6464 {
6465 gtk_widget_shape_combine_mask(gobj(), const_cast<GdkBitmap*>(Glib::unwrap<Gdk::Bitmap>(shape_mask)), offset_x, offset_y);
6466 }
6467
6468 void Widget::input_shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y)
6469 {
6470 gtk_widget_input_shape_combine_mask(gobj(), const_cast<GdkBitmap*>(Glib::unwrap<Gdk::Bitmap>(shape_mask)), offset_x, offset_y);
6471 }
6472
6473 void Widget::reset_shapes()
6474 {
6475 gtk_widget_reset_shapes(gobj());
6476 }
6477
6478 Glib::ListHandle<Widget*> Widget::list_mnemonic_labels()
6479 {
6480   return Glib::ListHandle<Widget*>(gtk_widget_list_mnemonic_labels(gobj()), Glib::OWNERSHIP_SHALLOW);
6481 }
6482
6483 Glib::ListHandle<const Widget*> Widget::list_mnemonic_labels() const
6484 {
6485   return Glib::ListHandle<const Widget*>(gtk_widget_list_mnemonic_labels(const_cast<GtkWidget*>(gobj())), Glib::OWNERSHIP_SHALLOW);
6486 }
6487
6488 void Widget::add_mnemonic_label(Widget& label)
6489 {
6490 gtk_widget_add_mnemonic_label(gobj(), (label).gobj());
6491 }
6492
6493 void Widget::remove_mnemonic_label(Widget& label)
6494 {
6495 gtk_widget_remove_mnemonic_label(gobj(), (label).gobj());
6496 }
6497
6498 void Widget::drag_get_data(const Glib::RefPtr<Gdk::DragContext>& context, Glib::ustring& target, guint32 time)
6499 {
6500 gtk_drag_get_data(gobj(), Glib::unwrap(context), Gdk::AtomString::to_c_type(target), time);
6501 }
6502
6503 void Widget::drag_highlight()
6504 {
6505 gtk_drag_highlight(gobj());
6506 }
6507
6508 void Widget::drag_unhighlight()
6509 {
6510 gtk_drag_unhighlight(gobj());
6511 }
6512
6513 void Widget::drag_dest_set_proxy(const Glib::RefPtr<Gdk::Window>& proxy_window, Gdk::DragProtocol protocol, bool use_coordinates)
6514 {
6515 gtk_drag_dest_set_proxy(gobj(), Glib::unwrap(proxy_window), ((GdkDragProtocol)(protocol)), static_cast<int>(use_coordinates));
6516 }
6517
6518 void Widget::drag_dest_unset()
6519 {
6520 gtk_drag_dest_unset(gobj());
6521 }
6522
6523 Glib::ustring Widget::drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context, const Glib::RefPtr<TargetList>& target_list) const
6524 {
6525   return Gdk::AtomString::to_cpp_type(gtk_drag_dest_find_target(const_cast<GtkWidget*>(gobj()), Glib::unwrap(context), const_cast<GtkTargetList*>(Glib::unwrap(target_list))));
6526 }
6527
6528 Glib::RefPtr<TargetList> Widget::drag_dest_get_target_list()
6529 {
6530
6531   Glib::RefPtr<TargetList> retvalue = Glib::wrap(gtk_drag_dest_get_target_list(gobj()));
6532   if(retvalue)
6533     retvalue->reference(); //The function does not do a ref for us.
6534   return retvalue;
6535
6536 }
6537
6538 Glib::RefPtr<const TargetList> Widget::drag_dest_get_target_list() const
6539 {
6540   return const_cast<Widget*>(this)->drag_dest_get_target_list();
6541 }
6542
6543 void Widget::drag_dest_set_target_list(const Glib::RefPtr<TargetList>& target_list)
6544 {
6545 gtk_drag_dest_set_target_list(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(target_list)));
6546 }
6547
6548 void Widget::drag_dest_add_text_targets()
6549 {
6550 gtk_drag_dest_add_text_targets(gobj());
6551 }
6552
6553 void Widget::drag_dest_add_image_targets()
6554 {
6555 gtk_drag_dest_add_image_targets(gobj());
6556 }
6557
6558 void Widget::drag_dest_add_uri_targets()
6559 {
6560 gtk_drag_dest_add_uri_targets(gobj());
6561 }
6562
6563 void Widget::drag_source_unset()
6564 {
6565 gtk_drag_source_unset(gobj());
6566 }
6567
6568 void Widget::drag_source_set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
6569 {
6570 gtk_drag_source_set_icon(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask));
6571 }
6572
6573 void Widget::drag_source_set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
6574 {
6575 gtk_drag_source_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf));
6576 }
6577
6578 void Widget::drag_source_set_icon(const StockID& stock_id)
6579 {
6580 gtk_drag_source_set_icon_stock(gobj(), (stock_id).get_c_str());
6581 }
6582
6583 void Widget::drag_source_set_icon(const Glib::ustring& icon_name)
6584 {
6585 gtk_drag_source_set_icon_name(gobj(), icon_name.c_str());
6586 }
6587
6588 void Widget::drag_source_add_text_targets()
6589 {
6590 gtk_drag_source_add_text_targets(gobj());
6591 }
6592
6593 void Widget::drag_source_add_uri_targets()
6594 {
6595 gtk_drag_source_add_uri_targets(gobj());
6596 }
6597
6598 void Widget::drag_source_add_image_targets()
6599 {
6600 gtk_drag_source_add_image_targets(gobj());
6601 }
6602
6603 Glib::RefPtr<Gdk::DragContext> Widget::drag_begin(const Glib::RefPtr<TargetList>& targets, Gdk::DragAction actions, int button, GdkEvent* event)
6604 {
6605
6606   Glib::RefPtr<Gdk::DragContext> retvalue = Glib::wrap(gtk_drag_begin(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(targets)), ((GdkDragAction)(actions)), button, event), true);
6607   if(retvalue)
6608     retvalue->reference(); //The function does not do a ref for us.
6609   return retvalue;
6610
6611 }
6612
6613 bool Widget::drag_check_threshold(int start_x, int start_y, int current_x, int current_y)
6614 {
6615   return gtk_drag_check_threshold(gobj(), start_x, start_y, current_x, current_y);
6616 }
6617
6618 void Widget::queue_resize_no_redraw()
6619 {
6620 gtk_widget_queue_resize_no_redraw(gobj());
6621 }
6622
6623 bool Widget::get_no_show_all() const
6624 {
6625   return gtk_widget_get_no_show_all(const_cast<GtkWidget*>(gobj()));
6626 }
6627
6628 void Widget::set_no_show_all(bool no_show_all)
6629 {
6630 gtk_widget_set_no_show_all(gobj(), static_cast<int>(no_show_all));
6631 }
6632
6633 void Widget::set_parent(Widget& parent)
6634 {
6635 gtk_widget_set_parent(gobj(), (parent).gobj());
6636 }
6637
6638 void Widget::unparent()
6639 {
6640 gtk_widget_unparent(gobj());
6641 }
6642
6643 void Widget::map()
6644 {
6645 gtk_widget_map(gobj());
6646 }
6647
6648 void Widget::unmap()
6649 {
6650 gtk_widget_unmap(gobj());
6651 }
6652
6653 void Widget::set_tooltip_window(Window& widget)
6654 {
6655 gtk_widget_set_tooltip_window(gobj(), (widget).gobj());
6656 }
6657
6658 Window* Widget::get_tooltip_window()
6659 {
6660   return Glib::wrap(gtk_widget_get_tooltip_window(gobj()));
6661 }
6662
6663 void Widget::trigger_tooltip_query()
6664 {
6665 gtk_widget_trigger_tooltip_query(gobj());
6666 }
6667
6668 void Widget::set_tooltip_text(const Glib::ustring& text)
6669 {
6670 gtk_widget_set_tooltip_text(gobj(), text.c_str());
6671 }
6672
6673 Glib::ustring Widget::get_tooltip_text() const
6674 {
6675   return Glib::convert_return_gchar_ptr_to_ustring(gtk_widget_get_tooltip_text(const_cast<GtkWidget*>(gobj())));
6676 }
6677
6678 void Widget::set_tooltip_markup(const Glib::ustring& markup)
6679 {
6680 gtk_widget_set_tooltip_markup(gobj(), markup.c_str());
6681 }
6682
6683 Glib::ustring Widget::get_tooltip_markup() const
6684 {
6685   return Glib::convert_return_gchar_ptr_to_ustring(gtk_widget_get_tooltip_markup(const_cast<GtkWidget*>(gobj())));
6686 }
6687
6688 void Widget::set_has_tooltip(bool has_tooltip)
6689 {
6690 gtk_widget_set_has_tooltip(gobj(), static_cast<int>(has_tooltip));
6691 }
6692
6693 bool Widget::get_has_tooltip() const
6694 {
6695   return gtk_widget_get_has_tooltip(const_cast<GtkWidget*>(gobj()));
6696 }
6697
6698 bool Widget::is_composited() const
6699 {
6700   return gtk_widget_is_composited(const_cast<GtkWidget*>(gobj()));
6701 }
6702
6703 Glib::RefPtr<Action> Widget::get_action()
6704 {
6705
6706   Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_widget_get_action(gobj()));
6707   if(retvalue)
6708     retvalue->reference(); //The function does not do a ref for us.
6709   return retvalue;
6710
6711 }
6712
6713 Glib::RefPtr<const Action> Widget::get_action() const
6714 {
6715   return const_cast<Widget*>(this)->get_action();
6716 }
6717
6718  Gtk::StateType Widget::get_state() const
6719 {
6720   return static_cast<StateType>(gobj()->state);
6721 }
6722
6723  Gtk::StateType Widget::get_saved_state() const
6724 {
6725   return static_cast<StateType>(gobj()->saved_state);
6726 }
6727
6728  Requisition Widget::get_requisition() const
6729 {
6730   return (Requisition)(gobj()->requisition);
6731 }
6732
6733  Allocation Widget::get_allocation() const
6734 {
6735   return (Allocation)(Glib::wrap(&gobj()->allocation));
6736 }
6737
6738  Glib::RefPtr<Gdk::Window> Widget::get_window()
6739 {
6740   Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->window)));
6741
6742   if(ref_ptr)
6743     ref_ptr->reference();
6744
6745   return ref_ptr;
6746 }
6747
6748 Glib::RefPtr<const Gdk::Window> Widget::get_window() const
6749 {
6750   Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->window)));
6751
6752   if(ref_ptr)
6753     ref_ptr->reference();
6754
6755   return ref_ptr;
6756 }
6757
6758 Widget::Widget()
6759 :
6760   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
6761   Glib::ObjectBase(0),
6762   Gtk::Object(Glib::ConstructParams(widget_class_.init()))
6763 {
6764   }
6765
6766 void Widget::realize()
6767 {
6768 gtk_widget_realize(gobj());
6769 }
6770
6771 void Widget::unrealize()
6772 {
6773 gtk_widget_unrealize(gobj());
6774 }
6775
6776 void Widget::get_child_requisition(Requisition& requisition) const
6777 {
6778 gtk_widget_get_child_requisition(const_cast<GtkWidget*>(gobj()), (GtkRequisition*)(&requisition));
6779 }
6780
6781 void Widget::get_style_property_value(const Glib::ustring& the_property_name, Glib::ValueBase& value) const
6782 {
6783 gtk_widget_style_get_property(const_cast<GtkWidget*>(gobj()), the_property_name.c_str(), (value).gobj());
6784 }
6785
6786  void Widget::set_allocation(const Allocation& value)
6787 {
6788   gobj()->allocation = (GtkAllocation)(*(value.gobj()));
6789 }
6790
6791  void Widget::set_window(const Glib::RefPtr<Gdk::Window>& value)
6792 {
6793   Glib::RefPtr<Gdk::Window> valueOld(Glib::wrap((GdkWindowObject*)(gobj()->window))); //Take possession of the old one, unref-ing it in the destructor.
6794
6795   if(value)
6796     value->reference(); //Ref once for the recipient.
6797
6798   gobj()->window = Glib::unwrap(value);
6799 }
6800
6801
6802 Glib::SignalProxy0< void > Widget::signal_show()
6803 {
6804   return Glib::SignalProxy0< void >(this, &Widget_signal_show_info);
6805 }
6806
6807
6808 Glib::SignalProxy0< void > Widget::signal_hide()
6809 {
6810   return Glib::SignalProxy0< void >(this, &Widget_signal_hide_info);
6811 }
6812
6813
6814 Glib::SignalProxy0< void > Widget::signal_map()
6815 {
6816   return Glib::SignalProxy0< void >(this, &Widget_signal_map_info);
6817 }
6818
6819
6820 Glib::SignalProxy0< void > Widget::signal_unmap()
6821 {
6822   return Glib::SignalProxy0< void >(this, &Widget_signal_unmap_info);
6823 }
6824
6825
6826 Glib::SignalProxy0< void > Widget::signal_realize()
6827 {
6828   return Glib::SignalProxy0< void >(this, &Widget_signal_realize_info);
6829 }
6830
6831
6832 Glib::SignalProxy0< void > Widget::signal_unrealize()
6833 {
6834   return Glib::SignalProxy0< void >(this, &Widget_signal_unrealize_info);
6835 }
6836
6837
6838 Glib::SignalProxy1< void,Requisition* > Widget::signal_size_request()
6839 {
6840   return Glib::SignalProxy1< void,Requisition* >(this, &Widget_signal_size_request_info);
6841 }
6842
6843
6844 Glib::SignalProxy1< void,Allocation& > Widget::signal_size_allocate()
6845 {
6846   return Glib::SignalProxy1< void,Allocation& >(this, &Widget_signal_size_allocate_info);
6847 }
6848
6849
6850 Glib::SignalProxy1< void,Gtk::StateType > Widget::signal_state_changed()
6851 {
6852   return Glib::SignalProxy1< void,Gtk::StateType >(this, &Widget_signal_state_changed_info);
6853 }
6854
6855
6856 Glib::SignalProxy1< void,Widget* > Widget::signal_parent_changed()
6857 {
6858   return Glib::SignalProxy1< void,Widget* >(this, &Widget_signal_parent_changed_info);
6859 }
6860
6861
6862 Glib::SignalProxy1< void,Widget* > Widget::signal_hierarchy_changed()
6863 {
6864   return Glib::SignalProxy1< void,Widget* >(this, &Widget_signal_hierarchy_changed_info);
6865 }
6866
6867
6868 Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::Style>& > Widget::signal_style_changed()
6869 {
6870   return Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::Style>& >(this, &Widget_signal_style_changed_info);
6871 }
6872
6873
6874 Glib::SignalProxy1< void,TextDirection > Widget::signal_direction_changed()
6875 {
6876   return Glib::SignalProxy1< void,TextDirection >(this, &Widget_signal_direction_changed_info);
6877 }
6878
6879
6880 Glib::SignalProxy1< void,bool > Widget::signal_grab_notify()
6881 {
6882   return Glib::SignalProxy1< void,bool >(this, &Widget_signal_grab_notify_info);
6883 }
6884
6885
6886 Glib::SignalProxy1< void,GParamSpec* > Widget::signal_child_notify()
6887 {
6888   return Glib::SignalProxy1< void,GParamSpec* >(this, &Widget_signal_child_notify_info);
6889 }
6890
6891
6892 Glib::SignalProxy1< bool,bool > Widget::signal_mnemonic_activate()
6893 {
6894   return Glib::SignalProxy1< bool,bool >(this, &Widget_signal_mnemonic_activate_info);
6895 }
6896
6897
6898 Glib::SignalProxy0< void > Widget::signal_grab_focus()
6899 {
6900   return Glib::SignalProxy0< void >(this, &Widget_signal_grab_focus_info);
6901 }
6902
6903
6904 Glib::SignalProxy1< bool,DirectionType > Widget::signal_focus()
6905 {
6906   return Glib::SignalProxy1< bool,DirectionType >(this, &Widget_signal_focus_info);
6907 }
6908
6909
6910 Glib::SignalProxy1< bool,GdkEvent* > Widget::signal_event()
6911 {
6912   return Glib::SignalProxy1< bool,GdkEvent* >(this, &Widget_signal_event_info);
6913 }
6914
6915
6916 Glib::SignalProxy1< void,GdkEvent* > Widget::signal_event_after()
6917 {
6918   return Glib::SignalProxy1< void,GdkEvent* >(this, &Widget_signal_event_after_info);
6919 }
6920
6921
6922 Glib::SignalProxy1< bool,GdkEventButton* > Widget::signal_button_press_event()
6923 {
6924   return Glib::SignalProxy1< bool,GdkEventButton* >(this, &Widget_signal_button_press_event_info);
6925 }
6926
6927
6928 Glib::SignalProxy1< bool,GdkEventButton* > Widget::signal_button_release_event()
6929 {
6930   return Glib::SignalProxy1< bool,GdkEventButton* >(this, &Widget_signal_button_release_event_info);
6931 }
6932
6933
6934 Glib::SignalProxy1< bool,GdkEventScroll* > Widget::signal_scroll_event()
6935 {
6936   return Glib::SignalProxy1< bool,GdkEventScroll* >(this, &Widget_signal_scroll_event_info);
6937 }
6938
6939
6940 Glib::SignalProxy1< bool,GdkEventMotion* > Widget::signal_motion_notify_event()
6941 {
6942   return Glib::SignalProxy1< bool,GdkEventMotion* >(this, &Widget_signal_motion_notify_event_info);
6943 }
6944
6945
6946 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_delete_event()
6947 {
6948   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_delete_event_info);
6949 }
6950
6951
6952 Glib::SignalProxy1< bool,GdkEventExpose* > Widget::signal_expose_event()
6953 {
6954   return Glib::SignalProxy1< bool,GdkEventExpose* >(this, &Widget_signal_expose_event_info);
6955 }
6956
6957
6958 Glib::SignalProxy1< bool,GdkEventKey* > Widget::signal_key_press_event()
6959 {
6960   return Glib::SignalProxy1< bool,GdkEventKey* >(this, &Widget_signal_key_press_event_info);
6961 }
6962
6963
6964 Glib::SignalProxy1< bool,GdkEventKey* > Widget::signal_key_release_event()
6965 {
6966   return Glib::SignalProxy1< bool,GdkEventKey* >(this, &Widget_signal_key_release_event_info);
6967 }
6968
6969
6970 Glib::SignalProxy1< bool,GdkEventCrossing* > Widget::signal_enter_notify_event()
6971 {
6972   return Glib::SignalProxy1< bool,GdkEventCrossing* >(this, &Widget_signal_enter_notify_event_info);
6973 }
6974
6975
6976 Glib::SignalProxy1< bool,GdkEventCrossing* > Widget::signal_leave_notify_event()
6977 {
6978   return Glib::SignalProxy1< bool,GdkEventCrossing* >(this, &Widget_signal_leave_notify_event_info);
6979 }
6980
6981
6982 Glib::SignalProxy1< bool,GdkEventConfigure* > Widget::signal_configure_event()
6983 {
6984   return Glib::SignalProxy1< bool,GdkEventConfigure* >(this, &Widget_signal_configure_event_info);
6985 }
6986
6987
6988 Glib::SignalProxy1< bool,GdkEventFocus* > Widget::signal_focus_in_event()
6989 {
6990   return Glib::SignalProxy1< bool,GdkEventFocus* >(this, &Widget_signal_focus_in_event_info);
6991 }
6992
6993
6994 Glib::SignalProxy1< bool,GdkEventFocus* > Widget::signal_focus_out_event()
6995 {
6996   return Glib::SignalProxy1< bool,GdkEventFocus* >(this, &Widget_signal_focus_out_event_info);
6997 }
6998
6999
7000 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_map_event()
7001 {
7002   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_map_event_info);
7003 }
7004
7005
7006 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_unmap_event()
7007 {
7008   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_unmap_event_info);
7009 }
7010
7011
7012 Glib::SignalProxy1< bool,GdkEventProperty* > Widget::signal_property_notify_event()
7013 {
7014   return Glib::SignalProxy1< bool,GdkEventProperty* >(this, &Widget_signal_property_notify_event_info);
7015 }
7016
7017
7018 Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_clear_event()
7019 {
7020   return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_clear_event_info);
7021 }
7022
7023
7024 Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_request_event()
7025 {
7026   return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_request_event_info);
7027 }
7028
7029
7030 Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_notify_event()
7031 {
7032   return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_notify_event_info);
7033 }
7034
7035
7036 Glib::SignalProxy1< bool,GdkEventProximity* > Widget::signal_proximity_in_event()
7037 {
7038   return Glib::SignalProxy1< bool,GdkEventProximity* >(this, &Widget_signal_proximity_in_event_info);
7039 }
7040
7041
7042 Glib::SignalProxy1< bool,GdkEventProximity* > Widget::signal_proximity_out_event()
7043 {
7044   return Glib::SignalProxy1< bool,GdkEventProximity* >(this, &Widget_signal_proximity_out_event_info);
7045 }
7046
7047
7048 Glib::SignalProxy1< bool,GdkEventVisibility* > Widget::signal_visibility_notify_event()
7049 {
7050   return Glib::SignalProxy1< bool,GdkEventVisibility* >(this, &Widget_signal_visibility_notify_event_info);
7051 }
7052
7053
7054 Glib::SignalProxy1< bool,GdkEventClient* > Widget::signal_client_event()
7055 {
7056   return Glib::SignalProxy1< bool,GdkEventClient* >(this, &Widget_signal_client_event_info);
7057 }
7058
7059
7060 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_no_expose_event()
7061 {
7062   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_no_expose_event_info);
7063 }
7064
7065
7066 Glib::SignalProxy1< bool,GdkEventWindowState* > Widget::signal_window_state_event()
7067 {
7068   return Glib::SignalProxy1< bool,GdkEventWindowState* >(this, &Widget_signal_window_state_event_info);
7069 }
7070
7071
7072 Glib::SignalProxy3< void,SelectionData&,guint,guint > Widget::signal_selection_get()
7073 {
7074   return Glib::SignalProxy3< void,SelectionData&,guint,guint >(this, &Widget_signal_selection_get_info);
7075 }
7076
7077
7078 Glib::SignalProxy2< void,const SelectionData&,guint > Widget::signal_selection_received()
7079 {
7080   return Glib::SignalProxy2< void,const SelectionData&,guint >(this, &Widget_signal_selection_received_info);
7081 }
7082
7083
7084 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_begin()
7085 {
7086   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_begin_info);
7087 }
7088
7089
7090 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_end()
7091 {
7092   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_end_info);
7093 }
7094
7095
7096 Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > Widget::signal_drag_data_get()
7097 {
7098   return Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint >(this, &Widget_signal_drag_data_get_info);
7099 }
7100
7101
7102 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_data_delete()
7103 {
7104   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_data_delete_info);
7105 }
7106
7107
7108 Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint > Widget::signal_drag_leave()
7109 {
7110   return Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint >(this, &Widget_signal_drag_leave_info);
7111 }
7112
7113
7114 Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > Widget::signal_drag_motion()
7115 {
7116   return Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint >(this, &Widget_signal_drag_motion_info);
7117 }
7118
7119
7120 Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > Widget::signal_drag_drop()
7121 {
7122   return Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint >(this, &Widget_signal_drag_drop_info);
7123 }
7124
7125
7126 Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > Widget::signal_drag_data_received()
7127 {
7128   return Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint >(this, &Widget_signal_drag_data_received_info);
7129 }
7130
7131
7132 #ifdef GTKMM_ATKMM_ENABLED
7133 Glib::SignalProxy0< Glib::RefPtr<Atk::Object> > Widget::signal_get_accessible()
7134 {
7135   return Glib::SignalProxy0< Glib::RefPtr<Atk::Object> >(this, &Widget_signal_get_accessible_info);
7136 }
7137 #endif // GTKMM_ATKMM_ENABLED
7138
7139
7140 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > Widget::signal_screen_changed()
7141 {
7142   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& >(this, &Widget_signal_screen_changed_info);
7143 }
7144
7145
7146 Glib::SignalProxy0< void > Widget::signal_composited_changed()
7147 {
7148   return Glib::SignalProxy0< void >(this, &Widget_signal_composited_changed_info);
7149 }
7150
7151
7152 Glib::SignalProxy4< bool,int,int,bool,const Glib::RefPtr<Tooltip>& > Widget::signal_query_tooltip()
7153 {
7154   return Glib::SignalProxy4< bool,int,int,bool,const Glib::RefPtr<Tooltip>& >(this, &Widget_signal_query_tooltip_info);
7155 }
7156
7157
7158 #ifdef GLIBMM_PROPERTIES_ENABLED
7159 Glib::PropertyProxy<Glib::ustring> Widget::property_name()
7160 {
7161   return Glib::PropertyProxy<Glib::ustring>(this, "name");
7162 }
7163 #endif //GLIBMM_PROPERTIES_ENABLED
7164
7165 #ifdef GLIBMM_PROPERTIES_ENABLED
7166 Glib::PropertyProxy_ReadOnly<Glib::ustring> Widget::property_name() const
7167 {
7168   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
7169 }
7170 #endif //GLIBMM_PROPERTIES_ENABLED
7171
7172 #ifdef GLIBMM_PROPERTIES_ENABLED
7173 Glib::PropertyProxy<Container*> Widget::property_parent()
7174 {
7175   return Glib::PropertyProxy<Container*>(this, "parent");
7176 }
7177 #endif //GLIBMM_PROPERTIES_ENABLED
7178
7179 #ifdef GLIBMM_PROPERTIES_ENABLED
7180 Glib::PropertyProxy_ReadOnly<Container*> Widget::property_parent() const
7181 {
7182   return Glib::PropertyProxy_ReadOnly<Container*>(this, "parent");
7183 }
7184 #endif //GLIBMM_PROPERTIES_ENABLED
7185
7186 #ifdef GLIBMM_PROPERTIES_ENABLED
7187 Glib::PropertyProxy<int> Widget::property_width_request()
7188 {
7189   return Glib::PropertyProxy<int>(this, "width-request");
7190 }
7191 #endif //GLIBMM_PROPERTIES_ENABLED
7192
7193 #ifdef GLIBMM_PROPERTIES_ENABLED
7194 Glib::PropertyProxy_ReadOnly<int> Widget::property_width_request() const
7195 {
7196   return Glib::PropertyProxy_ReadOnly<int>(this, "width-request");
7197 }
7198 #endif //GLIBMM_PROPERTIES_ENABLED
7199
7200 #ifdef GLIBMM_PROPERTIES_ENABLED
7201 Glib::PropertyProxy<int> Widget::property_height_request()
7202 {
7203   return Glib::PropertyProxy<int>(this, "height-request");
7204 }
7205 #endif //GLIBMM_PROPERTIES_ENABLED
7206
7207 #ifdef GLIBMM_PROPERTIES_ENABLED
7208 Glib::PropertyProxy_ReadOnly<int> Widget::property_height_request() const
7209 {
7210   return Glib::PropertyProxy_ReadOnly<int>(this, "height-request");
7211 }
7212 #endif //GLIBMM_PROPERTIES_ENABLED
7213
7214 #ifdef GLIBMM_PROPERTIES_ENABLED
7215 Glib::PropertyProxy<bool> Widget::property_visible()
7216 {
7217   return Glib::PropertyProxy<bool>(this, "visible");
7218 }
7219 #endif //GLIBMM_PROPERTIES_ENABLED
7220
7221 #ifdef GLIBMM_PROPERTIES_ENABLED
7222 Glib::PropertyProxy_ReadOnly<bool> Widget::property_visible() const
7223 {
7224   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
7225 }
7226 #endif //GLIBMM_PROPERTIES_ENABLED
7227
7228 #ifdef GLIBMM_PROPERTIES_ENABLED
7229 Glib::PropertyProxy<bool> Widget::property_sensitive()
7230 {
7231   return Glib::PropertyProxy<bool>(this, "sensitive");
7232 }
7233 #endif //GLIBMM_PROPERTIES_ENABLED
7234
7235 #ifdef GLIBMM_PROPERTIES_ENABLED
7236 Glib::PropertyProxy_ReadOnly<bool> Widget::property_sensitive() const
7237 {
7238   return Glib::PropertyProxy_ReadOnly<bool>(this, "sensitive");
7239 }
7240 #endif //GLIBMM_PROPERTIES_ENABLED
7241
7242 #ifdef GLIBMM_PROPERTIES_ENABLED
7243 Glib::PropertyProxy<bool> Widget::property_app_paintable()
7244 {
7245   return Glib::PropertyProxy<bool>(this, "app-paintable");
7246 }
7247 #endif //GLIBMM_PROPERTIES_ENABLED
7248
7249 #ifdef GLIBMM_PROPERTIES_ENABLED
7250 Glib::PropertyProxy_ReadOnly<bool> Widget::property_app_paintable() const
7251 {
7252   return Glib::PropertyProxy_ReadOnly<bool>(this, "app-paintable");
7253 }
7254 #endif //GLIBMM_PROPERTIES_ENABLED
7255
7256 #ifdef GLIBMM_PROPERTIES_ENABLED
7257 Glib::PropertyProxy<bool> Widget::property_can_focus()
7258 {
7259   return Glib::PropertyProxy<bool>(this, "can-focus");
7260 }
7261 #endif //GLIBMM_PROPERTIES_ENABLED
7262
7263 #ifdef GLIBMM_PROPERTIES_ENABLED
7264 Glib::PropertyProxy_ReadOnly<bool> Widget::property_can_focus() const
7265 {
7266   return Glib::PropertyProxy_ReadOnly<bool>(this, "can-focus");
7267 }
7268 #endif //GLIBMM_PROPERTIES_ENABLED
7269
7270 #ifdef GLIBMM_PROPERTIES_ENABLED
7271 Glib::PropertyProxy<bool> Widget::property_has_focus()
7272 {
7273   return Glib::PropertyProxy<bool>(this, "has-focus");
7274 }
7275 #endif //GLIBMM_PROPERTIES_ENABLED
7276
7277 #ifdef GLIBMM_PROPERTIES_ENABLED
7278 Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_focus() const
7279 {
7280   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-focus");
7281 }
7282 #endif //GLIBMM_PROPERTIES_ENABLED
7283
7284 #ifdef GLIBMM_PROPERTIES_ENABLED
7285 Glib::PropertyProxy<bool> Widget::property_can_default()
7286 {
7287   return Glib::PropertyProxy<bool>(this, "can-default");
7288 }
7289 #endif //GLIBMM_PROPERTIES_ENABLED
7290
7291 #ifdef GLIBMM_PROPERTIES_ENABLED
7292 Glib::PropertyProxy_ReadOnly<bool> Widget::property_can_default() const
7293 {
7294   return Glib::PropertyProxy_ReadOnly<bool>(this, "can-default");
7295 }
7296 #endif //GLIBMM_PROPERTIES_ENABLED
7297
7298 #ifdef GLIBMM_PROPERTIES_ENABLED
7299 Glib::PropertyProxy<bool> Widget::property_has_default()
7300 {
7301   return Glib::PropertyProxy<bool>(this, "has-default");
7302 }
7303 #endif //GLIBMM_PROPERTIES_ENABLED
7304
7305 #ifdef GLIBMM_PROPERTIES_ENABLED
7306 Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_default() const
7307 {
7308   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-default");
7309 }
7310 #endif //GLIBMM_PROPERTIES_ENABLED
7311
7312 #ifdef GLIBMM_PROPERTIES_ENABLED
7313 Glib::PropertyProxy<bool> Widget::property_receives_default()
7314 {
7315   return Glib::PropertyProxy<bool>(this, "receives-default");
7316 }
7317 #endif //GLIBMM_PROPERTIES_ENABLED
7318
7319 #ifdef GLIBMM_PROPERTIES_ENABLED
7320 Glib::PropertyProxy_ReadOnly<bool> Widget::property_receives_default() const
7321 {
7322   return Glib::PropertyProxy_ReadOnly<bool>(this, "receives-default");
7323 }
7324 #endif //GLIBMM_PROPERTIES_ENABLED
7325
7326 #ifdef GLIBMM_PROPERTIES_ENABLED
7327 Glib::PropertyProxy_ReadOnly<bool> Widget::property_composite_child() const
7328 {
7329   return Glib::PropertyProxy_ReadOnly<bool>(this, "composite-child");
7330 }
7331 #endif //GLIBMM_PROPERTIES_ENABLED
7332
7333 #ifdef GLIBMM_PROPERTIES_ENABLED
7334 Glib::PropertyProxy< Glib::RefPtr<Style> > Widget::property_style()
7335 {
7336   return Glib::PropertyProxy< Glib::RefPtr<Style> >(this, "style");
7337 }
7338 #endif //GLIBMM_PROPERTIES_ENABLED
7339
7340 #ifdef GLIBMM_PROPERTIES_ENABLED
7341 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> > Widget::property_style() const
7342 {
7343   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> >(this, "style");
7344 }
7345 #endif //GLIBMM_PROPERTIES_ENABLED
7346
7347 #ifdef GLIBMM_PROPERTIES_ENABLED
7348 Glib::PropertyProxy<Gdk::EventMask> Widget::property_events()
7349 {
7350   return Glib::PropertyProxy<Gdk::EventMask>(this, "events");
7351 }
7352 #endif //GLIBMM_PROPERTIES_ENABLED
7353
7354 #ifdef GLIBMM_PROPERTIES_ENABLED
7355 Glib::PropertyProxy_ReadOnly<Gdk::EventMask> Widget::property_events() const
7356 {
7357   return Glib::PropertyProxy_ReadOnly<Gdk::EventMask>(this, "events");
7358 }
7359 #endif //GLIBMM_PROPERTIES_ENABLED
7360
7361 #ifdef GLIBMM_PROPERTIES_ENABLED
7362 Glib::PropertyProxy<Gdk::ExtensionMode> Widget::property_extension_events()
7363 {
7364   return Glib::PropertyProxy<Gdk::ExtensionMode>(this, "extension-events");
7365 }
7366 #endif //GLIBMM_PROPERTIES_ENABLED
7367
7368 #ifdef GLIBMM_PROPERTIES_ENABLED
7369 Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode> Widget::property_extension_events() const
7370 {
7371   return Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode>(this, "extension-events");
7372 }
7373 #endif //GLIBMM_PROPERTIES_ENABLED
7374
7375 #ifdef GLIBMM_PROPERTIES_ENABLED
7376 Glib::PropertyProxy<bool> Widget::property_has_tooltip()
7377 {
7378   return Glib::PropertyProxy<bool>(this, "has-tooltip");
7379 }
7380 #endif //GLIBMM_PROPERTIES_ENABLED
7381
7382 #ifdef GLIBMM_PROPERTIES_ENABLED
7383 Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_tooltip() const
7384 {
7385   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-tooltip");
7386 }
7387 #endif //GLIBMM_PROPERTIES_ENABLED
7388
7389 #ifdef GLIBMM_PROPERTIES_ENABLED
7390 Glib::PropertyProxy<Glib::ustring> Widget::property_tooltip_markup()
7391 {
7392   return Glib::PropertyProxy<Glib::ustring>(this, "tooltip-markup");
7393 }
7394 #endif //GLIBMM_PROPERTIES_ENABLED
7395
7396 #ifdef GLIBMM_PROPERTIES_ENABLED
7397 Glib::PropertyProxy_ReadOnly<Glib::ustring> Widget::property_tooltip_markup() const
7398 {
7399   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tooltip-markup");
7400 }
7401 #endif //GLIBMM_PROPERTIES_ENABLED
7402
7403 #ifdef GLIBMM_PROPERTIES_ENABLED
7404 Glib::PropertyProxy<Glib::ustring> Widget::property_tooltip_text()
7405 {
7406   return Glib::PropertyProxy<Glib::ustring>(this, "tooltip-text");
7407 }
7408 #endif //GLIBMM_PROPERTIES_ENABLED
7409
7410 #ifdef GLIBMM_PROPERTIES_ENABLED
7411 Glib::PropertyProxy_ReadOnly<Glib::ustring> Widget::property_tooltip_text() const
7412 {
7413   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tooltip-text");
7414 }
7415 #endif //GLIBMM_PROPERTIES_ENABLED
7416
7417
7418 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
7419 void Gtk::Widget::on_show()
7420 {
7421   BaseClassType *const base = static_cast<BaseClassType*>(
7422       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7423   );
7424
7425   if(base && base->show)
7426     (*base->show)(gobj());
7427 }
7428 void Gtk::Widget::on_hide()
7429 {
7430   BaseClassType *const base = static_cast<BaseClassType*>(
7431       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7432   );
7433
7434   if(base && base->hide)
7435     (*base->hide)(gobj());
7436 }
7437 void Gtk::Widget::on_map()
7438 {
7439   BaseClassType *const base = static_cast<BaseClassType*>(
7440       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7441   );
7442
7443   if(base && base->map)
7444     (*base->map)(gobj());
7445 }
7446 void Gtk::Widget::on_unmap()
7447 {
7448   BaseClassType *const base = static_cast<BaseClassType*>(
7449       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7450   );
7451
7452   if(base && base->unmap)
7453     (*base->unmap)(gobj());
7454 }
7455 void Gtk::Widget::on_realize()
7456 {
7457   BaseClassType *const base = static_cast<BaseClassType*>(
7458       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7459   );
7460
7461   if(base && base->realize)
7462     (*base->realize)(gobj());
7463 }
7464 void Gtk::Widget::on_unrealize()
7465 {
7466   BaseClassType *const base = static_cast<BaseClassType*>(
7467       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7468   );
7469
7470   if(base && base->unrealize)
7471     (*base->unrealize)(gobj());
7472 }
7473 void Gtk::Widget::on_size_request(Requisition* requisition)
7474 {
7475   BaseClassType *const base = static_cast<BaseClassType*>(
7476       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7477   );
7478
7479   if(base && base->size_request)
7480     (*base->size_request)(gobj(),(GtkRequisition*)(requisition));
7481 }
7482 void Gtk::Widget::on_size_allocate(Allocation& allocation)
7483 {
7484   BaseClassType *const base = static_cast<BaseClassType*>(
7485       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7486   );
7487
7488   if(base && base->size_allocate)
7489     (*base->size_allocate)(gobj(),(GtkAllocation*)(allocation.gobj()));
7490 }
7491 void Gtk::Widget::on_state_changed(Gtk::StateType previous_state)
7492 {
7493   BaseClassType *const base = static_cast<BaseClassType*>(
7494       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7495   );
7496
7497   if(base && base->state_changed)
7498     (*base->state_changed)(gobj(),((GtkStateType)(previous_state)));
7499 }
7500 void Gtk::Widget::on_parent_changed(Widget* previous_parent)
7501 {
7502   BaseClassType *const base = static_cast<BaseClassType*>(
7503       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7504   );
7505
7506   if(base && base->parent_set)
7507     (*base->parent_set)(gobj(),(GtkWidget*)Glib::unwrap(previous_parent));
7508 }
7509 void Gtk::Widget::on_hierarchy_changed(Widget* previous_toplevel)
7510 {
7511   BaseClassType *const base = static_cast<BaseClassType*>(
7512       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7513   );
7514
7515   if(base && base->hierarchy_changed)
7516     (*base->hierarchy_changed)(gobj(),(GtkWidget*)Glib::unwrap(previous_toplevel));
7517 }
7518 void Gtk::Widget::on_style_changed(const Glib::RefPtr<Gtk::Style>& previous_style)
7519 {
7520   BaseClassType *const base = static_cast<BaseClassType*>(
7521       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7522   );
7523
7524   if(base && base->style_set)
7525     (*base->style_set)(gobj(),Glib::unwrap(previous_style));
7526 }
7527 void Gtk::Widget::on_direction_changed(TextDirection direction)
7528 {
7529   BaseClassType *const base = static_cast<BaseClassType*>(
7530       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7531   );
7532
7533   if(base && base->direction_changed)
7534     (*base->direction_changed)(gobj(),((GtkTextDirection)(direction)));
7535 }
7536 void Gtk::Widget::on_grab_notify(bool was_grabbed)
7537 {
7538   BaseClassType *const base = static_cast<BaseClassType*>(
7539       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7540   );
7541
7542   if(base && base->grab_notify)
7543     (*base->grab_notify)(gobj(),static_cast<int>(was_grabbed));
7544 }
7545 void Gtk::Widget::on_child_notify(GParamSpec* pspec)
7546 {
7547   BaseClassType *const base = static_cast<BaseClassType*>(
7548       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7549   );
7550
7551   if(base && base->child_notify)
7552     (*base->child_notify)(gobj(),pspec);
7553 }
7554 bool Gtk::Widget::on_mnemonic_activate(bool group_cycling)
7555 {
7556   BaseClassType *const base = static_cast<BaseClassType*>(
7557       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7558   );
7559
7560   if(base && base->mnemonic_activate)
7561     return (*base->mnemonic_activate)(gobj(),static_cast<int>(group_cycling));
7562
7563   typedef bool RType;
7564   return RType();
7565 }
7566 void Gtk::Widget::on_grab_focus()
7567 {
7568   BaseClassType *const base = static_cast<BaseClassType*>(
7569       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7570   );
7571
7572   if(base && base->grab_focus)
7573     (*base->grab_focus)(gobj());
7574 }
7575 bool Gtk::Widget::on_focus(DirectionType direction)
7576 {
7577   BaseClassType *const base = static_cast<BaseClassType*>(
7578       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7579   );
7580
7581   if(base && base->focus)
7582     return (*base->focus)(gobj(),((GtkDirectionType)(direction)));
7583
7584   typedef bool RType;
7585   return RType();
7586 }
7587 bool Gtk::Widget::on_event(GdkEvent* event)
7588 {
7589   BaseClassType *const base = static_cast<BaseClassType*>(
7590       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7591   );
7592
7593   if(base && base->event)
7594     return (*base->event)(gobj(),event);
7595
7596   typedef bool RType;
7597   return RType();
7598 }
7599 bool Gtk::Widget::on_button_press_event(GdkEventButton* event)
7600 {
7601   BaseClassType *const base = static_cast<BaseClassType*>(
7602       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7603   );
7604
7605   if(base && base->button_press_event)
7606     return (*base->button_press_event)(gobj(),event);
7607
7608   typedef bool RType;
7609   return RType();
7610 }
7611 bool Gtk::Widget::on_button_release_event(GdkEventButton* event)
7612 {
7613   BaseClassType *const base = static_cast<BaseClassType*>(
7614       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7615   );
7616
7617   if(base && base->button_release_event)
7618     return (*base->button_release_event)(gobj(),event);
7619
7620   typedef bool RType;
7621   return RType();
7622 }
7623 bool Gtk::Widget::on_scroll_event(GdkEventScroll* event)
7624 {
7625   BaseClassType *const base = static_cast<BaseClassType*>(
7626       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7627   );
7628
7629   if(base && base->scroll_event)
7630     return (*base->scroll_event)(gobj(),event);
7631
7632   typedef bool RType;
7633   return RType();
7634 }
7635 bool Gtk::Widget::on_motion_notify_event(GdkEventMotion* event)
7636 {
7637   BaseClassType *const base = static_cast<BaseClassType*>(
7638       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7639   );
7640
7641   if(base && base->motion_notify_event)
7642     return (*base->motion_notify_event)(gobj(),event);
7643
7644   typedef bool RType;
7645   return RType();
7646 }
7647 bool Gtk::Widget::on_delete_event(GdkEventAny* event)
7648 {
7649   BaseClassType *const base = static_cast<BaseClassType*>(
7650       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7651   );
7652
7653   if(base && base->delete_event)
7654     return (*base->delete_event)(gobj(),event);
7655
7656   typedef bool RType;
7657   return RType();
7658 }
7659 bool Gtk::Widget::on_expose_event(GdkEventExpose* event)
7660 {
7661   BaseClassType *const base = static_cast<BaseClassType*>(
7662       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7663   );
7664
7665   if(base && base->expose_event)
7666     return (*base->expose_event)(gobj(),event);
7667
7668   typedef bool RType;
7669   return RType();
7670 }
7671 bool Gtk::Widget::on_key_press_event(GdkEventKey* event)
7672 {
7673   BaseClassType *const base = static_cast<BaseClassType*>(
7674       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7675   );
7676
7677   if(base && base->key_press_event)
7678     return (*base->key_press_event)(gobj(),event);
7679
7680   typedef bool RType;
7681   return RType();
7682 }
7683 bool Gtk::Widget::on_key_release_event(GdkEventKey* event)
7684 {
7685   BaseClassType *const base = static_cast<BaseClassType*>(
7686       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7687   );
7688
7689   if(base && base->key_release_event)
7690     return (*base->key_release_event)(gobj(),event);
7691
7692   typedef bool RType;
7693   return RType();
7694 }
7695 bool Gtk::Widget::on_enter_notify_event(GdkEventCrossing* event)
7696 {
7697   BaseClassType *const base = static_cast<BaseClassType*>(
7698       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7699   );
7700
7701   if(base && base->enter_notify_event)
7702     return (*base->enter_notify_event)(gobj(),event);
7703
7704   typedef bool RType;
7705   return RType();
7706 }
7707 bool Gtk::Widget::on_leave_notify_event(GdkEventCrossing* event)
7708 {
7709   BaseClassType *const base = static_cast<BaseClassType*>(
7710       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7711   );
7712
7713   if(base && base->leave_notify_event)
7714     return (*base->leave_notify_event)(gobj(),event);
7715
7716   typedef bool RType;
7717   return RType();
7718 }
7719 bool Gtk::Widget::on_configure_event(GdkEventConfigure* event)
7720 {
7721   BaseClassType *const base = static_cast<BaseClassType*>(
7722       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7723   );
7724
7725   if(base && base->configure_event)
7726     return (*base->configure_event)(gobj(),event);
7727
7728   typedef bool RType;
7729   return RType();
7730 }
7731 bool Gtk::Widget::on_focus_in_event(GdkEventFocus* event)
7732 {
7733   BaseClassType *const base = static_cast<BaseClassType*>(
7734       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7735   );
7736
7737   if(base && base->focus_in_event)
7738     return (*base->focus_in_event)(gobj(),event);
7739
7740   typedef bool RType;
7741   return RType();
7742 }
7743 bool Gtk::Widget::on_focus_out_event(GdkEventFocus* event)
7744 {
7745   BaseClassType *const base = static_cast<BaseClassType*>(
7746       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7747   );
7748
7749   if(base && base->focus_out_event)
7750     return (*base->focus_out_event)(gobj(),event);
7751
7752   typedef bool RType;
7753   return RType();
7754 }
7755 bool Gtk::Widget::on_map_event(GdkEventAny* event)
7756 {
7757   BaseClassType *const base = static_cast<BaseClassType*>(
7758       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7759   );
7760
7761   if(base && base->map_event)
7762     return (*base->map_event)(gobj(),event);
7763
7764   typedef bool RType;
7765   return RType();
7766 }
7767 bool Gtk::Widget::on_unmap_event(GdkEventAny* event)
7768 {
7769   BaseClassType *const base = static_cast<BaseClassType*>(
7770       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7771   );
7772
7773   if(base && base->unmap_event)
7774     return (*base->unmap_event)(gobj(),event);
7775
7776   typedef bool RType;
7777   return RType();
7778 }
7779 bool Gtk::Widget::on_property_notify_event(GdkEventProperty* event)
7780 {
7781   BaseClassType *const base = static_cast<BaseClassType*>(
7782       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7783   );
7784
7785   if(base && base->property_notify_event)
7786     return (*base->property_notify_event)(gobj(),event);
7787
7788   typedef bool RType;
7789   return RType();
7790 }
7791 bool Gtk::Widget::on_selection_clear_event(GdkEventSelection* event)
7792 {
7793   BaseClassType *const base = static_cast<BaseClassType*>(
7794       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7795   );
7796
7797   if(base && base->selection_clear_event)
7798     return (*base->selection_clear_event)(gobj(),event);
7799
7800   typedef bool RType;
7801   return RType();
7802 }
7803 bool Gtk::Widget::on_selection_request_event(GdkEventSelection* event)
7804 {
7805   BaseClassType *const base = static_cast<BaseClassType*>(
7806       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7807   );
7808
7809   if(base && base->selection_request_event)
7810     return (*base->selection_request_event)(gobj(),event);
7811
7812   typedef bool RType;
7813   return RType();
7814 }
7815 bool Gtk::Widget::on_selection_notify_event(GdkEventSelection* event)
7816 {
7817   BaseClassType *const base = static_cast<BaseClassType*>(
7818       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7819   );
7820
7821   if(base && base->selection_notify_event)
7822     return (*base->selection_notify_event)(gobj(),event);
7823
7824   typedef bool RType;
7825   return RType();
7826 }
7827 bool Gtk::Widget::on_proximity_in_event(GdkEventProximity* event)
7828 {
7829   BaseClassType *const base = static_cast<BaseClassType*>(
7830       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7831   );
7832
7833   if(base && base->proximity_in_event)
7834     return (*base->proximity_in_event)(gobj(),event);
7835
7836   typedef bool RType;
7837   return RType();
7838 }
7839 bool Gtk::Widget::on_proximity_out_event(GdkEventProximity* event)
7840 {
7841   BaseClassType *const base = static_cast<BaseClassType*>(
7842       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7843   );
7844
7845   if(base && base->proximity_out_event)
7846     return (*base->proximity_out_event)(gobj(),event);
7847
7848   typedef bool RType;
7849   return RType();
7850 }
7851 bool Gtk::Widget::on_visibility_notify_event(GdkEventVisibility* event)
7852 {
7853   BaseClassType *const base = static_cast<BaseClassType*>(
7854       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7855   );
7856
7857   if(base && base->visibility_notify_event)
7858     return (*base->visibility_notify_event)(gobj(),event);
7859
7860   typedef bool RType;
7861   return RType();
7862 }
7863 bool Gtk::Widget::on_client_event(GdkEventClient* event)
7864 {
7865   BaseClassType *const base = static_cast<BaseClassType*>(
7866       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7867   );
7868
7869   if(base && base->client_event)
7870     return (*base->client_event)(gobj(),event);
7871
7872   typedef bool RType;
7873   return RType();
7874 }
7875 bool Gtk::Widget::on_no_expose_event(GdkEventAny* event)
7876 {
7877   BaseClassType *const base = static_cast<BaseClassType*>(
7878       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7879   );
7880
7881   if(base && base->no_expose_event)
7882     return (*base->no_expose_event)(gobj(),event);
7883
7884   typedef bool RType;
7885   return RType();
7886 }
7887 bool Gtk::Widget::on_window_state_event(GdkEventWindowState* event)
7888 {
7889   BaseClassType *const base = static_cast<BaseClassType*>(
7890       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7891   );
7892
7893   if(base && base->window_state_event)
7894     return (*base->window_state_event)(gobj(),event);
7895
7896   typedef bool RType;
7897   return RType();
7898 }
7899 void Gtk::Widget::on_selection_get(SelectionData& selection_data, guint info, guint time)
7900 {
7901   BaseClassType *const base = static_cast<BaseClassType*>(
7902       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7903   );
7904
7905   if(base && base->selection_get)
7906     (*base->selection_get)(gobj(),(selection_data).gobj(),info,time);
7907 }
7908 void Gtk::Widget::on_selection_received(const SelectionData& selection_data, guint time)
7909 {
7910   BaseClassType *const base = static_cast<BaseClassType*>(
7911       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7912   );
7913
7914   if(base && base->selection_received)
7915     (*base->selection_received)(gobj(),const_cast<GtkSelectionData*>((selection_data).gobj()),time);
7916 }
7917 void Gtk::Widget::on_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
7918 {
7919   BaseClassType *const base = static_cast<BaseClassType*>(
7920       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7921   );
7922
7923   if(base && base->drag_begin)
7924     (*base->drag_begin)(gobj(),Glib::unwrap(context));
7925 }
7926 void Gtk::Widget::on_drag_end(const Glib::RefPtr<Gdk::DragContext>& context)
7927 {
7928   BaseClassType *const base = static_cast<BaseClassType*>(
7929       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7930   );
7931
7932   if(base && base->drag_end)
7933     (*base->drag_end)(gobj(),Glib::unwrap(context));
7934 }
7935 void Gtk::Widget::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, SelectionData& selection_data, guint info, guint time)
7936 {
7937   BaseClassType *const base = static_cast<BaseClassType*>(
7938       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7939   );
7940
7941   if(base && base->drag_data_get)
7942     (*base->drag_data_get)(gobj(),Glib::unwrap(context),(selection_data).gobj(),info,time);
7943 }
7944 void Gtk::Widget::on_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context)
7945 {
7946   BaseClassType *const base = static_cast<BaseClassType*>(
7947       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7948   );
7949
7950   if(base && base->drag_data_delete)
7951     (*base->drag_data_delete)(gobj(),Glib::unwrap(context));
7952 }
7953 void Gtk::Widget::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)
7954 {
7955   BaseClassType *const base = static_cast<BaseClassType*>(
7956       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7957   );
7958
7959   if(base && base->drag_leave)
7960     (*base->drag_leave)(gobj(),Glib::unwrap(context),time);
7961 }
7962 bool Gtk::Widget::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
7963 {
7964   BaseClassType *const base = static_cast<BaseClassType*>(
7965       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7966   );
7967
7968   if(base && base->drag_motion)
7969     return (*base->drag_motion)(gobj(),Glib::unwrap(context),x,y,time);
7970
7971   typedef bool RType;
7972   return RType();
7973 }
7974 bool Gtk::Widget::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
7975 {
7976   BaseClassType *const base = static_cast<BaseClassType*>(
7977       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7978   );
7979
7980   if(base && base->drag_drop)
7981     return (*base->drag_drop)(gobj(),Glib::unwrap(context),x,y,time);
7982
7983   typedef bool RType;
7984   return RType();
7985 }
7986 void Gtk::Widget::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time)
7987 {
7988   BaseClassType *const base = static_cast<BaseClassType*>(
7989       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
7990   );
7991
7992   if(base && base->drag_data_received)
7993     (*base->drag_data_received)(gobj(),Glib::unwrap(context),x,y,const_cast<GtkSelectionData*>((selection_data).gobj()),info,time);
7994 }
7995 #ifdef GTKMM_ATKMM_ENABLED
7996 Glib::RefPtr<Atk::Object> Gtk::Widget::on_get_accessible()
7997 {
7998   BaseClassType *const base = static_cast<BaseClassType*>(
7999       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
8000   );
8001
8002   if(base && base->get_accessible)
8003     return Glib::wrap((*base->get_accessible)(gobj()), true);
8004
8005   typedef Glib::RefPtr<Atk::Object> RType;
8006   return RType();
8007 }
8008 #endif // GTKMM_ATKMM_ENABLED
8009 void Gtk::Widget::on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen)
8010 {
8011   BaseClassType *const base = static_cast<BaseClassType*>(
8012       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
8013   );
8014
8015   if(base && base->screen_changed)
8016     (*base->screen_changed)(gobj(),Glib::unwrap(previous_screen));
8017 }
8018 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
8019
8020 #ifdef GLIBMM_VFUNCS_ENABLED
8021 void Gtk::Widget::dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2)
8022 {
8023   BaseClassType *const base = static_cast<BaseClassType*>(
8024       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
8025   );
8026
8027   if(base && base->dispatch_child_properties_changed)
8028     (*base->dispatch_child_properties_changed)(gobj(),p1,p2);
8029 }
8030 void Gtk::Widget::show_all_vfunc()
8031 {
8032   BaseClassType *const base = static_cast<BaseClassType*>(
8033       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
8034   );
8035
8036   if(base && base->show_all)
8037     (*base->show_all)(gobj());
8038 }
8039 void Gtk::Widget::hide_all_vfunc()
8040 {
8041   BaseClassType *const base = static_cast<BaseClassType*>(
8042       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
8043   );
8044
8045   if(base && base->hide_all)
8046     (*base->hide_all)(gobj());
8047 }
8048 #ifdef GTKMM_ATKMM_ENABLED
8049 Glib::RefPtr<Atk::Object> Gtk::Widget::get_accessible_vfunc()
8050 {
8051   BaseClassType *const base = static_cast<BaseClassType*>(
8052       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
8053   );
8054
8055   if(base && base->get_accessible)
8056     return Glib::wrap((*base->get_accessible)(gobj()), true);
8057
8058   typedef Glib::RefPtr<Atk::Object> RType;
8059   return RType();
8060 }
8061 #endif // GTKMM_ATKMM_ENABLED
8062 #endif //GLIBMM_VFUNCS_ENABLED
8063
8064
8065 } // namespace Gtk
8066
8067