libs/gtkmm2/atk/atkmm/objectaccessible.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <atkmm/objectaccessible.h>
   4 #include <atkmm/private/objectaccessible_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 <atk/atkgobjectaccessible.h>
  29
  30 namespace
  31 {
  32 } // anonymous namespace
  33
  34
  35 namespace Glib
  36 {
  37
  38 Glib::RefPtr<Atk::ObjectAccessible> wrap(AtkGObjectAccessible* object, bool take_copy)
  39 {
  40   return Glib::RefPtr<Atk::ObjectAccessible>( dynamic_cast<Atk::ObjectAccessible*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  41   //We use dynamic_cast<> in case of multiple inheritance.
  42 }
  43
  44 } /* namespace Glib */
  45
  46
  47 namespace Atk
  48 {
  49
  50
  51 /* The *_Class implementation: */
  52
  53 const Glib::Class& ObjectAccessible_Class::init()
  54 {
  55   if(!gtype_) // create the GType if necessary
  56   {
  57     // Glib::Class has to know the class init function to clone custom types.
  58     class_init_func_ = &ObjectAccessible_Class::class_init_function;
  59
  60     // This is actually just optimized away, apparently with no harm.
  61     // Make sure that the parent type has been created.
  62     //CppClassParent::CppObjectType::get_type();
  63
  64     // Create the wrapper type, with the same class/instance size as the base type.
  65     register_derived_type(atk_gobject_accessible_get_type());
  66
  67     // Add derived versions of interfaces, if the C type implements any interfaces:
  68   }
  69
  70   return *this;
  71 }
  72
  73 void ObjectAccessible_Class::class_init_function(void* g_class, void* class_data)
  74 {
  75   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  76   CppClassParent::class_init_function(klass, class_data);
  77
  78 }
  79
  80
  81 Glib::ObjectBase* ObjectAccessible_Class::wrap_new(GObject* object)
  82 {
  83   return new ObjectAccessible((AtkGObjectAccessible*)object);
  84 }
  85
  86
  87 /* The implementation: */
  88
  89 AtkGObjectAccessible* ObjectAccessible::gobj_copy()
  90 {
  91   reference();
  92   return gobj();
  93 }
  94
  95 ObjectAccessible::ObjectAccessible(const Glib::ConstructParams& construct_params)
  96 :
  97   Atk::Object(construct_params)
  98 {}
  99
 100 ObjectAccessible::ObjectAccessible(AtkGObjectAccessible* castitem)
 101 :
 102   Atk::Object((AtkObject*)(castitem))
 103 {}
 104
 105 ObjectAccessible::~ObjectAccessible()
 106 {}
 107
 108
 109 ObjectAccessible::CppClassType ObjectAccessible::objectaccessible_class_; // initialize static member
 110
 111 GType ObjectAccessible::get_type()
 112 {
 113   return objectaccessible_class_.init().get_type();
 114 }
 115
 116 GType ObjectAccessible::get_base_type()
 117 {
 118   return atk_gobject_accessible_get_type();
 119 }
 120
 121
 122 Glib::RefPtr<Glib::Object> ObjectAccessible::get_object()
 123 {
 124
 125   Glib::RefPtr<Glib::Object> retvalue = Glib::wrap(atk_gobject_accessible_get_object(gobj()));
 126
 127   if(retvalue)
 128     retvalue->reference(); //The function does not do a ref for us.
 129   return retvalue;
 130 }
 131
 132 Glib::RefPtr<const Glib::Object> ObjectAccessible::get_object() const
 133 {
 134
 135   Glib::RefPtr<const Glib::Object> retvalue = Glib::wrap(atk_gobject_accessible_get_object(const_cast<AtkGObjectAccessible*>(gobj())));
 136
 137   if(retvalue)
 138     retvalue->reference(); //The function does not do a ref for us.
 139   return retvalue;
 140 }
 141
 142 Glib::RefPtr<Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<Glib::Object>& obj)
 143 {
 144
 145   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_gobject_accessible_for_object(Glib::unwrap(obj)));
 146
 147   if(retvalue)
 148     retvalue->reference(); //The function does not do a ref for us.
 149   return retvalue;
 150 }
 151
 152 Glib::RefPtr<const Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<const Glib::Object>& obj)
 153 {
 154
 155   Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_gobject_accessible_for_object(const_cast<GObject*>(Glib::unwrap<Glib::Object>(obj))));
 156
 157   if(retvalue)
 158     retvalue->reference(); //The function does not do a ref for us.
 159   return retvalue;
 160 }
 161
 162
 163 } // namespace Atk
 164
 165