libs/gtkmm2/gtk/gtkmm/separator.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/separator.h>
   5 #include <gtkmm/private/separator_p.h>
   6
   7 // -*- c++ -*-
   8 /* $Id$ */
   9
  10 /*
  11  *
  12  * Copyright 1998-2002 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/gtkseparator.h>
  30 #include <gtk/gtkhseparator.h>
  31 #include <gtk/gtkvseparator.h>
  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 #ifdef GLIBMM_VFUNCS_ENABLED
  80 #endif //GLIBMM_VFUNCS_ENABLED
  81
  82 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  83 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  84 }
  85
  86 #ifdef GLIBMM_VFUNCS_ENABLED
  87 #endif //GLIBMM_VFUNCS_ENABLED
  88
  89 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  90 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  91
  92
  93 Glib::ObjectBase* Separator_Class::wrap_new(GObject* o)
  94 {
  95   return manage(new Separator((GtkSeparator*)(o)));
  96
  97 }
  98
  99
 100 /* The implementation: */
 101
 102 Separator::Separator(const Glib::ConstructParams& construct_params)
 103 :
 104   Gtk::Widget(construct_params)
 105 {
 106   }
 107
 108 Separator::Separator(GtkSeparator* castitem)
 109 :
 110   Gtk::Widget((GtkWidget*)(castitem))
 111 {
 112   }
 113
 114 Separator::~Separator()
 115 {
 116   destroy_();
 117 }
 118
 119 Separator::CppClassType Separator::separator_class_; // initialize static member
 120
 121 GType Separator::get_type()
 122 {
 123   return separator_class_.init().get_type();
 124 }
 125
 126 GType Separator::get_base_type()
 127 {
 128   return gtk_separator_get_type();
 129 }
 130
 131
 132 Separator::Separator()
 133 :
 134   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 135   Glib::ObjectBase(0),
 136   Gtk::Widget(Glib::ConstructParams(separator_class_.init()))
 137 {
 138   }
 139
 140
 141 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 142 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 143
 144 #ifdef GLIBMM_VFUNCS_ENABLED
 145 #endif //GLIBMM_VFUNCS_ENABLED
 146
 147
 148 } // namespace Gtk
 149
 150
 151 namespace Glib
 152 {
 153
 154 Gtk::VSeparator* wrap(GtkVSeparator* object, bool take_copy)
 155 {
 156   return dynamic_cast<Gtk::VSeparator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 157 }
 158
 159 } /* namespace Glib */
 160
 161 namespace Gtk
 162 {
 163
 164
 165 /* The *_Class implementation: */
 166
 167 const Glib::Class& VSeparator_Class::init()
 168 {
 169   if(!gtype_) // create the GType if necessary
 170   {
 171     // Glib::Class has to know the class init function to clone custom types.
 172     class_init_func_ = &VSeparator_Class::class_init_function;
 173
 174     // This is actually just optimized away, apparently with no harm.
 175     // Make sure that the parent type has been created.
 176     //CppClassParent::CppObjectType::get_type();
 177
 178     // Create the wrapper type, with the same class/instance size as the base type.
 179     register_derived_type(gtk_vseparator_get_type());
 180
 181     // Add derived versions of interfaces, if the C type implements any interfaces:
 182   }
 183
 184   return *this;
 185 }
 186
 187 void VSeparator_Class::class_init_function(void* g_class, void* class_data)
 188 {
 189   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 190   CppClassParent::class_init_function(klass, class_data);
 191
 192 #ifdef GLIBMM_VFUNCS_ENABLED
 193 #endif //GLIBMM_VFUNCS_ENABLED
 194
 195 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 196 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 197 }
 198
 199 #ifdef GLIBMM_VFUNCS_ENABLED
 200 #endif //GLIBMM_VFUNCS_ENABLED
 201
 202 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 203 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 204
 205
 206 Glib::ObjectBase* VSeparator_Class::wrap_new(GObject* o)
 207 {
 208   return manage(new VSeparator((GtkVSeparator*)(o)));
 209
 210 }
 211
 212
 213 /* The implementation: */
 214
 215 VSeparator::VSeparator(const Glib::ConstructParams& construct_params)
 216 :
 217   Gtk::Separator(construct_params)
 218 {
 219   }
 220
 221 VSeparator::VSeparator(GtkVSeparator* castitem)
 222 :
 223   Gtk::Separator((GtkSeparator*)(castitem))
 224 {
 225   }
 226
 227 VSeparator::~VSeparator()
 228 {
 229   destroy_();
 230 }
 231
 232 VSeparator::CppClassType VSeparator::vseparator_class_; // initialize static member
 233
 234 GType VSeparator::get_type()
 235 {
 236   return vseparator_class_.init().get_type();
 237 }
 238
 239 GType VSeparator::get_base_type()
 240 {
 241   return gtk_vseparator_get_type();
 242 }
 243
 244 VSeparator::VSeparator()
 245 :
 246   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 247   Glib::ObjectBase(0),
 248   Gtk::Separator(Glib::ConstructParams(vseparator_class_.init()))
 249 {
 250   }
 251
 252
 253 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 254 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 255
 256 #ifdef GLIBMM_VFUNCS_ENABLED
 257 #endif //GLIBMM_VFUNCS_ENABLED
 258
 259
 260 } // namespace Gtk
 261
 262
 263 namespace Glib
 264 {
 265
 266 Gtk::HSeparator* wrap(GtkHSeparator* object, bool take_copy)
 267 {
 268   return dynamic_cast<Gtk::HSeparator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 269 }
 270
 271 } /* namespace Glib */
 272
 273 namespace Gtk
 274 {
 275
 276
 277 /* The *_Class implementation: */
 278
 279 const Glib::Class& HSeparator_Class::init()
 280 {
 281   if(!gtype_) // create the GType if necessary
 282   {
 283     // Glib::Class has to know the class init function to clone custom types.
 284     class_init_func_ = &HSeparator_Class::class_init_function;
 285
 286     // This is actually just optimized away, apparently with no harm.
 287     // Make sure that the parent type has been created.
 288     //CppClassParent::CppObjectType::get_type();
 289
 290     // Create the wrapper type, with the same class/instance size as the base type.
 291     register_derived_type(gtk_hseparator_get_type());
 292
 293     // Add derived versions of interfaces, if the C type implements any interfaces:
 294   }
 295
 296   return *this;
 297 }
 298
 299 void HSeparator_Class::class_init_function(void* g_class, void* class_data)
 300 {
 301   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 302   CppClassParent::class_init_function(klass, class_data);
 303
 304 #ifdef GLIBMM_VFUNCS_ENABLED
 305 #endif //GLIBMM_VFUNCS_ENABLED
 306
 307 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 308 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 309 }
 310
 311 #ifdef GLIBMM_VFUNCS_ENABLED
 312 #endif //GLIBMM_VFUNCS_ENABLED
 313
 314 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 315 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 316
 317
 318 Glib::ObjectBase* HSeparator_Class::wrap_new(GObject* o)
 319 {
 320   return manage(new HSeparator((GtkHSeparator*)(o)));
 321
 322 }
 323
 324
 325 /* The implementation: */
 326
 327 HSeparator::HSeparator(const Glib::ConstructParams& construct_params)
 328 :
 329   Gtk::Separator(construct_params)
 330 {
 331   }
 332
 333 HSeparator::HSeparator(GtkHSeparator* castitem)
 334 :
 335   Gtk::Separator((GtkSeparator*)(castitem))
 336 {
 337   }
 338
 339 HSeparator::~HSeparator()
 340 {
 341   destroy_();
 342 }
 343
 344 HSeparator::CppClassType HSeparator::hseparator_class_; // initialize static member
 345
 346 GType HSeparator::get_type()
 347 {
 348   return hseparator_class_.init().get_type();
 349 }
 350
 351 GType HSeparator::get_base_type()
 352 {
 353   return gtk_hseparator_get_type();
 354 }
 355
 356 HSeparator::HSeparator()
 357 :
 358   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 359   Glib::ObjectBase(0),
 360   Gtk::Separator(Glib::ConstructParams(hseparator_class_.init()))
 361 {
 362   }
 363
 364
 365 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 366 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 367
 368 #ifdef GLIBMM_VFUNCS_ENABLED
 369 #endif //GLIBMM_VFUNCS_ENABLED
 370
 371
 372 } // namespace Gtk
 373
 374