libs/gtkmm2/gtk/gtkmm/scrollbar.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/scrollbar.h>
   5 #include <gtkmm/private/scrollbar_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 <gtkmm/adjustment.h>
  30
  31 #include <gtk/gtkscrollbar.h>
  32 #include <gtk/gtkhscrollbar.h>
  33 #include <gtk/gtkvscrollbar.h>
  34
  35 namespace Gtk
  36 {
  37
  38 VScrollbar::VScrollbar(Adjustment& adjustment)
  39 :
  40   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  41   Glib::ObjectBase(0),
  42   Scrollbar(Glib::ConstructParams(vscrollbar_class_.init()))
  43 {
  44   set_adjustment(adjustment);
  45 }
  46
  47 VScrollbar::VScrollbar()
  48 :
  49   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  50   Glib::ObjectBase(0),
  51   Scrollbar(Glib::ConstructParams(vscrollbar_class_.init()))
  52 {
  53   Adjustment* adjustment = manage(new Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
  54
  55   // The adjustment will be destroyed along with the object
  56   set_adjustment(*adjustment);
  57 }
  58
  59
  60 HScrollbar::HScrollbar()
  61 :
  62   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  63   Glib::ObjectBase(0),
  64   Scrollbar(Glib::ConstructParams(hscrollbar_class_.init()))
  65 {
  66   Adjustment* adjustment = manage(new Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
  67
  68   // The adjustment will be destroyed along with the object
  69   set_adjustment(*adjustment);
  70 }
  71
  72 HScrollbar::HScrollbar(Adjustment& adjustment)
  73 :
  74   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  75   Glib::ObjectBase(0),
  76   Scrollbar(Glib::ConstructParams(hscrollbar_class_.init()))
  77 {
  78   set_adjustment(adjustment);
  79 }
  80
  81 } // namespace Gtk
  82
  83
  84 namespace
  85 {
  86 } // anonymous namespace
  87
  88
  89 namespace Glib
  90 {
  91
  92 Gtk::Scrollbar* wrap(GtkScrollbar* object, bool take_copy)
  93 {
  94   return dynamic_cast<Gtk::Scrollbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  95 }
  96
  97 } /* namespace Glib */
  98
  99 namespace Gtk
 100 {
 101
 102
 103 /* The *_Class implementation: */
 104
 105 const Glib::Class& Scrollbar_Class::init()
 106 {
 107   if(!gtype_) // create the GType if necessary
 108   {
 109     // Glib::Class has to know the class init function to clone custom types.
 110     class_init_func_ = &Scrollbar_Class::class_init_function;
 111
 112     // This is actually just optimized away, apparently with no harm.
 113     // Make sure that the parent type has been created.
 114     //CppClassParent::CppObjectType::get_type();
 115
 116     // Create the wrapper type, with the same class/instance size as the base type.
 117     register_derived_type(gtk_scrollbar_get_type());
 118
 119     // Add derived versions of interfaces, if the C type implements any interfaces:
 120   }
 121
 122   return *this;
 123 }
 124
 125 void Scrollbar_Class::class_init_function(void* g_class, void* class_data)
 126 {
 127   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 128   CppClassParent::class_init_function(klass, class_data);
 129
 130 #ifdef GLIBMM_VFUNCS_ENABLED
 131 #endif //GLIBMM_VFUNCS_ENABLED
 132
 133 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 134 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 135 }
 136
 137 #ifdef GLIBMM_VFUNCS_ENABLED
 138 #endif //GLIBMM_VFUNCS_ENABLED
 139
 140 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 141 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 142
 143
 144 Glib::ObjectBase* Scrollbar_Class::wrap_new(GObject* o)
 145 {
 146   return manage(new Scrollbar((GtkScrollbar*)(o)));
 147
 148 }
 149
 150
 151 /* The implementation: */
 152
 153 Scrollbar::Scrollbar(const Glib::ConstructParams& construct_params)
 154 :
 155   Gtk::Range(construct_params)
 156 {
 157   }
 158
 159 Scrollbar::Scrollbar(GtkScrollbar* castitem)
 160 :
 161   Gtk::Range((GtkRange*)(castitem))
 162 {
 163   }
 164
 165 Scrollbar::~Scrollbar()
 166 {
 167   destroy_();
 168 }
 169
 170 Scrollbar::CppClassType Scrollbar::scrollbar_class_; // initialize static member
 171
 172 GType Scrollbar::get_type()
 173 {
 174   return scrollbar_class_.init().get_type();
 175 }
 176
 177 GType Scrollbar::get_base_type()
 178 {
 179   return gtk_scrollbar_get_type();
 180 }
 181
 182
 183 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 184 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 185
 186 #ifdef GLIBMM_VFUNCS_ENABLED
 187 #endif //GLIBMM_VFUNCS_ENABLED
 188
 189
 190 } // namespace Gtk
 191
 192
 193 namespace Glib
 194 {
 195
 196 Gtk::VScrollbar* wrap(GtkVScrollbar* object, bool take_copy)
 197 {
 198   return dynamic_cast<Gtk::VScrollbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 199 }
 200
 201 } /* namespace Glib */
 202
 203 namespace Gtk
 204 {
 205
 206
 207 /* The *_Class implementation: */
 208
 209 const Glib::Class& VScrollbar_Class::init()
 210 {
 211   if(!gtype_) // create the GType if necessary
 212   {
 213     // Glib::Class has to know the class init function to clone custom types.
 214     class_init_func_ = &VScrollbar_Class::class_init_function;
 215
 216     // This is actually just optimized away, apparently with no harm.
 217     // Make sure that the parent type has been created.
 218     //CppClassParent::CppObjectType::get_type();
 219
 220     // Create the wrapper type, with the same class/instance size as the base type.
 221     register_derived_type(gtk_vscrollbar_get_type());
 222
 223     // Add derived versions of interfaces, if the C type implements any interfaces:
 224   }
 225
 226   return *this;
 227 }
 228
 229 void VScrollbar_Class::class_init_function(void* g_class, void* class_data)
 230 {
 231   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 232   CppClassParent::class_init_function(klass, class_data);
 233
 234 #ifdef GLIBMM_VFUNCS_ENABLED
 235 #endif //GLIBMM_VFUNCS_ENABLED
 236
 237 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 238 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 239 }
 240
 241 #ifdef GLIBMM_VFUNCS_ENABLED
 242 #endif //GLIBMM_VFUNCS_ENABLED
 243
 244 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 245 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 246
 247
 248 Glib::ObjectBase* VScrollbar_Class::wrap_new(GObject* o)
 249 {
 250   return manage(new VScrollbar((GtkVScrollbar*)(o)));
 251
 252 }
 253
 254
 255 /* The implementation: */
 256
 257 VScrollbar::VScrollbar(const Glib::ConstructParams& construct_params)
 258 :
 259   Gtk::Scrollbar(construct_params)
 260 {
 261   }
 262
 263 VScrollbar::VScrollbar(GtkVScrollbar* castitem)
 264 :
 265   Gtk::Scrollbar((GtkScrollbar*)(castitem))
 266 {
 267   }
 268
 269 VScrollbar::~VScrollbar()
 270 {
 271   destroy_();
 272 }
 273
 274 VScrollbar::CppClassType VScrollbar::vscrollbar_class_; // initialize static member
 275
 276 GType VScrollbar::get_type()
 277 {
 278   return vscrollbar_class_.init().get_type();
 279 }
 280
 281 GType VScrollbar::get_base_type()
 282 {
 283   return gtk_vscrollbar_get_type();
 284 }
 285
 286
 287 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 288 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 289
 290 #ifdef GLIBMM_VFUNCS_ENABLED
 291 #endif //GLIBMM_VFUNCS_ENABLED
 292
 293
 294 } // namespace Gtk
 295
 296
 297 namespace Glib
 298 {
 299
 300 Gtk::HScrollbar* wrap(GtkHScrollbar* object, bool take_copy)
 301 {
 302   return dynamic_cast<Gtk::HScrollbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 303 }
 304
 305 } /* namespace Glib */
 306
 307 namespace Gtk
 308 {
 309
 310
 311 /* The *_Class implementation: */
 312
 313 const Glib::Class& HScrollbar_Class::init()
 314 {
 315   if(!gtype_) // create the GType if necessary
 316   {
 317     // Glib::Class has to know the class init function to clone custom types.
 318     class_init_func_ = &HScrollbar_Class::class_init_function;
 319
 320     // This is actually just optimized away, apparently with no harm.
 321     // Make sure that the parent type has been created.
 322     //CppClassParent::CppObjectType::get_type();
 323
 324     // Create the wrapper type, with the same class/instance size as the base type.
 325     register_derived_type(gtk_hscrollbar_get_type());
 326
 327     // Add derived versions of interfaces, if the C type implements any interfaces:
 328   }
 329
 330   return *this;
 331 }
 332
 333 void HScrollbar_Class::class_init_function(void* g_class, void* class_data)
 334 {
 335   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 336   CppClassParent::class_init_function(klass, class_data);
 337
 338 #ifdef GLIBMM_VFUNCS_ENABLED
 339 #endif //GLIBMM_VFUNCS_ENABLED
 340
 341 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 342 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 343 }
 344
 345 #ifdef GLIBMM_VFUNCS_ENABLED
 346 #endif //GLIBMM_VFUNCS_ENABLED
 347
 348 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 349 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 350
 351
 352 Glib::ObjectBase* HScrollbar_Class::wrap_new(GObject* o)
 353 {
 354   return manage(new HScrollbar((GtkHScrollbar*)(o)));
 355
 356 }
 357
 358
 359 /* The implementation: */
 360
 361 HScrollbar::HScrollbar(const Glib::ConstructParams& construct_params)
 362 :
 363   Gtk::Scrollbar(construct_params)
 364 {
 365   }
 366
 367 HScrollbar::HScrollbar(GtkHScrollbar* castitem)
 368 :
 369   Gtk::Scrollbar((GtkScrollbar*)(castitem))
 370 {
 371   }
 372
 373 HScrollbar::~HScrollbar()
 374 {
 375   destroy_();
 376 }
 377
 378 HScrollbar::CppClassType HScrollbar::hscrollbar_class_; // initialize static member
 379
 380 GType HScrollbar::get_type()
 381 {
 382   return hscrollbar_class_.init().get_type();
 383 }
 384
 385 GType HScrollbar::get_base_type()
 386 {
 387   return gtk_hscrollbar_get_type();
 388 }
 389
 390
 391 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 392 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 393
 394 #ifdef GLIBMM_VFUNCS_ENABLED
 395 #endif //GLIBMM_VFUNCS_ENABLED
 396
 397
 398 } // namespace Gtk
 399
 400