libs/gtkmm2/gtk/gtkmm/eventbox.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/eventbox.h>
   5 #include <gtkmm/private/eventbox_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/gtkeventbox.h>
  30
  31 namespace
  32 {
  33 } // anonymous namespace
  34
  35
  36 namespace Glib
  37 {
  38
  39 Gtk::EventBox* wrap(GtkEventBox* object, bool take_copy)
  40 {
  41   return dynamic_cast<Gtk::EventBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
  42 }
  43
  44 } /* namespace Glib */
  45
  46 namespace Gtk
  47 {
  48
  49
  50 /* The *_Class implementation: */
  51
  52 const Glib::Class& EventBox_Class::init()
  53 {
  54   if(!gtype_) // create the GType if necessary
  55   {
  56     // Glib::Class has to know the class init function to clone custom types.
  57     class_init_func_ = &EventBox_Class::class_init_function;
  58
  59     // This is actually just optimized away, apparently with no harm.
  60     // Make sure that the parent type has been created.
  61     //CppClassParent::CppObjectType::get_type();
  62
  63     // Create the wrapper type, with the same class/instance size as the base type.
  64     register_derived_type(gtk_event_box_get_type());
  65
  66     // Add derived versions of interfaces, if the C type implements any interfaces:
  67   }
  68
  69   return *this;
  70 }
  71
  72 void EventBox_Class::class_init_function(void* g_class, void* class_data)
  73 {
  74   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  75   CppClassParent::class_init_function(klass, class_data);
  76
  77 #ifdef GLIBMM_VFUNCS_ENABLED
  78 #endif //GLIBMM_VFUNCS_ENABLED
  79
  80 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  81 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  82 }
  83
  84 #ifdef GLIBMM_VFUNCS_ENABLED
  85 #endif //GLIBMM_VFUNCS_ENABLED
  86
  87 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  88 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  89
  90
  91 Glib::ObjectBase* EventBox_Class::wrap_new(GObject* o)
  92 {
  93   return manage(new EventBox((GtkEventBox*)(o)));
  94
  95 }
  96
  97
  98 /* The implementation: */
  99
 100 EventBox::EventBox(const Glib::ConstructParams& construct_params)
 101 :
 102   Gtk::Bin(construct_params)
 103 {
 104   }
 105
 106 EventBox::EventBox(GtkEventBox* castitem)
 107 :
 108   Gtk::Bin((GtkBin*)(castitem))
 109 {
 110   }
 111
 112 EventBox::~EventBox()
 113 {
 114   destroy_();
 115 }
 116
 117 EventBox::CppClassType EventBox::eventbox_class_; // initialize static member
 118
 119 GType EventBox::get_type()
 120 {
 121   return eventbox_class_.init().get_type();
 122 }
 123
 124 GType EventBox::get_base_type()
 125 {
 126   return gtk_event_box_get_type();
 127 }
 128
 129
 130 EventBox::EventBox()
 131 :
 132   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 133   Glib::ObjectBase(0),
 134   Gtk::Bin(Glib::ConstructParams(eventbox_class_.init()))
 135 {
 136   }
 137
 138 bool EventBox::get_visible_window() const
 139 {
 140   return gtk_event_box_get_visible_window(const_cast<GtkEventBox*>(gobj()));
 141 }
 142
 143 void EventBox::set_visible_window(bool visible_window)
 144 {
 145 gtk_event_box_set_visible_window(gobj(), static_cast<int>(visible_window));
 146 }
 147
 148 bool EventBox::get_above_child() const
 149 {
 150   return gtk_event_box_get_above_child(const_cast<GtkEventBox*>(gobj()));
 151 }
 152
 153 void EventBox::set_above_child(bool above_child)
 154 {
 155 gtk_event_box_set_above_child(gobj(), static_cast<int>(above_child));
 156 }
 157
 158
 159 #ifdef GLIBMM_PROPERTIES_ENABLED
 160 Glib::PropertyProxy<bool> EventBox::property_visible_window()
 161 {
 162   return Glib::PropertyProxy<bool>(this, "visible-window");
 163 }
 164 #endif //GLIBMM_PROPERTIES_ENABLED
 165
 166 #ifdef GLIBMM_PROPERTIES_ENABLED
 167 Glib::PropertyProxy_ReadOnly<bool> EventBox::property_visible_window() const
 168 {
 169   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-window");
 170 }
 171 #endif //GLIBMM_PROPERTIES_ENABLED
 172
 173 #ifdef GLIBMM_PROPERTIES_ENABLED
 174 Glib::PropertyProxy<bool> EventBox::property_above_child()
 175 {
 176   return Glib::PropertyProxy<bool>(this, "above-child");
 177 }
 178 #endif //GLIBMM_PROPERTIES_ENABLED
 179
 180 #ifdef GLIBMM_PROPERTIES_ENABLED
 181 Glib::PropertyProxy_ReadOnly<bool> EventBox::property_above_child() const
 182 {
 183   return Glib::PropertyProxy_ReadOnly<bool>(this, "above-child");
 184 }
 185 #endif //GLIBMM_PROPERTIES_ENABLED
 186
 187
 188 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 189 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 190
 191 #ifdef GLIBMM_VFUNCS_ENABLED
 192 #endif //GLIBMM_VFUNCS_ENABLED
 193
 194
 195 } // namespace Gtk
 196
 197