libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <gtkmm/toggletoolbutton.h>
   4 #include <gtkmm/private/toggletoolbutton_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/gtktoggletoolbutton.h>
  29
  30 namespace Gtk
  31 {
  32
  33 ToggleToolButton::ToggleToolButton(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(toggletoolbutton_class_.init(), "label", label.c_str(), (char*) 0))
  37 {
  38 }
  39
  40 ToggleToolButton::ToggleToolButton(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(toggletoolbutton_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 ToggleToolButton_signal_toggled_info =
  54 {
  55   "toggled",
  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::ToggleToolButton* wrap(GtkToggleToolButton* object, bool take_copy)
  67 {
  68   return dynamic_cast<Gtk::ToggleToolButton *> (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& ToggleToolButton_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_ = &ToggleToolButton_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_toggle_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 ToggleToolButton_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->toggled = &toggled_callback;
 105 }
 106
 107
 108 void ToggleToolButton_Class::toggled_callback(GtkToggleToolButton* 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_toggled();
 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->toggled)
 138       (*base->toggled)(self);
 139   }
 140 }
 141
 142
 143 Glib::ObjectBase* ToggleToolButton_Class::wrap_new(GObject* o)
 144 {
 145   return manage(new ToggleToolButton((GtkToggleToolButton*)(o)));
 146
 147 }
 148
 149
 150 /* The implementation: */
 151
 152 ToggleToolButton::ToggleToolButton(const Glib::ConstructParams& construct_params)
 153 :
 154   Gtk::ToolButton(construct_params)
 155 {
 156   }
 157
 158 ToggleToolButton::ToggleToolButton(GtkToggleToolButton* castitem)
 159 :
 160   Gtk::ToolButton((GtkToolButton*)(castitem))
 161 {
 162   }
 163
 164 ToggleToolButton::~ToggleToolButton()
 165 {
 166   destroy_();
 167 }
 168
 169 ToggleToolButton::CppClassType ToggleToolButton::toggletoolbutton_class_; // initialize static member
 170
 171 GType ToggleToolButton::get_type()
 172 {
 173   return toggletoolbutton_class_.init().get_type();
 174 }
 175
 176 GType ToggleToolButton::get_base_type()
 177 {
 178   return gtk_toggle_tool_button_get_type();
 179 }
 180
 181
 182 ToggleToolButton::ToggleToolButton()
 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(toggletoolbutton_class_.init()))
 186 {
 187   }
 188
 189 ToggleToolButton::ToggleToolButton(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(toggletoolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
 193 {
 194   }
 195
 196 void ToggleToolButton::set_active(bool is_active)
 197 {
 198   gtk_toggle_tool_button_set_active(gobj(), static_cast<int>(is_active));
 199 }
 200
 201 bool ToggleToolButton::get_active() const
 202 {
 203   return gtk_toggle_tool_button_get_active(const_cast<GtkToggleToolButton*>(gobj()));
 204 }
 205
 206
 207 Glib::SignalProxy0< void > ToggleToolButton::signal_toggled()
 208 {
 209   return Glib::SignalProxy0< void >(this, &ToggleToolButton_signal_toggled_info);
 210 }
 211
 212
 213 void Gtk::ToggleToolButton::on_toggled()
 214 {
 215   BaseClassType *const base = static_cast<BaseClassType*>(
 216       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 217   );
 218
 219   if(base && base->toggled)
 220     (*base->toggled)(gobj());
 221 }
 222
 223
 224 } // namespace Gtk
 225
 226