libs/gtkmm2/gtk/gtkmm/sizegroup.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/sizegroup.h>
   5 #include <gtkmm/private/sizegroup_p.h>
   6
   7 #include <gtk/gtktypebuiltins.h>
   8 // -*- c++ -*-
   9 /* $Id$ */
  10
  11 /*
  12  *
  13  * Copyright 2002 The gtkmm Development Team
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Library General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Library General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Library General Public
  26  * License along with this library; if not, write to the Free
  27  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28  */
  29
  30 #include <gtk/gtksizegroup.h>
  31
  32 namespace Gtk
  33 {
  34
  35 SizeGroup::SizeGroup(SizeGroupMode mode)
  36 :
  37   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  38   Glib::ObjectBase(0),
  39   Glib::Object(Glib::ConstructParams(sizegroup_class_.init(), "mode",(GtkSizeGroupMode) mode, static_cast<char*>(0)))
  40 {}
  41
  42 } // namespace Gtk
  43
  44
  45 namespace
  46 {
  47 } // anonymous namespace
  48
  49 // static
  50 GType Glib::Value<Gtk::SizeGroupMode>::value_type()
  51 {
  52   return gtk_size_group_mode_get_type();
  53 }
  54
  55
  56 namespace Glib
  57 {
  58
  59 Glib::RefPtr<Gtk::SizeGroup> wrap(GtkSizeGroup* object, bool take_copy)
  60 {
  61   return Glib::RefPtr<Gtk::SizeGroup>( dynamic_cast<Gtk::SizeGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  62   //We use dynamic_cast<> in case of multiple inheritance.
  63 }
  64
  65 } /* namespace Glib */
  66
  67
  68 namespace Gtk
  69 {
  70
  71
  72 /* The *_Class implementation: */
  73
  74 const Glib::Class& SizeGroup_Class::init()
  75 {
  76   if(!gtype_) // create the GType if necessary
  77   {
  78     // Glib::Class has to know the class init function to clone custom types.
  79     class_init_func_ = &SizeGroup_Class::class_init_function;
  80
  81     // This is actually just optimized away, apparently with no harm.
  82     // Make sure that the parent type has been created.
  83     //CppClassParent::CppObjectType::get_type();
  84
  85     // Create the wrapper type, with the same class/instance size as the base type.
  86     register_derived_type(gtk_size_group_get_type());
  87
  88     // Add derived versions of interfaces, if the C type implements any interfaces:
  89   }
  90
  91   return *this;
  92 }
  93
  94 void SizeGroup_Class::class_init_function(void* g_class, void* class_data)
  95 {
  96   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  97   CppClassParent::class_init_function(klass, class_data);
  98
  99 #ifdef GLIBMM_VFUNCS_ENABLED
 100 #endif //GLIBMM_VFUNCS_ENABLED
 101
 102 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 103 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 104 }
 105
 106 #ifdef GLIBMM_VFUNCS_ENABLED
 107 #endif //GLIBMM_VFUNCS_ENABLED
 108
 109 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 110 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 111
 112
 113 Glib::ObjectBase* SizeGroup_Class::wrap_new(GObject* object)
 114 {
 115   return new SizeGroup((GtkSizeGroup*)object);
 116 }
 117
 118
 119 /* The implementation: */
 120
 121 GtkSizeGroup* SizeGroup::gobj_copy()
 122 {
 123   reference();
 124   return gobj();
 125 }
 126
 127 SizeGroup::SizeGroup(const Glib::ConstructParams& construct_params)
 128 :
 129   Glib::Object(construct_params)
 130 {}
 131
 132 SizeGroup::SizeGroup(GtkSizeGroup* castitem)
 133 :
 134   Glib::Object((GObject*)(castitem))
 135 {}
 136
 137 SizeGroup::~SizeGroup()
 138 {}
 139
 140
 141 SizeGroup::CppClassType SizeGroup::sizegroup_class_; // initialize static member
 142
 143 GType SizeGroup::get_type()
 144 {
 145   return sizegroup_class_.init().get_type();
 146 }
 147
 148 GType SizeGroup::get_base_type()
 149 {
 150   return gtk_size_group_get_type();
 151 }
 152
 153
 154 Glib::RefPtr<SizeGroup> SizeGroup::create(SizeGroupMode mode)
 155 {
 156   return Glib::RefPtr<SizeGroup>( new SizeGroup(mode) );
 157 }
 158 void SizeGroup::set_mode(SizeGroupMode mode)
 159 {
 160 gtk_size_group_set_mode(gobj(), ((GtkSizeGroupMode)(mode)));
 161 }
 162
 163 SizeGroupMode SizeGroup::get_mode() const
 164 {
 165   return ((SizeGroupMode)(gtk_size_group_get_mode(const_cast<GtkSizeGroup*>(gobj()))));
 166 }
 167
 168 void SizeGroup::set_ignore_hidden(bool ignore_hidden)
 169 {
 170 gtk_size_group_set_ignore_hidden(gobj(), static_cast<int>(ignore_hidden));
 171 }
 172
 173 bool SizeGroup::get_ignore_hidden() const
 174 {
 175   return gtk_size_group_get_ignore_hidden(const_cast<GtkSizeGroup*>(gobj()));
 176 }
 177
 178 void SizeGroup::add_widget(Widget& widget)
 179 {
 180 gtk_size_group_add_widget(gobj(), (widget).gobj());
 181 }
 182
 183 void SizeGroup::remove_widget(Widget& widget)
 184 {
 185 gtk_size_group_remove_widget(gobj(), (widget).gobj());
 186 }
 187
 188 Glib::SListHandle<Widget*> SizeGroup::get_widgets()
 189 {
 190   return Glib::SListHandle<Widget*>(gtk_size_group_get_widgets(gobj()), Glib::OWNERSHIP_SHALLOW);
 191 }
 192
 193 Glib::SListHandle<const Widget*> SizeGroup::get_widgets() const
 194 {
 195   return Glib::SListHandle<const Widget*>(gtk_size_group_get_widgets(const_cast<GtkSizeGroup*>(gobj())), Glib::OWNERSHIP_SHALLOW);
 196 }
 197
 198
 199 #ifdef GLIBMM_PROPERTIES_ENABLED
 200 Glib::PropertyProxy<SizeGroupMode> SizeGroup::property_mode()
 201 {
 202   return Glib::PropertyProxy<SizeGroupMode>(this, "mode");
 203 }
 204 #endif //GLIBMM_PROPERTIES_ENABLED
 205
 206 #ifdef GLIBMM_PROPERTIES_ENABLED
 207 Glib::PropertyProxy_ReadOnly<SizeGroupMode> SizeGroup::property_mode() const
 208 {
 209   return Glib::PropertyProxy_ReadOnly<SizeGroupMode>(this, "mode");
 210 }
 211 #endif //GLIBMM_PROPERTIES_ENABLED
 212
 213 #ifdef GLIBMM_PROPERTIES_ENABLED
 214 Glib::PropertyProxy<bool> SizeGroup::property_ignore_hidden()
 215 {
 216   return Glib::PropertyProxy<bool>(this, "ignore-hidden");
 217 }
 218 #endif //GLIBMM_PROPERTIES_ENABLED
 219
 220 #ifdef GLIBMM_PROPERTIES_ENABLED
 221 Glib::PropertyProxy_ReadOnly<bool> SizeGroup::property_ignore_hidden() const
 222 {
 223   return Glib::PropertyProxy_ReadOnly<bool>(this, "ignore-hidden");
 224 }
 225 #endif //GLIBMM_PROPERTIES_ENABLED
 226
 227
 228 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 229 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 230
 231 #ifdef GLIBMM_VFUNCS_ENABLED
 232 #endif //GLIBMM_VFUNCS_ENABLED
 233
 234
 235 } // namespace Gtk
 236
 237