libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <gtkmm/menutoolbutton.h>
   4 #include <gtkmm/private/menutoolbutton_p.h>
   5
   6 // -*- c++ -*-
   7 /* $Id$ */
   8
   9 /*
  10  *
  11  * Copyright 2003 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 <gtk/gtkmenutoolbutton.h>
  29
  30 namespace Gtk
  31 {
  32
  33 MenuToolButton::MenuToolButton(const Glib::ustring& label)
  34 :
  35   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
  36   Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init(), "label", label.c_str(), (char*) 0))
  37 {
  38 }
  39
  40 MenuToolButton::MenuToolButton(Widget& icon_widget, const Glib::ustring& label)
  41 :
  42   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
  43   Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init(), "icon_widget", (icon_widget).gobj(), "label", label.c_str(), (char*) 0))
  44 {
  45 }
  46
  47 } // namespace Gtk
  48
  49
  50 namespace
  51 {
  52
  53 const Glib::SignalProxyInfo MenuToolButton_signal_show_menu_info =
  54 {
  55   "show_menu",
  56   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  57   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
  58 };
  59
  60 } // anonymous namespace
  61
  62
  63 namespace Glib
  64 {
  65
  66 Gtk::MenuToolButton* wrap(GtkMenuToolButton* object, bool take_copy)
  67 {
  68   return dynamic_cast<Gtk::MenuToolButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  69 }
  70
  71 } /* namespace Glib */
  72
  73 namespace Gtk
  74 {
  75
  76
  77 /* The *_Class implementation: */
  78
  79 const Glib::Class& MenuToolButton_Class::init()
  80 {
  81   if(!gtype_) // create the GType if necessary
  82   {
  83     // Glib::Class has to know the class init function to clone custom types.
  84     class_init_func_ = &MenuToolButton_Class::class_init_function;
  85
  86     // This is actually just optimized away, apparently with no harm.
  87     // Make sure that the parent type has been created.
  88     //CppClassParent::CppObjectType::get_type();
  89
  90     // Create the wrapper type, with the same class/instance size as the base type.
  91     register_derived_type(gtk_menu_tool_button_get_type());
  92
  93     // Add derived versions of interfaces, if the C type implements any interfaces:
  94   }
  95
  96   return *this;
  97 }
  98
  99 void MenuToolButton_Class::class_init_function(void* g_class, void* class_data)
 100 {
 101   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 102   CppClassParent::class_init_function(klass, class_data);
 103
 104   klass->show_menu = &show_menu_callback;
 105 }
 106
 107
 108 void MenuToolButton_Class::show_menu_callback(GtkMenuToolButton* self)
 109 {
 110   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 111       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 112
 113   // Non-gtkmmproc-generated custom classes implicitly call the default
 114   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 115   // generated classes can use this optimisation, which avoids the unnecessary
 116   // parameter conversions if there is no possibility of the virtual function
 117   // being overridden:
 118   if(obj && obj->is_derived_())
 119   {
 120     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 121     {
 122       // Call the virtual member method, which derived classes might override.
 123       obj->on_show_menu();
 124     }
 125     catch(...)
 126     {
 127       Glib::exception_handlers_invoke();
 128     }
 129   }
 130   else
 131   {
 132     BaseClassType *const base = static_cast<BaseClassType*>(
 133         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 134     );
 135
 136     // Call the original underlying C function:
 137     if(base && base->show_menu)
 138       (*base->show_menu)(self);
 139   }
 140 }
 141
 142
 143 Glib::ObjectBase* MenuToolButton_Class::wrap_new(GObject* o)
 144 {
 145   return manage(new MenuToolButton((GtkMenuToolButton*)(o)));
 146
 147 }
 148
 149
 150 /* The implementation: */
 151
 152 MenuToolButton::MenuToolButton(const Glib::ConstructParams& construct_params)
 153 :
 154   Gtk::ToolButton(construct_params)
 155 {
 156   }
 157
 158 MenuToolButton::MenuToolButton(GtkMenuToolButton* castitem)
 159 :
 160   Gtk::ToolButton((GtkToolButton*)(castitem))
 161 {
 162   }
 163
 164 MenuToolButton::~MenuToolButton()
 165 {
 166   destroy_();
 167 }
 168
 169 MenuToolButton::CppClassType MenuToolButton::menutoolbutton_class_; // initialize static member
 170
 171 GType MenuToolButton::get_type()
 172 {
 173   return menutoolbutton_class_.init().get_type();
 174 }
 175
 176 GType MenuToolButton::get_base_type()
 177 {
 178   return gtk_menu_tool_button_get_type();
 179 }
 180
 181
 182 MenuToolButton::MenuToolButton()
 183 :
 184   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 185   Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init()))
 186 {
 187   }
 188
 189 MenuToolButton::MenuToolButton(const Gtk::StockID& stock_id)
 190 :
 191   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 192   Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
 193 {
 194   }
 195
 196 void MenuToolButton::set_menu(Menu& menu)
 197 {
 198   gtk_menu_tool_button_set_menu(gobj(), (menu).Gtk::Widget::gobj());
 199 }
 200
 201 Menu* MenuToolButton::get_menu()
 202 {
 203   return Glib::wrap((GtkMenu*)(gtk_menu_tool_button_get_menu(gobj())));
 204 }
 205
 206 const Menu* MenuToolButton::get_menu() const
 207 {
 208   return Glib::wrap((GtkMenu*)(gtk_menu_tool_button_get_menu(const_cast<GtkMenuToolButton*>(gobj()))));
 209 }
 210
 211 void MenuToolButton::set_arrow_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
 212 {
 213   gtk_menu_tool_button_set_arrow_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str());
 214 }
 215
 216
 217 Glib::SignalProxy0< void > MenuToolButton::signal_show_menu()
 218 {
 219   return Glib::SignalProxy0< void >(this, &MenuToolButton_signal_show_menu_info);
 220 }
 221
 222
 223 Glib::PropertyProxy<Menu*> MenuToolButton::property_menu()
 224 {
 225   return Glib::PropertyProxy<Menu*>(this, "menu");
 226 }
 227
 228 Glib::PropertyProxy_ReadOnly<Menu*> MenuToolButton::property_menu() const
 229 {
 230   return Glib::PropertyProxy_ReadOnly<Menu*>(this, "menu");
 231 }
 232
 233
 234 void Gtk::MenuToolButton::on_show_menu()
 235 {
 236   BaseClassType *const base = static_cast<BaseClassType*>(
 237       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 238   );
 239
 240   if(base && base->show_menu)
 241     (*base->show_menu)(gobj());
 242 }
 243
 244
 245 } // namespace Gtk
 246
 247