libs/gtkmm2/gtk/gtkmm/buttonbox.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/buttonbox.h>
   5 #include <gtkmm/private/buttonbox_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/gtkhbbox.h>
  30 #include <gtk/gtkvbbox.h>
  31
  32 namespace Gtk
  33 {
  34
  35 VButtonBox::VButtonBox(ButtonBoxStyle layout, int spacing)
  36 :
  37   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  38   Glib::ObjectBase(0),
  39   ButtonBox(Glib::ConstructParams(vbuttonbox_class_.init()))
  40 {
  41   set_layout(layout);
  42   set_spacing(spacing);
  43 }
  44
  45 HButtonBox::HButtonBox(ButtonBoxStyle layout, int spacing)
  46 :
  47   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  48   Glib::ObjectBase(0),
  49   ButtonBox(Glib::ConstructParams(hbuttonbox_class_.init()))
  50 {
  51   set_layout(layout);
  52   set_spacing(spacing);
  53 }
  54
  55 } // namespace Gtk
  56
  57
  58 namespace
  59 {
  60 } // anonymous namespace
  61
  62
  63 namespace Glib
  64 {
  65
  66 Gtk::ButtonBox* wrap(GtkButtonBox* object, bool take_copy)
  67 {
  68   return dynamic_cast<Gtk::ButtonBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  69 }
  70
  71 } /* namespace Glib */
  72
  73 namespace Gtk
  74 {
  75
  76
  77 /* The *_Class implementation: */
  78
  79 const Glib::Class& ButtonBox_Class::init()
  80 {
  81   if(!gtype_) // create the GType if necessary
  82   {
  83     // Glib::Class has to know the class init function to clone custom types.
  84     class_init_func_ = &ButtonBox_Class::class_init_function;
  85
  86     // This is actually just optimized away, apparently with no harm.
  87     // Make sure that the parent type has been created.
  88     //CppClassParent::CppObjectType::get_type();
  89
  90     // Create the wrapper type, with the same class/instance size as the base type.
  91     register_derived_type(gtk_button_box_get_type());
  92
  93     // Add derived versions of interfaces, if the C type implements any interfaces:
  94   }
  95
  96   return *this;
  97 }
  98
  99 void ButtonBox_Class::class_init_function(void* g_class, void* class_data)
 100 {
 101   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 102   CppClassParent::class_init_function(klass, class_data);
 103
 104 #ifdef GLIBMM_VFUNCS_ENABLED
 105 #endif //GLIBMM_VFUNCS_ENABLED
 106
 107 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 108 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 109 }
 110
 111 #ifdef GLIBMM_VFUNCS_ENABLED
 112 #endif //GLIBMM_VFUNCS_ENABLED
 113
 114 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 115 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 116
 117
 118 Glib::ObjectBase* ButtonBox_Class::wrap_new(GObject* o)
 119 {
 120   return manage(new ButtonBox((GtkButtonBox*)(o)));
 121
 122 }
 123
 124
 125 /* The implementation: */
 126
 127 ButtonBox::ButtonBox(const Glib::ConstructParams& construct_params)
 128 :
 129   Gtk::Box(construct_params)
 130 {
 131   }
 132
 133 ButtonBox::ButtonBox(GtkButtonBox* castitem)
 134 :
 135   Gtk::Box((GtkBox*)(castitem))
 136 {
 137   }
 138
 139 ButtonBox::~ButtonBox()
 140 {
 141   destroy_();
 142 }
 143
 144 ButtonBox::CppClassType ButtonBox::buttonbox_class_; // initialize static member
 145
 146 GType ButtonBox::get_type()
 147 {
 148   return buttonbox_class_.init().get_type();
 149 }
 150
 151 GType ButtonBox::get_base_type()
 152 {
 153   return gtk_button_box_get_type();
 154 }
 155
 156
 157 ButtonBoxStyle ButtonBox::get_layout() const
 158 {
 159   return ((ButtonBoxStyle)(gtk_button_box_get_layout(const_cast<GtkButtonBox*>(gobj()))));
 160 }
 161
 162 void ButtonBox::set_layout(ButtonBoxStyle layout_style)
 163 {
 164 gtk_button_box_set_layout(gobj(), ((GtkButtonBoxStyle)(layout_style)));
 165 }
 166
 167 void ButtonBox::set_child_secondary(Widget& child, bool is_secondary)
 168 {
 169 gtk_button_box_set_child_secondary(gobj(), (child).gobj(), static_cast<int>(is_secondary));
 170 }
 171
 172 bool ButtonBox::get_child_secondary(const Gtk::Widget& child) const
 173 {
 174   return gtk_button_box_get_child_secondary(const_cast<GtkButtonBox*>(gobj()), const_cast<GtkWidget*>(child.gobj()));
 175 }
 176
 177  int ButtonBox::get_child_min_width() const
 178 {
 179   return gobj()->child_min_width;
 180 }
 181
 182  void ButtonBox::set_child_min_width(const int& value)
 183 {
 184   gobj()->child_min_width = value;
 185 }
 186
 187  int ButtonBox::get_child_min_height() const
 188 {
 189   return gobj()->child_min_height;
 190 }
 191
 192  void ButtonBox::set_child_min_height(const int& value)
 193 {
 194   gobj()->child_min_height = value;
 195 }
 196
 197  int ButtonBox::get_child_ipadding_x() const
 198 {
 199   return gobj()->child_ipad_x;
 200 }
 201
 202  void ButtonBox::set_child_ipadding_x(const int& value)
 203 {
 204   gobj()->child_ipad_x = value;
 205 }
 206
 207  int ButtonBox::get_child_ipadding_y() const
 208 {
 209   return gobj()->child_ipad_y;
 210 }
 211
 212  void ButtonBox::set_child_ipadding_y(const int& value)
 213 {
 214   gobj()->child_ipad_y = value;
 215 }
 216
 217
 218 #ifdef GLIBMM_PROPERTIES_ENABLED
 219 Glib::PropertyProxy<ButtonBoxStyle> ButtonBox::property_layout_style()
 220 {
 221   return Glib::PropertyProxy<ButtonBoxStyle>(this, "layout-style");
 222 }
 223 #endif //GLIBMM_PROPERTIES_ENABLED
 224
 225 #ifdef GLIBMM_PROPERTIES_ENABLED
 226 Glib::PropertyProxy_ReadOnly<ButtonBoxStyle> ButtonBox::property_layout_style() const
 227 {
 228   return Glib::PropertyProxy_ReadOnly<ButtonBoxStyle>(this, "layout-style");
 229 }
 230 #endif //GLIBMM_PROPERTIES_ENABLED
 231
 232
 233 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 234 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 235
 236 #ifdef GLIBMM_VFUNCS_ENABLED
 237 #endif //GLIBMM_VFUNCS_ENABLED
 238
 239
 240 } // namespace Gtk
 241
 242
 243 namespace Glib
 244 {
 245
 246 Gtk::VButtonBox* wrap(GtkVButtonBox* object, bool take_copy)
 247 {
 248   return dynamic_cast<Gtk::VButtonBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 249 }
 250
 251 } /* namespace Glib */
 252
 253 namespace Gtk
 254 {
 255
 256
 257 /* The *_Class implementation: */
 258
 259 const Glib::Class& VButtonBox_Class::init()
 260 {
 261   if(!gtype_) // create the GType if necessary
 262   {
 263     // Glib::Class has to know the class init function to clone custom types.
 264     class_init_func_ = &VButtonBox_Class::class_init_function;
 265
 266     // This is actually just optimized away, apparently with no harm.
 267     // Make sure that the parent type has been created.
 268     //CppClassParent::CppObjectType::get_type();
 269
 270     // Create the wrapper type, with the same class/instance size as the base type.
 271     register_derived_type(gtk_vbutton_box_get_type());
 272
 273     // Add derived versions of interfaces, if the C type implements any interfaces:
 274   }
 275
 276   return *this;
 277 }
 278
 279 void VButtonBox_Class::class_init_function(void* g_class, void* class_data)
 280 {
 281   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 282   CppClassParent::class_init_function(klass, class_data);
 283
 284 #ifdef GLIBMM_VFUNCS_ENABLED
 285 #endif //GLIBMM_VFUNCS_ENABLED
 286
 287 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 288 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 289 }
 290
 291 #ifdef GLIBMM_VFUNCS_ENABLED
 292 #endif //GLIBMM_VFUNCS_ENABLED
 293
 294 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 295 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 296
 297
 298 Glib::ObjectBase* VButtonBox_Class::wrap_new(GObject* o)
 299 {
 300   return manage(new VButtonBox((GtkVButtonBox*)(o)));
 301
 302 }
 303
 304
 305 /* The implementation: */
 306
 307 VButtonBox::VButtonBox(const Glib::ConstructParams& construct_params)
 308 :
 309   Gtk::ButtonBox(construct_params)
 310 {
 311   }
 312
 313 VButtonBox::VButtonBox(GtkVButtonBox* castitem)
 314 :
 315   Gtk::ButtonBox((GtkButtonBox*)(castitem))
 316 {
 317   }
 318
 319 VButtonBox::~VButtonBox()
 320 {
 321   destroy_();
 322 }
 323
 324 VButtonBox::CppClassType VButtonBox::vbuttonbox_class_; // initialize static member
 325
 326 GType VButtonBox::get_type()
 327 {
 328   return vbuttonbox_class_.init().get_type();
 329 }
 330
 331 GType VButtonBox::get_base_type()
 332 {
 333   return gtk_vbutton_box_get_type();
 334 }
 335
 336
 337 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 338 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 339
 340 #ifdef GLIBMM_VFUNCS_ENABLED
 341 #endif //GLIBMM_VFUNCS_ENABLED
 342
 343
 344 } // namespace Gtk
 345
 346
 347 namespace Glib
 348 {
 349
 350 Gtk::HButtonBox* wrap(GtkHButtonBox* object, bool take_copy)
 351 {
 352   return dynamic_cast<Gtk::HButtonBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 353 }
 354
 355 } /* namespace Glib */
 356
 357 namespace Gtk
 358 {
 359
 360
 361 /* The *_Class implementation: */
 362
 363 const Glib::Class& HButtonBox_Class::init()
 364 {
 365   if(!gtype_) // create the GType if necessary
 366   {
 367     // Glib::Class has to know the class init function to clone custom types.
 368     class_init_func_ = &HButtonBox_Class::class_init_function;
 369
 370     // This is actually just optimized away, apparently with no harm.
 371     // Make sure that the parent type has been created.
 372     //CppClassParent::CppObjectType::get_type();
 373
 374     // Create the wrapper type, with the same class/instance size as the base type.
 375     register_derived_type(gtk_hbutton_box_get_type());
 376
 377     // Add derived versions of interfaces, if the C type implements any interfaces:
 378   }
 379
 380   return *this;
 381 }
 382
 383 void HButtonBox_Class::class_init_function(void* g_class, void* class_data)
 384 {
 385   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 386   CppClassParent::class_init_function(klass, class_data);
 387
 388 #ifdef GLIBMM_VFUNCS_ENABLED
 389 #endif //GLIBMM_VFUNCS_ENABLED
 390
 391 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 392 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 393 }
 394
 395 #ifdef GLIBMM_VFUNCS_ENABLED
 396 #endif //GLIBMM_VFUNCS_ENABLED
 397
 398 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 399 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 400
 401
 402 Glib::ObjectBase* HButtonBox_Class::wrap_new(GObject* o)
 403 {
 404   return manage(new HButtonBox((GtkHButtonBox*)(o)));
 405
 406 }
 407
 408
 409 /* The implementation: */
 410
 411 HButtonBox::HButtonBox(const Glib::ConstructParams& construct_params)
 412 :
 413   Gtk::ButtonBox(construct_params)
 414 {
 415   }
 416
 417 HButtonBox::HButtonBox(GtkHButtonBox* castitem)
 418 :
 419   Gtk::ButtonBox((GtkButtonBox*)(castitem))
 420 {
 421   }
 422
 423 HButtonBox::~HButtonBox()
 424 {
 425   destroy_();
 426 }
 427
 428 HButtonBox::CppClassType HButtonBox::hbuttonbox_class_; // initialize static member
 429
 430 GType HButtonBox::get_type()
 431 {
 432   return hbuttonbox_class_.init().get_type();
 433 }
 434
 435 GType HButtonBox::get_base_type()
 436 {
 437   return gtk_hbutton_box_get_type();
 438 }
 439
 440
 441 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 442 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 443
 444 #ifdef GLIBMM_VFUNCS_ENABLED
 445 #endif //GLIBMM_VFUNCS_ENABLED
 446
 447
 448 } // namespace Gtk
 449
 450