libs/gtkmm2/gtk/gtkmm/fixed.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <gtkmm/fixed.h>
   4 #include <gtkmm/private/fixed_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/gtkfixed.h>
  29
  30 namespace Gtk
  31 {
  32 }
  33
  34
  35 namespace
  36 {
  37 } // anonymous namespace
  38
  39
  40 namespace Glib
  41 {
  42
  43 Gtk::Fixed* wrap(GtkFixed* object, bool take_copy)
  44 {
  45   return dynamic_cast<Gtk::Fixed *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  46 }
  47
  48 } /* namespace Glib */
  49
  50 namespace Gtk
  51 {
  52
  53
  54 /* The *_Class implementation: */
  55
  56 const Glib::Class& Fixed_Class::init()
  57 {
  58   if(!gtype_) // create the GType if necessary
  59   {
  60     // Glib::Class has to know the class init function to clone custom types.
  61     class_init_func_ = &Fixed_Class::class_init_function;
  62
  63     // This is actually just optimized away, apparently with no harm.
  64     // Make sure that the parent type has been created.
  65     //CppClassParent::CppObjectType::get_type();
  66
  67     // Create the wrapper type, with the same class/instance size as the base type.
  68     register_derived_type(gtk_fixed_get_type());
  69
  70     // Add derived versions of interfaces, if the C type implements any interfaces:
  71   }
  72
  73   return *this;
  74 }
  75
  76 void Fixed_Class::class_init_function(void* g_class, void* class_data)
  77 {
  78   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  79   CppClassParent::class_init_function(klass, class_data);
  80
  81 }
  82
  83
  84 Glib::ObjectBase* Fixed_Class::wrap_new(GObject* o)
  85 {
  86   return manage(new Fixed((GtkFixed*)(o)));
  87
  88 }
  89
  90
  91 /* The implementation: */
  92
  93 Fixed::Fixed(const Glib::ConstructParams& construct_params)
  94 :
  95   Gtk::Container(construct_params)
  96 {
  97   }
  98
  99 Fixed::Fixed(GtkFixed* castitem)
 100 :
 101   Gtk::Container((GtkContainer*)(castitem))
 102 {
 103   }
 104
 105 Fixed::~Fixed()
 106 {
 107   destroy_();
 108 }
 109
 110 Fixed::CppClassType Fixed::fixed_class_; // initialize static member
 111
 112 GType Fixed::get_type()
 113 {
 114   return fixed_class_.init().get_type();
 115 }
 116
 117 GType Fixed::get_base_type()
 118 {
 119   return gtk_fixed_get_type();
 120 }
 121
 122
 123 Fixed::Fixed()
 124 :
 125   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 126   Gtk::Container(Glib::ConstructParams(fixed_class_.init()))
 127 {
 128   }
 129
 130 void Fixed::put(Widget& widget, int x, int y)
 131 {
 132   gtk_fixed_put(gobj(), (widget).gobj(), x, y);
 133 }
 134
 135 void Fixed::move(Widget& widget, int x, int y)
 136 {
 137   gtk_fixed_move(gobj(), (widget).gobj(), x, y);
 138 }
 139
 140 void Fixed::set_has_window(bool has_window)
 141 {
 142   gtk_fixed_set_has_window(gobj(), static_cast<int>(has_window));
 143 }
 144
 145 bool Fixed::get_has_window() const
 146 {
 147   return gtk_fixed_get_has_window(const_cast<GtkFixed*>(gobj()));
 148 }
 149
 150
 151 } // namespace Gtk
 152
 153