libs/gtkmm2/gtk/gtkmm/expander.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/expander.h>
   5 #include <gtkmm/private/expander_p.h>
   6
   7 // -*- c++ -*-
   8 /* $Id$ */
   9
  10 /*
  11  *
  12  * Copyright 2003 The gtkmm Development Team
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Library General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Library General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Library General Public
  25  * License along with this library; if not, write to the Free
  26  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27  */
  28
  29 #include <gtk/gtkexpander.h>
  30
  31 namespace Gtk
  32 {
  33
  34 Expander::Expander(const Glib::ustring& label, bool mnemonic)
  35 :
  36   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  37   Glib::ObjectBase(0),
  38   Gtk::Bin(Glib::ConstructParams(expander_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), static_cast<char*>(0)))
  39 {}
  40
  41 } // namespace Gtk
  42
  43
  44 namespace
  45 {
  46 } // anonymous namespace
  47
  48
  49 namespace Glib
  50 {
  51
  52 Gtk::Expander* wrap(GtkExpander* object, bool take_copy)
  53 {
  54   return dynamic_cast<Gtk::Expander *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  55 }
  56
  57 } /* namespace Glib */
  58
  59 namespace Gtk
  60 {
  61
  62
  63 /* The *_Class implementation: */
  64
  65 const Glib::Class& Expander_Class::init()
  66 {
  67   if(!gtype_) // create the GType if necessary
  68   {
  69     // Glib::Class has to know the class init function to clone custom types.
  70     class_init_func_ = &Expander_Class::class_init_function;
  71
  72     // This is actually just optimized away, apparently with no harm.
  73     // Make sure that the parent type has been created.
  74     //CppClassParent::CppObjectType::get_type();
  75
  76     // Create the wrapper type, with the same class/instance size as the base type.
  77     register_derived_type(gtk_expander_get_type());
  78
  79     // Add derived versions of interfaces, if the C type implements any interfaces:
  80   }
  81
  82   return *this;
  83 }
  84
  85 void Expander_Class::class_init_function(void* g_class, void* class_data)
  86 {
  87   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  88   CppClassParent::class_init_function(klass, class_data);
  89
  90 #ifdef GLIBMM_VFUNCS_ENABLED
  91 #endif //GLIBMM_VFUNCS_ENABLED
  92
  93 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  94 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  95 }
  96
  97 #ifdef GLIBMM_VFUNCS_ENABLED
  98 #endif //GLIBMM_VFUNCS_ENABLED
  99
 100 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 101 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 102
 103
 104 Glib::ObjectBase* Expander_Class::wrap_new(GObject* o)
 105 {
 106   return manage(new Expander((GtkExpander*)(o)));
 107
 108 }
 109
 110
 111 /* The implementation: */
 112
 113 Expander::Expander(const Glib::ConstructParams& construct_params)
 114 :
 115   Gtk::Bin(construct_params)
 116 {
 117   }
 118
 119 Expander::Expander(GtkExpander* castitem)
 120 :
 121   Gtk::Bin((GtkBin*)(castitem))
 122 {
 123   }
 124
 125 Expander::~Expander()
 126 {
 127   destroy_();
 128 }
 129
 130 Expander::CppClassType Expander::expander_class_; // initialize static member
 131
 132 GType Expander::get_type()
 133 {
 134   return expander_class_.init().get_type();
 135 }
 136
 137 GType Expander::get_base_type()
 138 {
 139   return gtk_expander_get_type();
 140 }
 141
 142
 143 Expander::Expander()
 144 :
 145   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 146   Glib::ObjectBase(0),
 147   Gtk::Bin(Glib::ConstructParams(expander_class_.init()))
 148 {
 149   }
 150
 151 void Expander::set_expanded(bool expanded)
 152 {
 153 gtk_expander_set_expanded(gobj(), static_cast<int>(expanded));
 154 }
 155
 156 bool Expander::get_expanded() const
 157 {
 158   return gtk_expander_get_expanded(const_cast<GtkExpander*>(gobj()));
 159 }
 160
 161 void Expander::set_spacing(int spacing)
 162 {
 163 gtk_expander_set_spacing(gobj(), spacing);
 164 }
 165
 166 int Expander::get_spacing() const
 167 {
 168   return gtk_expander_get_spacing(const_cast<GtkExpander*>(gobj()));
 169 }
 170
 171 void Expander::set_label(const Glib::ustring& label)
 172 {
 173 gtk_expander_set_label(gobj(), label.c_str());
 174 }
 175
 176 Glib::ustring Expander::get_label() const
 177 {
 178   return Glib::convert_const_gchar_ptr_to_ustring(gtk_expander_get_label(const_cast<GtkExpander*>(gobj())));
 179 }
 180
 181 void Expander::set_use_underline(bool use_underline)
 182 {
 183 gtk_expander_set_use_underline(gobj(), static_cast<int>(use_underline));
 184 }
 185
 186 bool Expander::get_use_underline() const
 187 {
 188   return gtk_expander_get_use_underline(const_cast<GtkExpander*>(gobj()));
 189 }
 190
 191 void Expander::set_use_markup(bool use_markup)
 192 {
 193 gtk_expander_set_use_markup(gobj(), static_cast<int>(use_markup));
 194 }
 195
 196 bool Expander::get_use_markup() const
 197 {
 198   return gtk_expander_get_use_markup(const_cast<GtkExpander*>(gobj()));
 199 }
 200
 201 void Expander::set_label_widget(Widget& label_widget)
 202 {
 203 gtk_expander_set_label_widget(gobj(), (label_widget).gobj());
 204 }
 205
 206 Widget* Expander::get_label_widget()
 207 {
 208   return Glib::wrap(gtk_expander_get_label_widget(gobj()));
 209 }
 210
 211 const Widget* Expander::get_label_widget() const
 212 {
 213   return const_cast<Expander*>(this)->get_label_widget();
 214 }
 215
 216
 217 #ifdef GLIBMM_PROPERTIES_ENABLED
 218 Glib::PropertyProxy<bool> Expander::property_expanded()
 219 {
 220   return Glib::PropertyProxy<bool>(this, "expanded");
 221 }
 222 #endif //GLIBMM_PROPERTIES_ENABLED
 223
 224 #ifdef GLIBMM_PROPERTIES_ENABLED
 225 Glib::PropertyProxy_ReadOnly<bool> Expander::property_expanded() const
 226 {
 227   return Glib::PropertyProxy_ReadOnly<bool>(this, "expanded");
 228 }
 229 #endif //GLIBMM_PROPERTIES_ENABLED
 230
 231 #ifdef GLIBMM_PROPERTIES_ENABLED
 232 Glib::PropertyProxy<Glib::ustring> Expander::property_label()
 233 {
 234   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 235 }
 236 #endif //GLIBMM_PROPERTIES_ENABLED
 237
 238 #ifdef GLIBMM_PROPERTIES_ENABLED
 239 Glib::PropertyProxy_ReadOnly<Glib::ustring> Expander::property_label() const
 240 {
 241   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 242 }
 243 #endif //GLIBMM_PROPERTIES_ENABLED
 244
 245 #ifdef GLIBMM_PROPERTIES_ENABLED
 246 Glib::PropertyProxy<bool> Expander::property_use_underline()
 247 {
 248   return Glib::PropertyProxy<bool>(this, "use-underline");
 249 }
 250 #endif //GLIBMM_PROPERTIES_ENABLED
 251
 252 #ifdef GLIBMM_PROPERTIES_ENABLED
 253 Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_underline() const
 254 {
 255   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
 256 }
 257 #endif //GLIBMM_PROPERTIES_ENABLED
 258
 259 #ifdef GLIBMM_PROPERTIES_ENABLED
 260 Glib::PropertyProxy<bool> Expander::property_use_markup()
 261 {
 262   return Glib::PropertyProxy<bool>(this, "use-markup");
 263 }
 264 #endif //GLIBMM_PROPERTIES_ENABLED
 265
 266 #ifdef GLIBMM_PROPERTIES_ENABLED
 267 Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_markup() const
 268 {
 269   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
 270 }
 271 #endif //GLIBMM_PROPERTIES_ENABLED
 272
 273 #ifdef GLIBMM_PROPERTIES_ENABLED
 274 Glib::PropertyProxy<int> Expander::property_spacing()
 275 {
 276   return Glib::PropertyProxy<int>(this, "spacing");
 277 }
 278 #endif //GLIBMM_PROPERTIES_ENABLED
 279
 280 #ifdef GLIBMM_PROPERTIES_ENABLED
 281 Glib::PropertyProxy_ReadOnly<int> Expander::property_spacing() const
 282 {
 283   return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
 284 }
 285 #endif //GLIBMM_PROPERTIES_ENABLED
 286
 287 #ifdef GLIBMM_PROPERTIES_ENABLED
 288 Glib::PropertyProxy<Widget*> Expander::property_label_widget()
 289 {
 290   return Glib::PropertyProxy<Widget*>(this, "label-widget");
 291 }
 292 #endif //GLIBMM_PROPERTIES_ENABLED
 293
 294 #ifdef GLIBMM_PROPERTIES_ENABLED
 295 Glib::PropertyProxy_ReadOnly<Widget*> Expander::property_label_widget() const
 296 {
 297   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "label-widget");
 298 }
 299 #endif //GLIBMM_PROPERTIES_ENABLED
 300
 301
 302 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 303 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 304
 305 #ifdef GLIBMM_VFUNCS_ENABLED
 306 #endif //GLIBMM_VFUNCS_ENABLED
 307
 308
 309 } // namespace Gtk
 310
 311