libs/gtkmm2/gtk/gtkmm/separator.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <gtkmm/separator.h>
   4 #include <gtkmm/private/separator_p.h>
   5
   6 // -*- c++ -*-
   7 /* $Id$ */
   8
   9 /*
  10  *
  11  * Copyright 1998-2002 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/gtkseparator.h>
  29 #include <gtk/gtkhseparator.h>
  30 #include <gtk/gtkvseparator.h>
  31
  32
  33 namespace
  34 {
  35 } // anonymous namespace
  36
  37
  38 namespace Glib
  39 {
  40
  41 Gtk::Separator* wrap(GtkSeparator* object, bool take_copy)
  42 {
  43   return dynamic_cast<Gtk::Separator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  44 }
  45
  46 } /* namespace Glib */
  47
  48 namespace Gtk
  49 {
  50
  51
  52 /* The *_Class implementation: */
  53
  54 const Glib::Class& Separator_Class::init()
  55 {
  56   if(!gtype_) // create the GType if necessary
  57   {
  58     // Glib::Class has to know the class init function to clone custom types.
  59     class_init_func_ = &Separator_Class::class_init_function;
  60
  61     // This is actually just optimized away, apparently with no harm.
  62     // Make sure that the parent type has been created.
  63     //CppClassParent::CppObjectType::get_type();
  64
  65     // Create the wrapper type, with the same class/instance size as the base type.
  66     register_derived_type(gtk_separator_get_type());
  67
  68     // Add derived versions of interfaces, if the C type implements any interfaces:
  69   }
  70
  71   return *this;
  72 }
  73
  74 void Separator_Class::class_init_function(void* g_class, void* class_data)
  75 {
  76   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  77   CppClassParent::class_init_function(klass, class_data);
  78
  79 }
  80
  81
  82 Glib::ObjectBase* Separator_Class::wrap_new(GObject* o)
  83 {
  84   return manage(new Separator((GtkSeparator*)(o)));
  85
  86 }
  87
  88
  89 /* The implementation: */
  90
  91 Separator::Separator(const Glib::ConstructParams& construct_params)
  92 :
  93   Gtk::Widget(construct_params)
  94 {
  95   }
  96
  97 Separator::Separator(GtkSeparator* castitem)
  98 :
  99   Gtk::Widget((GtkWidget*)(castitem))
 100 {
 101   }
 102
 103 Separator::~Separator()
 104 {
 105   destroy_();
 106 }
 107
 108 Separator::CppClassType Separator::separator_class_; // initialize static member
 109
 110 GType Separator::get_type()
 111 {
 112   return separator_class_.init().get_type();
 113 }
 114
 115 GType Separator::get_base_type()
 116 {
 117   return gtk_separator_get_type();
 118 }
 119
 120
 121 Separator::Separator()
 122 :
 123   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 124   Gtk::Widget(Glib::ConstructParams(separator_class_.init()))
 125 {
 126   }
 127
 128
 129 } // namespace Gtk
 130
 131
 132 namespace Glib
 133 {
 134
 135 Gtk::VSeparator* wrap(GtkVSeparator* object, bool take_copy)
 136 {
 137   return dynamic_cast<Gtk::VSeparator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 138 }
 139
 140 } /* namespace Glib */
 141
 142 namespace Gtk
 143 {
 144
 145
 146 /* The *_Class implementation: */
 147
 148 const Glib::Class& VSeparator_Class::init()
 149 {
 150   if(!gtype_) // create the GType if necessary
 151   {
 152     // Glib::Class has to know the class init function to clone custom types.
 153     class_init_func_ = &VSeparator_Class::class_init_function;
 154
 155     // This is actually just optimized away, apparently with no harm.
 156     // Make sure that the parent type has been created.
 157     //CppClassParent::CppObjectType::get_type();
 158
 159     // Create the wrapper type, with the same class/instance size as the base type.
 160     register_derived_type(gtk_vseparator_get_type());
 161
 162     // Add derived versions of interfaces, if the C type implements any interfaces:
 163   }
 164
 165   return *this;
 166 }
 167
 168 void VSeparator_Class::class_init_function(void* g_class, void* class_data)
 169 {
 170   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 171   CppClassParent::class_init_function(klass, class_data);
 172
 173 }
 174
 175
 176 Glib::ObjectBase* VSeparator_Class::wrap_new(GObject* o)
 177 {
 178   return manage(new VSeparator((GtkVSeparator*)(o)));
 179
 180 }
 181
 182
 183 /* The implementation: */
 184
 185 VSeparator::VSeparator(const Glib::ConstructParams& construct_params)
 186 :
 187   Gtk::Separator(construct_params)
 188 {
 189   }
 190
 191 VSeparator::VSeparator(GtkVSeparator* castitem)
 192 :
 193   Gtk::Separator((GtkSeparator*)(castitem))
 194 {
 195   }
 196
 197 VSeparator::~VSeparator()
 198 {
 199   destroy_();
 200 }
 201
 202 VSeparator::CppClassType VSeparator::vseparator_class_; // initialize static member
 203
 204 GType VSeparator::get_type()
 205 {
 206   return vseparator_class_.init().get_type();
 207 }
 208
 209 GType VSeparator::get_base_type()
 210 {
 211   return gtk_vseparator_get_type();
 212 }
 213
 214 VSeparator::VSeparator()
 215 :
 216   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 217   Gtk::Separator(Glib::ConstructParams(vseparator_class_.init()))
 218 {
 219   }
 220
 221
 222 } // namespace Gtk
 223
 224
 225 namespace Glib
 226 {
 227
 228 Gtk::HSeparator* wrap(GtkHSeparator* object, bool take_copy)
 229 {
 230   return dynamic_cast<Gtk::HSeparator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 231 }
 232
 233 } /* namespace Glib */
 234
 235 namespace Gtk
 236 {
 237
 238
 239 /* The *_Class implementation: */
 240
 241 const Glib::Class& HSeparator_Class::init()
 242 {
 243   if(!gtype_) // create the GType if necessary
 244   {
 245     // Glib::Class has to know the class init function to clone custom types.
 246     class_init_func_ = &HSeparator_Class::class_init_function;
 247
 248     // This is actually just optimized away, apparently with no harm.
 249     // Make sure that the parent type has been created.
 250     //CppClassParent::CppObjectType::get_type();
 251
 252     // Create the wrapper type, with the same class/instance size as the base type.
 253     register_derived_type(gtk_hseparator_get_type());
 254
 255     // Add derived versions of interfaces, if the C type implements any interfaces:
 256   }
 257
 258   return *this;
 259 }
 260
 261 void HSeparator_Class::class_init_function(void* g_class, void* class_data)
 262 {
 263   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 264   CppClassParent::class_init_function(klass, class_data);
 265
 266 }
 267
 268
 269 Glib::ObjectBase* HSeparator_Class::wrap_new(GObject* o)
 270 {
 271   return manage(new HSeparator((GtkHSeparator*)(o)));
 272
 273 }
 274
 275
 276 /* The implementation: */
 277
 278 HSeparator::HSeparator(const Glib::ConstructParams& construct_params)
 279 :
 280   Gtk::Separator(construct_params)
 281 {
 282   }
 283
 284 HSeparator::HSeparator(GtkHSeparator* castitem)
 285 :
 286   Gtk::Separator((GtkSeparator*)(castitem))
 287 {
 288   }
 289
 290 HSeparator::~HSeparator()
 291 {
 292   destroy_();
 293 }
 294
 295 HSeparator::CppClassType HSeparator::hseparator_class_; // initialize static member
 296
 297 GType HSeparator::get_type()
 298 {
 299   return hseparator_class_.init().get_type();
 300 }
 301
 302 GType HSeparator::get_base_type()
 303 {
 304   return gtk_hseparator_get_type();
 305 }
 306
 307 HSeparator::HSeparator()
 308 :
 309   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 310   Gtk::Separator(Glib::ConstructParams(hseparator_class_.init()))
 311 {
 312   }
 313
 314
 315 } // namespace Gtk
 316
 317