libs/gtkmm2/gtk/gtkmm/uimanager.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/uimanager.h>
   5 #include <gtkmm/private/uimanager_p.h>
   6
   7 // -*- c++ -*-
   8 /* $Id$ */
   9
  10 /* Copyright 2003 The gtkmm Development Team
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Library General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with this library; if not, write to the Free
  24  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #include <gtk/gtkuimanager.h>
  28
  29
  30 namespace Gtk
  31 {
  32
  33 typedef UIManager::ui_merge_id ui_merge_id; //Help gmmproc so that it does not need to add the full type name for the return type.
  34
  35 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  36 UIManager::ui_merge_id UIManager::add_ui_from_string(const Glib::ustring& buffer)
  37 #else
  38 UIManager::ui_merge_id UIManager::add_ui_from_string(const Glib::ustring& buffer, std::auto_ptr<Glib::Error>& error)
  39 #endif //GLIBMM_EXCEPTIONS_ENABLED
  40 {
  41   GError* gerror = 0;
  42   guint retvalue = gtk_ui_manager_add_ui_from_string(gobj(), buffer.c_str(), buffer.size(), &(gerror));
  43
  44   if (gerror)
  45   {
  46 #ifdef GLIBMM_EXCEPTIONS_ENABLED
  47   ::Glib::Error::throw_exception(gerror);
  48 #else
  49   error = ::Glib::Error::throw_exception(gerror);
  50 #endif //GLIBMM_EXCEPTIONS_ENABLED
  51   }
  52   return retvalue;
  53 }
  54
  55 void UIManager::add_ui_separator(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name, UIManagerItemType type, bool top)
  56 {
  57   gtk_ui_manager_add_ui(gobj(), merge_id, path.c_str(), name.c_str(), 0 /* See C docs */, ((GtkUIManagerItemType)(type)), static_cast<int>(top));
  58 }
  59
  60
  61 } // namespace Gtk
  62
  63
  64 namespace
  65 {
  66
  67
  68 static void UIManager_signal_add_widget_callback(GtkUIManager* self, GtkWidget* p0,void* data)
  69 {
  70   using namespace Gtk;
  71   typedef sigc::slot< void,Widget* > SlotType;
  72
  73   // Do not try to call a signal on a disassociated wrapper.
  74   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  75   {
  76     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  77     try
  78     {
  79     #endif //GLIBMM_EXCEPTIONS_ENABLED
  80       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  81         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
  82 );
  83     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  84     }
  85     catch(...)
  86     {
  87       Glib::exception_handlers_invoke();
  88     }
  89     #endif //GLIBMM_EXCEPTIONS_ENABLED
  90   }
  91 }
  92
  93 static const Glib::SignalProxyInfo UIManager_signal_add_widget_info =
  94 {
  95   "add_widget",
  96   (GCallback) &UIManager_signal_add_widget_callback,
  97   (GCallback) &UIManager_signal_add_widget_callback
  98 };
  99
 100
 101 static const Glib::SignalProxyInfo UIManager_signal_actions_changed_info =
 102 {
 103   "actions_changed",
 104   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 105   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 106 };
 107
 108
 109 static void UIManager_signal_connect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
 110 {
 111   using namespace Gtk;
 112   typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
 113
 114   // Do not try to call a signal on a disassociated wrapper.
 115   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 116   {
 117     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 118     try
 119     {
 120     #endif //GLIBMM_EXCEPTIONS_ENABLED
 121       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 122         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 123 , Glib::wrap(p1)
 124 );
 125     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 126     }
 127     catch(...)
 128     {
 129       Glib::exception_handlers_invoke();
 130     }
 131     #endif //GLIBMM_EXCEPTIONS_ENABLED
 132   }
 133 }
 134
 135 static const Glib::SignalProxyInfo UIManager_signal_connect_proxy_info =
 136 {
 137   "connect_proxy",
 138   (GCallback) &UIManager_signal_connect_proxy_callback,
 139   (GCallback) &UIManager_signal_connect_proxy_callback
 140 };
 141
 142
 143 static void UIManager_signal_disconnect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
 144 {
 145   using namespace Gtk;
 146   typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
 147
 148   // Do not try to call a signal on a disassociated wrapper.
 149   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 150   {
 151     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 152     try
 153     {
 154     #endif //GLIBMM_EXCEPTIONS_ENABLED
 155       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 156         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 157 , Glib::wrap(p1)
 158 );
 159     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 160     }
 161     catch(...)
 162     {
 163       Glib::exception_handlers_invoke();
 164     }
 165     #endif //GLIBMM_EXCEPTIONS_ENABLED
 166   }
 167 }
 168
 169 static const Glib::SignalProxyInfo UIManager_signal_disconnect_proxy_info =
 170 {
 171   "disconnect_proxy",
 172   (GCallback) &UIManager_signal_disconnect_proxy_callback,
 173   (GCallback) &UIManager_signal_disconnect_proxy_callback
 174 };
 175
 176
 177 static void UIManager_signal_pre_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
 178 {
 179   using namespace Gtk;
 180   typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
 181
 182   // Do not try to call a signal on a disassociated wrapper.
 183   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 184   {
 185     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 186     try
 187     {
 188     #endif //GLIBMM_EXCEPTIONS_ENABLED
 189       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 190         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 191 );
 192     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 193     }
 194     catch(...)
 195     {
 196       Glib::exception_handlers_invoke();
 197     }
 198     #endif //GLIBMM_EXCEPTIONS_ENABLED
 199   }
 200 }
 201
 202 static const Glib::SignalProxyInfo UIManager_signal_pre_activate_info =
 203 {
 204   "pre_activate",
 205   (GCallback) &UIManager_signal_pre_activate_callback,
 206   (GCallback) &UIManager_signal_pre_activate_callback
 207 };
 208
 209
 210 static void UIManager_signal_post_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
 211 {
 212   using namespace Gtk;
 213   typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
 214
 215   // Do not try to call a signal on a disassociated wrapper.
 216   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 217   {
 218     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 219     try
 220     {
 221     #endif //GLIBMM_EXCEPTIONS_ENABLED
 222       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 223         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 224 );
 225     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 226     }
 227     catch(...)
 228     {
 229       Glib::exception_handlers_invoke();
 230     }
 231     #endif //GLIBMM_EXCEPTIONS_ENABLED
 232   }
 233 }
 234
 235 static const Glib::SignalProxyInfo UIManager_signal_post_activate_info =
 236 {
 237   "post_activate",
 238   (GCallback) &UIManager_signal_post_activate_callback,
 239   (GCallback) &UIManager_signal_post_activate_callback
 240 };
 241
 242
 243 } // anonymous namespace
 244
 245 // static
 246 GType Glib::Value<Gtk::UIManagerItemType>::value_type()
 247 {
 248   return gtk_ui_manager_item_type_get_type();
 249 }
 250
 251
 252 namespace Glib
 253 {
 254
 255 Glib::RefPtr<Gtk::UIManager> wrap(GtkUIManager* object, bool take_copy)
 256 {
 257   return Glib::RefPtr<Gtk::UIManager>( dynamic_cast<Gtk::UIManager*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
 258   //We use dynamic_cast<> in case of multiple inheritance.
 259 }
 260
 261 } /* namespace Glib */
 262
 263
 264 namespace Gtk
 265 {
 266
 267
 268 /* The *_Class implementation: */
 269
 270 const Glib::Class& UIManager_Class::init()
 271 {
 272   if(!gtype_) // create the GType if necessary
 273   {
 274     // Glib::Class has to know the class init function to clone custom types.
 275     class_init_func_ = &UIManager_Class::class_init_function;
 276
 277     // This is actually just optimized away, apparently with no harm.
 278     // Make sure that the parent type has been created.
 279     //CppClassParent::CppObjectType::get_type();
 280
 281     // Create the wrapper type, with the same class/instance size as the base type.
 282     register_derived_type(gtk_ui_manager_get_type());
 283
 284     // Add derived versions of interfaces, if the C type implements any interfaces:
 285   }
 286
 287   return *this;
 288 }
 289
 290 void UIManager_Class::class_init_function(void* g_class, void* class_data)
 291 {
 292   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 293   CppClassParent::class_init_function(klass, class_data);
 294
 295 #ifdef GLIBMM_VFUNCS_ENABLED
 296 #endif //GLIBMM_VFUNCS_ENABLED
 297
 298 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 299   klass->add_widget = &add_widget_callback;
 300   klass->actions_changed = &actions_changed_callback;
 301 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 302 }
 303
 304 #ifdef GLIBMM_VFUNCS_ENABLED
 305 #endif //GLIBMM_VFUNCS_ENABLED
 306
 307 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 308 void UIManager_Class::add_widget_callback(GtkUIManager* self, GtkWidget* p0)
 309 {
 310   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 311       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 312
 313   // Non-gtkmmproc-generated custom classes implicitly call the default
 314   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 315   // generated classes can use this optimisation, which avoids the unnecessary
 316   // parameter conversions if there is no possibility of the virtual function
 317   // being overridden:
 318   if(obj_base && obj_base->is_derived_())
 319   {
 320     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 321     if(obj) // This can be NULL during destruction.
 322     {
 323       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 324       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 325       {
 326       #endif //GLIBMM_EXCEPTIONS_ENABLED
 327         // Call the virtual member method, which derived classes might override.
 328         obj->on_add_widget(Glib::wrap(p0)
 329 );
 330         return;
 331       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 332       }
 333       catch(...)
 334       {
 335         Glib::exception_handlers_invoke();
 336       }
 337       #endif //GLIBMM_EXCEPTIONS_ENABLED
 338     }
 339   }
 340
 341   BaseClassType *const base = static_cast<BaseClassType*>(
 342         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 343     );
 344
 345   // Call the original underlying C function:
 346   if(base && base->add_widget)
 347     (*base->add_widget)(self, p0);
 348 }
 349 void UIManager_Class::actions_changed_callback(GtkUIManager* self)
 350 {
 351   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 352       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 353
 354   // Non-gtkmmproc-generated custom classes implicitly call the default
 355   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 356   // generated classes can use this optimisation, which avoids the unnecessary
 357   // parameter conversions if there is no possibility of the virtual function
 358   // being overridden:
 359   if(obj_base && obj_base->is_derived_())
 360   {
 361     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 362     if(obj) // This can be NULL during destruction.
 363     {
 364       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 365       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 366       {
 367       #endif //GLIBMM_EXCEPTIONS_ENABLED
 368         // Call the virtual member method, which derived classes might override.
 369         obj->on_actions_changed();
 370         return;
 371       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 372       }
 373       catch(...)
 374       {
 375         Glib::exception_handlers_invoke();
 376       }
 377       #endif //GLIBMM_EXCEPTIONS_ENABLED
 378     }
 379   }
 380
 381   BaseClassType *const base = static_cast<BaseClassType*>(
 382         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 383     );
 384
 385   // Call the original underlying C function:
 386   if(base && base->actions_changed)
 387     (*base->actions_changed)(self);
 388 }
 389 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 390
 391
 392 Glib::ObjectBase* UIManager_Class::wrap_new(GObject* object)
 393 {
 394   return new UIManager((GtkUIManager*)object);
 395 }
 396
 397
 398 /* The implementation: */
 399
 400 GtkUIManager* UIManager::gobj_copy()
 401 {
 402   reference();
 403   return gobj();
 404 }
 405
 406 UIManager::UIManager(const Glib::ConstructParams& construct_params)
 407 :
 408   Glib::Object(construct_params)
 409 {}
 410
 411 UIManager::UIManager(GtkUIManager* castitem)
 412 :
 413   Glib::Object((GObject*)(castitem))
 414 {}
 415
 416 UIManager::~UIManager()
 417 {}
 418
 419
 420 UIManager::CppClassType UIManager::uimanager_class_; // initialize static member
 421
 422 GType UIManager::get_type()
 423 {
 424   return uimanager_class_.init().get_type();
 425 }
 426
 427 GType UIManager::get_base_type()
 428 {
 429   return gtk_ui_manager_get_type();
 430 }
 431
 432
 433 UIManager::UIManager()
 434 :
 435   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 436   Glib::ObjectBase(0),
 437   Glib::Object(Glib::ConstructParams(uimanager_class_.init()))
 438 {
 439   }
 440
 441 Glib::RefPtr<UIManager> UIManager::create()
 442 {
 443   return Glib::RefPtr<UIManager>( new UIManager() );
 444 }
 445 void UIManager::set_add_tearoffs(bool add_tearoffs)
 446 {
 447 gtk_ui_manager_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs));
 448 }
 449
 450 bool UIManager::get_add_tearoffs() const
 451 {
 452   return gtk_ui_manager_get_add_tearoffs(const_cast<GtkUIManager*>(gobj()));
 453 }
 454
 455 void UIManager::insert_action_group(const Glib::RefPtr<ActionGroup>& action_group, int pos)
 456 {
 457 gtk_ui_manager_insert_action_group(gobj(), Glib::unwrap(action_group), pos);
 458 }
 459
 460 void UIManager::remove_action_group(const Glib::RefPtr<ActionGroup>& action_group)
 461 {
 462 gtk_ui_manager_remove_action_group(gobj(), Glib::unwrap(action_group));
 463 }
 464
 465 Glib::ListHandle< Glib::RefPtr<ActionGroup> > UIManager::get_action_groups()
 466 {
 467   return Glib::ListHandle< Glib::RefPtr<ActionGroup> >(gtk_ui_manager_get_action_groups(gobj()), Glib::OWNERSHIP_NONE);
 468 }
 469
 470 Glib::ListHandle< Glib::RefPtr<const ActionGroup> > UIManager::get_action_groups() const
 471 {
 472   return Glib::ListHandle< Glib::RefPtr<const ActionGroup> >(gtk_ui_manager_get_action_groups(const_cast<GtkUIManager*>(gobj())), Glib::OWNERSHIP_SHALLOW);
 473 }
 474
 475 Glib::RefPtr<AccelGroup> UIManager::get_accel_group()
 476 {
 477
 478   Glib::RefPtr<AccelGroup> retvalue = Glib::wrap(gtk_ui_manager_get_accel_group(gobj()));
 479   if(retvalue)
 480     retvalue->reference(); //The function does not do a ref for us.
 481   return retvalue;
 482
 483 }
 484
 485 Glib::RefPtr<const AccelGroup> UIManager::get_accel_group() const
 486 {
 487   return const_cast<UIManager*>(this)->get_accel_group();
 488 }
 489
 490 Widget* UIManager::get_widget(const Glib::ustring& path)
 491 {
 492   return Glib::wrap(gtk_ui_manager_get_widget(gobj(), path.c_str()));
 493 }
 494
 495 const Widget* UIManager::get_widget(const Glib::ustring& path) const
 496 {
 497   return const_cast<UIManager*>(this)->get_widget(path);
 498 }
 499
 500 Glib::SListHandle<Widget*> UIManager::get_toplevels(UIManagerItemType types)
 501 {
 502   return Glib::SListHandle<Widget*>(gtk_ui_manager_get_toplevels(gobj(), ((GtkUIManagerItemType)(types))), Glib::OWNERSHIP_SHALLOW);
 503 }
 504
 505 Glib::SListHandle<const Widget*> UIManager::get_toplevels(UIManagerItemType types) const
 506 {
 507   return Glib::SListHandle<const Widget*>(gtk_ui_manager_get_toplevels(const_cast<GtkUIManager*>(gobj()), ((GtkUIManagerItemType)(types))), Glib::OWNERSHIP_SHALLOW);
 508 }
 509
 510 Glib::RefPtr<Action> UIManager::get_action(const Glib::ustring& path)
 511 {
 512
 513   Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_ui_manager_get_action(gobj(), path.c_str()));
 514   if(retvalue)
 515     retvalue->reference(); //The function does not do a ref for us.
 516   return retvalue;
 517
 518 }
 519
 520 Glib::RefPtr<const Action> UIManager::get_action(const Glib::ustring& path) const
 521 {
 522   return const_cast<UIManager*>(this)->get_action(path);
 523 }
 524
 525 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 526 ui_merge_id UIManager::add_ui_from_file(const Glib::ustring& filename)
 527 #else
 528 ui_merge_id UIManager::add_ui_from_file(const Glib::ustring& filename, std::auto_ptr<Glib::Error>& error)
 529 #endif //GLIBMM_EXCEPTIONS_ENABLED
 530 {
 531   GError* gerror = 0;
 532   ui_merge_id retvalue = gtk_ui_manager_add_ui_from_file(gobj(), filename.c_str(), &(gerror));
 533 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 534   if(gerror)
 535     ::Glib::Error::throw_exception(gerror);
 536 #else
 537   if(gerror)
 538     error = ::Glib::Error::throw_exception(gerror);
 539 #endif //GLIBMM_EXCEPTIONS_ENABLED
 540
 541   return retvalue;
 542
 543 }
 544
 545 void UIManager::add_ui(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name, const Glib::ustring& action, UIManagerItemType type, bool top)
 546 {
 547 gtk_ui_manager_add_ui(gobj(), merge_id, path.c_str(), name.c_str(), action.c_str(), ((GtkUIManagerItemType)(type)), static_cast<int>(top));
 548 }
 549
 550 void UIManager::remove_ui(ui_merge_id merge_id)
 551 {
 552 gtk_ui_manager_remove_ui(gobj(), merge_id);
 553 }
 554
 555 Glib::ustring UIManager::get_ui() const
 556 {
 557   return Glib::convert_return_gchar_ptr_to_ustring(gtk_ui_manager_get_ui(const_cast<GtkUIManager*>(gobj())));
 558 }
 559
 560 void UIManager::ensure_update()
 561 {
 562 gtk_ui_manager_ensure_update(gobj());
 563 }
 564
 565 ui_merge_id UIManager::new_merge_id()
 566 {
 567   return gtk_ui_manager_new_merge_id(gobj());
 568 }
 569
 570
 571 Glib::SignalProxy1< void,Widget* > UIManager::signal_add_widget()
 572 {
 573   return Glib::SignalProxy1< void,Widget* >(this, &UIManager_signal_add_widget_info);
 574 }
 575
 576
 577 Glib::SignalProxy0< void > UIManager::signal_actions_changed()
 578 {
 579   return Glib::SignalProxy0< void >(this, &UIManager_signal_actions_changed_info);
 580 }
 581
 582
 583 Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > UIManager::signal_connect_proxy()
 584 {
 585   return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &UIManager_signal_connect_proxy_info);
 586 }
 587
 588
 589 Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > UIManager::signal_disconnect_proxy()
 590 {
 591   return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &UIManager_signal_disconnect_proxy_info);
 592 }
 593
 594
 595 Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > UIManager::signal_pre_activate()
 596 {
 597   return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &UIManager_signal_pre_activate_info);
 598 }
 599
 600
 601 Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > UIManager::signal_post_activate()
 602 {
 603   return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &UIManager_signal_post_activate_info);
 604 }
 605
 606
 607 #ifdef GLIBMM_PROPERTIES_ENABLED
 608 Glib::PropertyProxy<bool> UIManager::property_add_tearoffs()
 609 {
 610   return Glib::PropertyProxy<bool>(this, "add-tearoffs");
 611 }
 612 #endif //GLIBMM_PROPERTIES_ENABLED
 613
 614 #ifdef GLIBMM_PROPERTIES_ENABLED
 615 Glib::PropertyProxy_ReadOnly<bool> UIManager::property_add_tearoffs() const
 616 {
 617   return Glib::PropertyProxy_ReadOnly<bool>(this, "add-tearoffs");
 618 }
 619 #endif //GLIBMM_PROPERTIES_ENABLED
 620
 621 #ifdef GLIBMM_PROPERTIES_ENABLED
 622 Glib::PropertyProxy_ReadOnly<Glib::ustring> UIManager::property_ui() const
 623 {
 624   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "ui");
 625 }
 626 #endif //GLIBMM_PROPERTIES_ENABLED
 627
 628
 629 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 630 void Gtk::UIManager::on_add_widget(Widget* widget)
 631 {
 632   BaseClassType *const base = static_cast<BaseClassType*>(
 633       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 634   );
 635
 636   if(base && base->add_widget)
 637     (*base->add_widget)(gobj(),(GtkWidget*)Glib::unwrap(widget));
 638 }
 639 void Gtk::UIManager::on_actions_changed()
 640 {
 641   BaseClassType *const base = static_cast<BaseClassType*>(
 642       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 643   );
 644
 645   if(base && base->actions_changed)
 646     (*base->actions_changed)(gobj());
 647 }
 648 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 649
 650 #ifdef GLIBMM_VFUNCS_ENABLED
 651 #endif //GLIBMM_VFUNCS_ENABLED
 652
 653
 654 } // namespace Gtk
 655
 656