libs/gtkmm2/gtk/gtkmm/expander.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <gtkmm/expander.h>
   4 #include <gtkmm/private/expander_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/gtkexpander.h>
  29
  30 namespace Gtk
  31 {
  32
  33 Expander::Expander(const Glib::ustring& label, bool mnemonic)
  34 :
  35   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
  36   Gtk::Bin(Glib::ConstructParams(expander_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
  37 {}
  38
  39 } // namespace Gtk
  40
  41
  42 namespace
  43 {
  44 } // anonymous namespace
  45
  46
  47 namespace Glib
  48 {
  49
  50 Gtk::Expander* wrap(GtkExpander* object, bool take_copy)
  51 {
  52   return dynamic_cast<Gtk::Expander *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  53 }
  54
  55 } /* namespace Glib */
  56
  57 namespace Gtk
  58 {
  59
  60
  61 /* The *_Class implementation: */
  62
  63 const Glib::Class& Expander_Class::init()
  64 {
  65   if(!gtype_) // create the GType if necessary
  66   {
  67     // Glib::Class has to know the class init function to clone custom types.
  68     class_init_func_ = &Expander_Class::class_init_function;
  69
  70     // This is actually just optimized away, apparently with no harm.
  71     // Make sure that the parent type has been created.
  72     //CppClassParent::CppObjectType::get_type();
  73
  74     // Create the wrapper type, with the same class/instance size as the base type.
  75     register_derived_type(gtk_expander_get_type());
  76
  77     // Add derived versions of interfaces, if the C type implements any interfaces:
  78   }
  79
  80   return *this;
  81 }
  82
  83 void Expander_Class::class_init_function(void* g_class, void* class_data)
  84 {
  85   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  86   CppClassParent::class_init_function(klass, class_data);
  87
  88 }
  89
  90
  91 Glib::ObjectBase* Expander_Class::wrap_new(GObject* o)
  92 {
  93   return manage(new Expander((GtkExpander*)(o)));
  94
  95 }
  96
  97
  98 /* The implementation: */
  99
 100 Expander::Expander(const Glib::ConstructParams& construct_params)
 101 :
 102   Gtk::Bin(construct_params)
 103 {
 104   }
 105
 106 Expander::Expander(GtkExpander* castitem)
 107 :
 108   Gtk::Bin((GtkBin*)(castitem))
 109 {
 110   }
 111
 112 Expander::~Expander()
 113 {
 114   destroy_();
 115 }
 116
 117 Expander::CppClassType Expander::expander_class_; // initialize static member
 118
 119 GType Expander::get_type()
 120 {
 121   return expander_class_.init().get_type();
 122 }
 123
 124 GType Expander::get_base_type()
 125 {
 126   return gtk_expander_get_type();
 127 }
 128
 129
 130 Expander::Expander()
 131 :
 132   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 133   Gtk::Bin(Glib::ConstructParams(expander_class_.init()))
 134 {
 135   }
 136
 137 void Expander::set_expanded(bool expanded)
 138 {
 139   gtk_expander_set_expanded(gobj(), static_cast<int>(expanded));
 140 }
 141
 142 bool Expander::get_expanded() const
 143 {
 144   return gtk_expander_get_expanded(const_cast<GtkExpander*>(gobj()));
 145 }
 146
 147 void Expander::set_spacing(int spacing)
 148 {
 149   gtk_expander_set_spacing(gobj(), spacing);
 150 }
 151
 152 int Expander::get_spacing() const
 153 {
 154   return gtk_expander_get_spacing(const_cast<GtkExpander*>(gobj()));
 155 }
 156
 157 void Expander::set_label(const Glib::ustring& label)
 158 {
 159   gtk_expander_set_label(gobj(), label.c_str());
 160 }
 161
 162 Glib::ustring Expander::get_label() const
 163 {
 164   return Glib::convert_const_gchar_ptr_to_ustring(gtk_expander_get_label(const_cast<GtkExpander*>(gobj())));
 165 }
 166
 167 void Expander::set_use_underline(bool use_underline)
 168 {
 169   gtk_expander_set_use_underline(gobj(), static_cast<int>(use_underline));
 170 }
 171
 172 bool Expander::get_use_underline() const
 173 {
 174   return gtk_expander_get_use_underline(const_cast<GtkExpander*>(gobj()));
 175 }
 176
 177 void Expander::set_use_markup(bool use_markup)
 178 {
 179   gtk_expander_set_use_markup(gobj(), static_cast<int>(use_markup));
 180 }
 181
 182 bool Expander::get_use_markup() const
 183 {
 184   return gtk_expander_get_use_markup(const_cast<GtkExpander*>(gobj()));
 185 }
 186
 187 void Expander::set_label_widget(Widget& label_widget)
 188 {
 189   gtk_expander_set_label_widget(gobj(), (label_widget).gobj());
 190 }
 191
 192 Widget* Expander::get_label_widget()
 193 {
 194   return Glib::wrap(gtk_expander_get_label_widget(gobj()));
 195 }
 196
 197 const Widget* Expander::get_label_widget() const
 198 {
 199   return Glib::wrap(gtk_expander_get_label_widget(const_cast<GtkExpander*>(gobj())));
 200 }
 201
 202
 203 Glib::PropertyProxy<bool> Expander::property_expanded()
 204 {
 205   return Glib::PropertyProxy<bool>(this, "expanded");
 206 }
 207
 208 Glib::PropertyProxy_ReadOnly<bool> Expander::property_expanded() const
 209 {
 210   return Glib::PropertyProxy_ReadOnly<bool>(this, "expanded");
 211 }
 212
 213 Glib::PropertyProxy<Glib::ustring> Expander::property_label()
 214 {
 215   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 216 }
 217
 218 Glib::PropertyProxy_ReadOnly<Glib::ustring> Expander::property_label() const
 219 {
 220   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 221 }
 222
 223 Glib::PropertyProxy<bool> Expander::property_use_underline()
 224 {
 225   return Glib::PropertyProxy<bool>(this, "use-underline");
 226 }
 227
 228 Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_underline() const
 229 {
 230   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
 231 }
 232
 233 Glib::PropertyProxy<bool> Expander::property_use_markup()
 234 {
 235   return Glib::PropertyProxy<bool>(this, "use-markup");
 236 }
 237
 238 Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_markup() const
 239 {
 240   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
 241 }
 242
 243 Glib::PropertyProxy<int> Expander::property_spacing()
 244 {
 245   return Glib::PropertyProxy<int>(this, "spacing");
 246 }
 247
 248 Glib::PropertyProxy_ReadOnly<int> Expander::property_spacing() const
 249 {
 250   return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
 251 }
 252
 253 Glib::PropertyProxy<Widget*> Expander::property_label_widget()
 254 {
 255   return Glib::PropertyProxy<Widget*>(this, "label-widget");
 256 }
 257
 258 Glib::PropertyProxy_ReadOnly<Widget*> Expander::property_label_widget() const
 259 {
 260   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "label-widget");
 261 }
 262
 263
 264 } // namespace Gtk
 265
 266