libs/gtkmm2/gtk/gtkmm/paned.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <gtkmm/paned.h>
   4 #include <gtkmm/private/paned_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/gtkpaned.h>
  29 #include <gtk/gtkhpaned.h>
  30 #include <gtk/gtkvpaned.h>
  31
  32 namespace Gtk
  33 {
  34
  35 void Paned::pack1(Widget& child, AttachOptions options)
  36 {
  37   const gboolean resize = ((options & EXPAND) != 0);
  38   const gboolean shrink = ((options & SHRINK) != 0);
  39
  40   gtk_paned_pack1(gobj(), child.gobj(), resize, shrink);
  41 }
  42
  43 void Paned::pack2(Widget& child, AttachOptions options)
  44 {
  45   const gboolean resize = ((options & EXPAND) != 0);
  46   const gboolean shrink = ((options & SHRINK) != 0);
  47
  48   gtk_paned_pack2(gobj(), child.gobj(), resize, shrink);
  49 }
  50
  51 } // namespace Gtk
  52
  53
  54 namespace
  55 {
  56 } // anonymous namespace
  57
  58
  59 namespace Glib
  60 {
  61
  62 Gtk::Paned* wrap(GtkPaned* object, bool take_copy)
  63 {
  64   return dynamic_cast<Gtk::Paned *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  65 }
  66
  67 } /* namespace Glib */
  68
  69 namespace Gtk
  70 {
  71
  72
  73 /* The *_Class implementation: */
  74
  75 const Glib::Class& Paned_Class::init()
  76 {
  77   if(!gtype_) // create the GType if necessary
  78   {
  79     // Glib::Class has to know the class init function to clone custom types.
  80     class_init_func_ = &Paned_Class::class_init_function;
  81
  82     // This is actually just optimized away, apparently with no harm.
  83     // Make sure that the parent type has been created.
  84     //CppClassParent::CppObjectType::get_type();
  85
  86     // Create the wrapper type, with the same class/instance size as the base type.
  87     register_derived_type(gtk_paned_get_type());
  88
  89     // Add derived versions of interfaces, if the C type implements any interfaces:
  90   }
  91
  92   return *this;
  93 }
  94
  95 void Paned_Class::class_init_function(void* g_class, void* class_data)
  96 {
  97   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  98   CppClassParent::class_init_function(klass, class_data);
  99
 100 }
 101
 102
 103 Glib::ObjectBase* Paned_Class::wrap_new(GObject* o)
 104 {
 105   return manage(new Paned((GtkPaned*)(o)));
 106
 107 }
 108
 109
 110 /* The implementation: */
 111
 112 Paned::Paned(const Glib::ConstructParams& construct_params)
 113 :
 114   Gtk::Container(construct_params)
 115 {
 116   }
 117
 118 Paned::Paned(GtkPaned* castitem)
 119 :
 120   Gtk::Container((GtkContainer*)(castitem))
 121 {
 122   }
 123
 124 Paned::~Paned()
 125 {
 126   destroy_();
 127 }
 128
 129 Paned::CppClassType Paned::paned_class_; // initialize static member
 130
 131 GType Paned::get_type()
 132 {
 133   return paned_class_.init().get_type();
 134 }
 135
 136 GType Paned::get_base_type()
 137 {
 138   return gtk_paned_get_type();
 139 }
 140
 141
 142 Paned::Paned()
 143 :
 144   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 145   Gtk::Container(Glib::ConstructParams(paned_class_.init()))
 146 {
 147   }
 148
 149 void Paned::add1(Widget& child)
 150 {
 151   gtk_paned_add1(gobj(), (child).gobj());
 152 }
 153
 154 void Paned::add2(Widget& child)
 155 {
 156   gtk_paned_add2(gobj(), (child).gobj());
 157 }
 158
 159 void Paned::pack1(Widget& child, bool resize, bool shrink)
 160 {
 161   gtk_paned_pack1(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink));
 162 }
 163
 164 void Paned::pack2(Widget& child, bool resize, bool shrink)
 165 {
 166   gtk_paned_pack2(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink));
 167 }
 168
 169 int Paned::get_position() const
 170 {
 171   return gtk_paned_get_position(const_cast<GtkPaned*>(gobj()));
 172 }
 173
 174 void Paned::set_position(int position)
 175 {
 176   gtk_paned_set_position(gobj(), position);
 177 }
 178
 179 Widget* Paned::get_child1()
 180 {
 181   return Glib::wrap(gtk_paned_get_child1(gobj()));
 182 }
 183
 184 const Widget* Paned::get_child1() const
 185 {
 186   return Glib::wrap(gtk_paned_get_child1(const_cast<GtkPaned*>(gobj())));
 187 }
 188
 189 Widget* Paned::get_child2()
 190 {
 191   return Glib::wrap(gtk_paned_get_child2(gobj()));
 192 }
 193
 194 const Widget* Paned::get_child2() const
 195 {
 196   return Glib::wrap(gtk_paned_get_child2(const_cast<GtkPaned*>(gobj())));
 197 }
 198
 199
 200 Glib::PropertyProxy<int> Paned::property_position()
 201 {
 202   return Glib::PropertyProxy<int>(this, "position");
 203 }
 204
 205 Glib::PropertyProxy_ReadOnly<int> Paned::property_position() const
 206 {
 207   return Glib::PropertyProxy_ReadOnly<int>(this, "position");
 208 }
 209
 210 Glib::PropertyProxy<bool> Paned::property_position_set()
 211 {
 212   return Glib::PropertyProxy<bool>(this, "position-set");
 213 }
 214
 215 Glib::PropertyProxy_ReadOnly<bool> Paned::property_position_set() const
 216 {
 217   return Glib::PropertyProxy_ReadOnly<bool>(this, "position-set");
 218 }
 219
 220 Glib::PropertyProxy_ReadOnly<int> Paned::property_min_position() const
 221 {
 222   return Glib::PropertyProxy_ReadOnly<int>(this, "min-position");
 223 }
 224
 225 Glib::PropertyProxy_ReadOnly<int> Paned::property_max_position() const
 226 {
 227   return Glib::PropertyProxy_ReadOnly<int>(this, "max-position");
 228 }
 229
 230
 231 } // namespace Gtk
 232
 233
 234 namespace Glib
 235 {
 236
 237 Gtk::HPaned* wrap(GtkHPaned* object, bool take_copy)
 238 {
 239   return dynamic_cast<Gtk::HPaned *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 240 }
 241
 242 } /* namespace Glib */
 243
 244 namespace Gtk
 245 {
 246
 247
 248 /* The *_Class implementation: */
 249
 250 const Glib::Class& HPaned_Class::init()
 251 {
 252   if(!gtype_) // create the GType if necessary
 253   {
 254     // Glib::Class has to know the class init function to clone custom types.
 255     class_init_func_ = &HPaned_Class::class_init_function;
 256
 257     // This is actually just optimized away, apparently with no harm.
 258     // Make sure that the parent type has been created.
 259     //CppClassParent::CppObjectType::get_type();
 260
 261     // Create the wrapper type, with the same class/instance size as the base type.
 262     register_derived_type(gtk_hpaned_get_type());
 263
 264     // Add derived versions of interfaces, if the C type implements any interfaces:
 265   }
 266
 267   return *this;
 268 }
 269
 270 void HPaned_Class::class_init_function(void* g_class, void* class_data)
 271 {
 272   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 273   CppClassParent::class_init_function(klass, class_data);
 274
 275 }
 276
 277
 278 Glib::ObjectBase* HPaned_Class::wrap_new(GObject* o)
 279 {
 280   return manage(new HPaned((GtkHPaned*)(o)));
 281
 282 }
 283
 284
 285 /* The implementation: */
 286
 287 HPaned::HPaned(const Glib::ConstructParams& construct_params)
 288 :
 289   Gtk::Paned(construct_params)
 290 {
 291   }
 292
 293 HPaned::HPaned(GtkHPaned* castitem)
 294 :
 295   Gtk::Paned((GtkPaned*)(castitem))
 296 {
 297   }
 298
 299 HPaned::~HPaned()
 300 {
 301   destroy_();
 302 }
 303
 304 HPaned::CppClassType HPaned::hpaned_class_; // initialize static member
 305
 306 GType HPaned::get_type()
 307 {
 308   return hpaned_class_.init().get_type();
 309 }
 310
 311 GType HPaned::get_base_type()
 312 {
 313   return gtk_hpaned_get_type();
 314 }
 315
 316 HPaned::HPaned()
 317 :
 318   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 319   Gtk::Paned(Glib::ConstructParams(hpaned_class_.init()))
 320 {
 321   }
 322
 323
 324 } // namespace Gtk
 325
 326
 327 namespace Glib
 328 {
 329
 330 Gtk::VPaned* wrap(GtkVPaned* object, bool take_copy)
 331 {
 332   return dynamic_cast<Gtk::VPaned *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 333 }
 334
 335 } /* namespace Glib */
 336
 337 namespace Gtk
 338 {
 339
 340
 341 /* The *_Class implementation: */
 342
 343 const Glib::Class& VPaned_Class::init()
 344 {
 345   if(!gtype_) // create the GType if necessary
 346   {
 347     // Glib::Class has to know the class init function to clone custom types.
 348     class_init_func_ = &VPaned_Class::class_init_function;
 349
 350     // This is actually just optimized away, apparently with no harm.
 351     // Make sure that the parent type has been created.
 352     //CppClassParent::CppObjectType::get_type();
 353
 354     // Create the wrapper type, with the same class/instance size as the base type.
 355     register_derived_type(gtk_vpaned_get_type());
 356
 357     // Add derived versions of interfaces, if the C type implements any interfaces:
 358   }
 359
 360   return *this;
 361 }
 362
 363 void VPaned_Class::class_init_function(void* g_class, void* class_data)
 364 {
 365   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 366   CppClassParent::class_init_function(klass, class_data);
 367
 368 }
 369
 370
 371 Glib::ObjectBase* VPaned_Class::wrap_new(GObject* o)
 372 {
 373   return manage(new VPaned((GtkVPaned*)(o)));
 374
 375 }
 376
 377
 378 /* The implementation: */
 379
 380 VPaned::VPaned(const Glib::ConstructParams& construct_params)
 381 :
 382   Gtk::Paned(construct_params)
 383 {
 384   }
 385
 386 VPaned::VPaned(GtkVPaned* castitem)
 387 :
 388   Gtk::Paned((GtkPaned*)(castitem))
 389 {
 390   }
 391
 392 VPaned::~VPaned()
 393 {
 394   destroy_();
 395 }
 396
 397 VPaned::CppClassType VPaned::vpaned_class_; // initialize static member
 398
 399 GType VPaned::get_type()
 400 {
 401   return vpaned_class_.init().get_type();
 402 }
 403
 404 GType VPaned::get_base_type()
 405 {
 406   return gtk_vpaned_get_type();
 407 }
 408
 409 VPaned::VPaned()
 410 :
 411   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 412   Gtk::Paned(Glib::ConstructParams(vpaned_class_.init()))
 413 {
 414   }
 415
 416
 417 } // namespace Gtk
 418
 419