libgnomecanvasmm/item.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3 #include <libgnomecanvasmm/item.h>
   4 #include <libgnomecanvasmm/private/item_p.h>
   5
   6 // -*- C++ -*-
   7 /* $Id$ */
   8
   9 /* item.cc
  10  *
  11  * Copyright (C) 1998 EMC Capital Management Inc.
  12  * Developed by Havoc Pennington <hp@pobox.com>
  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 extern "C"
  30 {
  31 #include <stdarg.h>
  32 }
  33
  34 #include <libgnomecanvasmm/canvas.h>
  35 #include <libgnomecanvasmm/group.h>
  36 #include <libgnomecanvas/gnome-canvas-util.h>
  37
  38 namespace Gnome
  39 {
  40
  41 namespace Canvas
  42 {
  43
  44 //This function creates an empty va_list instead of just passing 0 to gnome_canvas_item_construct().
  45 //This is necessary on the alpha platform.
  46 //It needs to be a separate helper function because we need a ... argument.
  47 static void
  48 item_construct_helper(GnomeCanvasItem *item, GnomeCanvasGroup *group, ...)
  49 {
  50   va_list va;
  51   va_start(va, group);
  52   gnome_canvas_item_construct(item, group, 0, va);
  53   va_end(va);
  54 }
  55
  56 void
  57 Item::item_construct(Group& group)
  58 {
  59   item_construct_helper(GNOME_CANVAS_ITEM(gobj()), group.gobj()); //With no ... arguments.
  60 }
  61
  62 void
  63 Item::item_construct(Group& group, const gchar* first_arg_name,
  64                                  va_list ap)
  65 {
  66   gnome_canvas_item_construct(GNOME_CANVAS_ITEM(gobj()), group.gobj(),
  67                               first_arg_name,
  68                               ap);
  69 }
  70
  71 void
  72 Item::set(const gchar* first_arg_name, ...)
  73 {
  74   va_list args;
  75   va_start(args,first_arg_name);
  76   gnome_canvas_item_set_valist(gobj(), first_arg_name, args);
  77   va_end(args);
  78 }
  79
  80 int Item::grab(unsigned int event_mask, const Gdk::Cursor& cursor, guint32 etime)
  81 {
  82   return gnome_canvas_item_grab(gobj(), event_mask, const_cast<GdkCursor*>(cursor.gobj()), etime);
  83 }
  84
  85 int Item::grab(unsigned int event_mask, guint32 etime)
  86 {
  87   return gnome_canvas_item_grab(gobj(), event_mask, 0, etime);
  88 }
  89
  90 void
  91 Item::affine_relative(const Art::AffineTrans &affine)
  92 {
  93   gnome_canvas_item_affine_relative (gobj(), affine.gobj());
  94 }
  95
  96 void
  97 Item::affine_absolute (const Art::AffineTrans &affine)
  98 {
  99   gnome_canvas_item_affine_absolute (gobj(), affine.gobj());
 100 }
 101
 102 Art::AffineTrans
 103 Item::get_i2w_affine() const
 104 {
 105   double tmp[6] = {0};
 106
 107   gnome_canvas_item_i2w_affine(const_cast<GnomeCanvasItem*>(gobj()), tmp);
 108   return Art::AffineTrans(tmp);
 109 }
 110
 111 Art::AffineTrans
 112 Item::get_i2c_affine() const
 113 {
 114   double tmp[6] = {0};
 115
 116   gnome_canvas_item_i2c_affine(const_cast<GnomeCanvasItem*>(gobj()), tmp);
 117   return Art::AffineTrans(tmp);
 118 }
 119
 120 } /* namespace Canvas */
 121 } /* namespace Gnome */
 122
 123
 124 namespace
 125 {
 126
 127 gboolean Item_signal_event_callback(GnomeCanvasItem* self, GdkEvent* p0,void* data)
 128 {
 129   using namespace Gnome::Canvas;
 130   typedef sigc::slot< bool,GdkEvent* > SlotType;
 131
 132   // Do not try to call a signal on a disassociated wrapper.
 133   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 134   {
 135     try
 136     {
 137       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 138         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
 139     }
 140     catch(...)
 141     {
 142       Glib::exception_handlers_invoke();
 143     }
 144   }
 145
 146   typedef gboolean RType;
 147   return RType();
 148 }
 149
 150 gboolean Item_signal_event_notify_callback(GnomeCanvasItem* self, GdkEvent* p0, void* data)
 151 {
 152   using namespace Gnome::Canvas;
 153   typedef sigc::slot< void,GdkEvent* > SlotType;
 154
 155   // Do not try to call a signal on a disassociated wrapper.
 156   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 157   {
 158     try
 159     {
 160       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 161         (*static_cast<SlotType*>(slot))(p0);
 162     }
 163     catch(...)
 164     {
 165       Glib::exception_handlers_invoke();
 166     }
 167   }
 168
 169   typedef gboolean RType;
 170   return RType();
 171 }
 172
 173 const Glib::SignalProxyInfo Item_signal_event_info =
 174 {
 175   "event",
 176   (GCallback) &Item_signal_event_callback,
 177   (GCallback) &Item_signal_event_notify_callback
 178 };
 179
 180 } // anonymous namespace
 181
 182
 183 namespace Glib
 184 {
 185
 186 Gnome::Canvas::Item* wrap(GnomeCanvasItem* object, bool take_copy)
 187 {
 188   return dynamic_cast<Gnome::Canvas::Item *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 189 }
 190
 191 } /* namespace Glib */
 192
 193 namespace Gnome
 194 {
 195
 196 namespace Canvas
 197 {
 198
 199
 200 /* The *_Class implementation: */
 201
 202 const Glib::Class& Item_Class::init()
 203 {
 204   if(!gtype_) // create the GType if necessary
 205   {
 206     // Glib::Class has to know the class init function to clone custom types.
 207     class_init_func_ = &Item_Class::class_init_function;
 208
 209     // This is actually just optimized away, apparently with no harm.
 210     // Make sure that the parent type has been created.
 211     //CppClassParent::CppObjectType::get_type();
 212
 213     // Create the wrapper type, with the same class/instance size as the base type.
 214     register_derived_type(gnome_canvas_item_get_type());
 215
 216     // Add derived versions of interfaces, if the C type implements any interfaces:
 217   }
 218
 219   return *this;
 220 }
 221
 222 void Item_Class::class_init_function(void* g_class, void* class_data)
 223 {
 224   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 225   CppClassParent::class_init_function(klass, class_data);
 226
 227   klass->update = &update_vfunc_callback;
 228   klass->realize = &realize_vfunc_callback;
 229   klass->unrealize = &unrealize_vfunc_callback;
 230   klass->map = &map_vfunc_callback;
 231   klass->unmap = &unmap_vfunc_callback;
 232   klass->coverage = &coverage_vfunc_callback;
 233   klass->draw = &draw_vfunc_callback;
 234   klass->render = &render_vfunc_callback;
 235   klass->point = &point_vfunc_callback;
 236   klass->bounds = &bounds_vfunc_callback;
 237   klass->event = &event_callback;
 238 }
 239
 240 void Item_Class::update_vfunc_callback(GnomeCanvasItem* self, double* affine, ArtSVP* clip_path, int flags)
 241 {
 242   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 243       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 244
 245   // Non-gtkmmproc-generated custom classes implicitly call the default
 246   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 247   // generated classes can use this optimisation, which avoids the unnecessary
 248   // parameter conversions if there is no possibility of the virtual function
 249   // being overridden:
 250   if(obj && obj->is_derived_())
 251   {
 252     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 253     {
 254       // Call the virtual member method, which derived classes might override.
 255       obj->update_vfunc(affine, clip_path, flags);
 256     }
 257     catch(...)
 258     {
 259       Glib::exception_handlers_invoke();
 260     }
 261   }
 262   else
 263   {
 264     BaseClassType *const base = static_cast<BaseClassType*>(
 265         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 266     );
 267
 268     // Call the original underlying C function:
 269     if(base && base->update)
 270       (*base->update)(self, affine, clip_path, flags);
 271   }
 272 }
 273
 274 void Item_Class::realize_vfunc_callback(GnomeCanvasItem* self)
 275 {
 276   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 277       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 278
 279   // Non-gtkmmproc-generated custom classes implicitly call the default
 280   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 281   // generated classes can use this optimisation, which avoids the unnecessary
 282   // parameter conversions if there is no possibility of the virtual function
 283   // being overridden:
 284   if(obj && obj->is_derived_())
 285   {
 286     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 287     {
 288       // Call the virtual member method, which derived classes might override.
 289       obj->realize_vfunc();
 290     }
 291     catch(...)
 292     {
 293       Glib::exception_handlers_invoke();
 294     }
 295   }
 296   else
 297   {
 298     BaseClassType *const base = static_cast<BaseClassType*>(
 299         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 300     );
 301
 302     // Call the original underlying C function:
 303     if(base && base->realize)
 304       (*base->realize)(self);
 305   }
 306 }
 307
 308 void Item_Class::unrealize_vfunc_callback(GnomeCanvasItem* self)
 309 {
 310   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 311       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 312
 313   // Non-gtkmmproc-generated custom classes implicitly call the default
 314   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 315   // generated classes can use this optimisation, which avoids the unnecessary
 316   // parameter conversions if there is no possibility of the virtual function
 317   // being overridden:
 318   if(obj && obj->is_derived_())
 319   {
 320     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 321     {
 322       // Call the virtual member method, which derived classes might override.
 323       obj->unrealize_vfunc();
 324     }
 325     catch(...)
 326     {
 327       Glib::exception_handlers_invoke();
 328     }
 329   }
 330   else
 331   {
 332     BaseClassType *const base = static_cast<BaseClassType*>(
 333         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 334     );
 335
 336     // Call the original underlying C function:
 337     if(base && base->unrealize)
 338       (*base->unrealize)(self);
 339   }
 340 }
 341
 342 void Item_Class::map_vfunc_callback(GnomeCanvasItem* self)
 343 {
 344   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 345       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 346
 347   // Non-gtkmmproc-generated custom classes implicitly call the default
 348   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 349   // generated classes can use this optimisation, which avoids the unnecessary
 350   // parameter conversions if there is no possibility of the virtual function
 351   // being overridden:
 352   if(obj && obj->is_derived_())
 353   {
 354     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 355     {
 356       // Call the virtual member method, which derived classes might override.
 357       obj->map_vfunc();
 358     }
 359     catch(...)
 360     {
 361       Glib::exception_handlers_invoke();
 362     }
 363   }
 364   else
 365   {
 366     BaseClassType *const base = static_cast<BaseClassType*>(
 367         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 368     );
 369
 370     // Call the original underlying C function:
 371     if(base && base->map)
 372       (*base->map)(self);
 373   }
 374 }
 375
 376 void Item_Class::unmap_vfunc_callback(GnomeCanvasItem* self)
 377 {
 378   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 379       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 380
 381   // Non-gtkmmproc-generated custom classes implicitly call the default
 382   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 383   // generated classes can use this optimisation, which avoids the unnecessary
 384   // parameter conversions if there is no possibility of the virtual function
 385   // being overridden:
 386   if(obj && obj->is_derived_())
 387   {
 388     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 389     {
 390       // Call the virtual member method, which derived classes might override.
 391       obj->unmap_vfunc();
 392     }
 393     catch(...)
 394     {
 395       Glib::exception_handlers_invoke();
 396     }
 397   }
 398   else
 399   {
 400     BaseClassType *const base = static_cast<BaseClassType*>(
 401         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 402     );
 403
 404     // Call the original underlying C function:
 405     if(base && base->unmap)
 406       (*base->unmap)(self);
 407   }
 408 }
 409
 410 ArtUta* Item_Class::coverage_vfunc_callback(GnomeCanvasItem* self)
 411 {
 412   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 413       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 414
 415   // Non-gtkmmproc-generated custom classes implicitly call the default
 416   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 417   // generated classes can use this optimisation, which avoids the unnecessary
 418   // parameter conversions if there is no possibility of the virtual function
 419   // being overridden:
 420   if(obj && obj->is_derived_())
 421   {
 422     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 423     {
 424       // Call the virtual member method, which derived classes might override.
 425       return obj->coverage_vfunc();
 426     }
 427     catch(...)
 428     {
 429       Glib::exception_handlers_invoke();
 430     }
 431   }
 432   else
 433   {
 434     BaseClassType *const base = static_cast<BaseClassType*>(
 435         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 436     );
 437
 438     // Call the original underlying C function:
 439     if(base && base->coverage)
 440       return (*base->coverage)(self);
 441   }
 442
 443   typedef ArtUta* RType;
 444   return RType();
 445 }
 446
 447 void Item_Class::draw_vfunc_callback(GnomeCanvasItem* self, GdkDrawable* drawable, int x, int y, int width, int height)
 448 {
 449   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 450       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 451
 452   // Non-gtkmmproc-generated custom classes implicitly call the default
 453   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 454   // generated classes can use this optimisation, which avoids the unnecessary
 455   // parameter conversions if there is no possibility of the virtual function
 456   // being overridden:
 457   if(obj && obj->is_derived_())
 458   {
 459     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 460     {
 461       // Call the virtual member method, which derived classes might override.
 462       obj->draw_vfunc(Glib::wrap(drawable, true)
 463 , x, y, width, height);
 464     }
 465     catch(...)
 466     {
 467       Glib::exception_handlers_invoke();
 468     }
 469   }
 470   else
 471   {
 472     BaseClassType *const base = static_cast<BaseClassType*>(
 473         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 474     );
 475
 476     // Call the original underlying C function:
 477     if(base && base->draw)
 478       (*base->draw)(self, drawable, x, y, width, height);
 479   }
 480 }
 481
 482 void Item_Class::render_vfunc_callback(GnomeCanvasItem* self, GnomeCanvasBuf* buf)
 483 {
 484   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 485       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 486
 487   // Non-gtkmmproc-generated custom classes implicitly call the default
 488   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 489   // generated classes can use this optimisation, which avoids the unnecessary
 490   // parameter conversions if there is no possibility of the virtual function
 491   // being overridden:
 492   if(obj && obj->is_derived_())
 493   {
 494     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 495     {
 496       // Call the virtual member method, which derived classes might override.
 497       obj->render_vfunc(buf);
 498     }
 499     catch(...)
 500     {
 501       Glib::exception_handlers_invoke();
 502     }
 503   }
 504   else
 505   {
 506     BaseClassType *const base = static_cast<BaseClassType*>(
 507         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 508     );
 509
 510     // Call the original underlying C function:
 511     if(base && base->render)
 512       (*base->render)(self, buf);
 513   }
 514 }
 515
 516 double Item_Class::point_vfunc_callback(GnomeCanvasItem* self, double x, double y, int cx, int cy, GnomeCanvasItem** actual_item)
 517 {
 518   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 519       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 520
 521   // Non-gtkmmproc-generated custom classes implicitly call the default
 522   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 523   // generated classes can use this optimisation, which avoids the unnecessary
 524   // parameter conversions if there is no possibility of the virtual function
 525   // being overridden:
 526   if(obj && obj->is_derived_())
 527   {
 528     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 529     {
 530       // Call the virtual member method, which derived classes might override.
 531       return obj->point_vfunc(x, y, cx, cy, actual_item);
 532     }
 533     catch(...)
 534     {
 535       Glib::exception_handlers_invoke();
 536     }
 537   }
 538   else
 539   {
 540     BaseClassType *const base = static_cast<BaseClassType*>(
 541         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 542     );
 543
 544     // Call the original underlying C function:
 545     if(base && base->point)
 546       return (*base->point)(self, x, y, cx, cy, actual_item);
 547   }
 548
 549   typedef double RType;
 550   return RType();
 551 }
 552
 553 void Item_Class::bounds_vfunc_callback(GnomeCanvasItem* self, double* x1, double* y1, double* x2, double* y2)
 554 {
 555   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 556       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 557
 558   // Non-gtkmmproc-generated custom classes implicitly call the default
 559   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 560   // generated classes can use this optimisation, which avoids the unnecessary
 561   // parameter conversions if there is no possibility of the virtual function
 562   // being overridden:
 563   if(obj && obj->is_derived_())
 564   {
 565     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 566     {
 567       // Call the virtual member method, which derived classes might override.
 568       obj->bounds_vfunc(x1, y1, x2, y2);
 569     }
 570     catch(...)
 571     {
 572       Glib::exception_handlers_invoke();
 573     }
 574   }
 575   else
 576   {
 577     BaseClassType *const base = static_cast<BaseClassType*>(
 578         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 579     );
 580
 581     // Call the original underlying C function:
 582     if(base && base->bounds)
 583       (*base->bounds)(self, x1, y1, x2, y2);
 584   }
 585 }
 586
 587
 588 gboolean Item_Class::event_callback(GnomeCanvasItem* self, GdkEvent* p0)
 589 {
 590   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 591       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 592
 593   // Non-gtkmmproc-generated custom classes implicitly call the default
 594   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 595   // generated classes can use this optimisation, which avoids the unnecessary
 596   // parameter conversions if there is no possibility of the virtual function
 597   // being overridden:
 598   if(obj && obj->is_derived_())
 599   {
 600     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 601     {
 602       // Call the virtual member method, which derived classes might override.
 603       return static_cast<int>(obj->on_event(p0));
 604     }
 605     catch(...)
 606     {
 607       Glib::exception_handlers_invoke();
 608     }
 609   }
 610   else
 611   {
 612     BaseClassType *const base = static_cast<BaseClassType*>(
 613         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 614     );
 615
 616     // Call the original underlying C function:
 617     if(base && base->event)
 618       return (*base->event)(self, p0);
 619   }
 620
 621   typedef gboolean RType;
 622   return RType();
 623 }
 624
 625
 626 Glib::ObjectBase* Item_Class::wrap_new(GObject* o)
 627 {
 628   return manage(new Item((GnomeCanvasItem*)(o)));
 629
 630 }
 631
 632
 633 /* The implementation: */
 634
 635 Item::Item(const Glib::ConstructParams& construct_params)
 636 :
 637   Gtk::Object(construct_params)
 638 {
 639   }
 640
 641 Item::Item(GnomeCanvasItem* castitem)
 642 :
 643   Gtk::Object((GtkObject*)(castitem))
 644 {
 645   }
 646
 647 Item::~Item()
 648 {
 649   destroy_();
 650 }
 651
 652 Item::CppClassType Item::item_class_; // initialize static member
 653
 654 GType Item::get_type()
 655 {
 656   return item_class_.init().get_type();
 657 }
 658
 659 GType Item::get_base_type()
 660 {
 661   return gnome_canvas_item_get_type();
 662 }
 663
 664
 665 void Item::move(double dx, double dy)
 666 {
 667   gnome_canvas_item_move(gobj(), dx, dy);
 668 }
 669
 670 void Item::raise(int positions)
 671 {
 672   gnome_canvas_item_raise(gobj(), positions);
 673 }
 674
 675 void Item::lower(int positions)
 676 {
 677   gnome_canvas_item_lower(gobj(), positions);
 678 }
 679
 680 void Item::raise_to_top()
 681 {
 682   gnome_canvas_item_raise_to_top(gobj());
 683 }
 684
 685 void Item::lower_to_bottom()
 686 {
 687   gnome_canvas_item_lower_to_bottom(gobj());
 688 }
 689
 690 void Item::ungrab(guint32 etime)
 691 {
 692   gnome_canvas_item_ungrab(gobj(), etime);
 693 }
 694
 695 void Item::w2i(double& x, double& y)
 696 {
 697   gnome_canvas_item_w2i(gobj(), &(x), &(y));
 698 }
 699
 700 void Item::i2w(double& x, double& y)
 701 {
 702   gnome_canvas_item_i2w(gobj(), &(x), &(y));
 703 }
 704
 705 void Item::grab_focus()
 706 {
 707   gnome_canvas_item_grab_focus(gobj());
 708 }
 709
 710 void Item::get_bounds(double& x1, double& y1, double& x2, double& y2) const
 711 {
 712   gnome_canvas_item_get_bounds(const_cast<GnomeCanvasItem*>(gobj()), &(x1), &(y1), &(x2), &(y2));
 713 }
 714
 715 void Item::show()
 716 {
 717   gnome_canvas_item_show(gobj());
 718 }
 719
 720 void Item::hide()
 721 {
 722   gnome_canvas_item_hide(gobj());
 723 }
 724
 725 void Item::reparent(Group& new_group)
 726 {
 727   gnome_canvas_item_reparent(gobj(), (new_group).gobj());
 728 }
 729
 730 Canvas* Item::get_canvas() const
 731 {
 732   return Glib::wrap(gobj()->canvas);
 733 }
 734
 735 void Item::request_update()
 736 {
 737   gnome_canvas_item_request_update(gobj());
 738 }
 739
 740 void Item::reset_bounds()
 741 {
 742   gnome_canvas_item_reset_bounds(gobj());
 743 }
 744
 745 void Item::update_svp(ArtSVP ** p_svp, ArtSVP * new_svp)
 746 {
 747   gnome_canvas_item_update_svp(gobj(), p_svp, new_svp);
 748 }
 749
 750 void Item::update_svp_clip(ArtSVP ** p_svp, ArtSVP * new_svp, ArtSVP * clip_svp)
 751 {
 752   gnome_canvas_item_update_svp_clip(gobj(), p_svp, new_svp, clip_svp);
 753 }
 754
 755 void Item::request_redraw_svp(const ArtSVP* svp)
 756 {
 757   gnome_canvas_item_request_redraw_svp(gobj(), svp);
 758 }
 759
 760 void Item::update_bbox(int x1, int y1, int x2, int y2)
 761 {
 762   gnome_canvas_update_bbox(gobj(), x1, y1, x2, y2);
 763 }
 764
 765
 766 Glib::SignalProxy1< bool,GdkEvent* > Item::signal_event()
 767 {
 768   return Glib::SignalProxy1< bool,GdkEvent* >(this, &Item_signal_event_info);
 769 }
 770
 771
 772 Glib::PropertyProxy<Group*> Item::property_parent()
 773 {
 774   return Glib::PropertyProxy<Group*>(this, "parent");
 775 }
 776
 777 Glib::PropertyProxy_ReadOnly<Group*> Item::property_parent() const
 778 {
 779   return Glib::PropertyProxy_ReadOnly<Group*>(this, "parent");
 780 }
 781
 782
 783 bool Gnome::Canvas::Item::on_event(GdkEvent* p1)
 784 {
 785   BaseClassType *const base = static_cast<BaseClassType*>(
 786       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 787   );
 788
 789   if(base && base->event)
 790     return (*base->event)(gobj(),p1);
 791
 792   typedef bool RType;
 793   return RType();
 794 }
 795
 796
 797 void Gnome::Canvas::Item::update_vfunc(double* affine, ArtSVP* clip_path, int flags)
 798 {
 799   BaseClassType *const base = static_cast<BaseClassType*>(
 800       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 801   );
 802
 803   if(base && base->update)
 804     (*base->update)(gobj(),affine,clip_path,flags);
 805 }
 806
 807 void Gnome::Canvas::Item::realize_vfunc()
 808 {
 809   BaseClassType *const base = static_cast<BaseClassType*>(
 810       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 811   );
 812
 813   if(base && base->realize)
 814     (*base->realize)(gobj());
 815 }
 816
 817 void Gnome::Canvas::Item::unrealize_vfunc()
 818 {
 819   BaseClassType *const base = static_cast<BaseClassType*>(
 820       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 821   );
 822
 823   if(base && base->unrealize)
 824     (*base->unrealize)(gobj());
 825 }
 826
 827 void Gnome::Canvas::Item::map_vfunc()
 828 {
 829   BaseClassType *const base = static_cast<BaseClassType*>(
 830       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 831   );
 832
 833   if(base && base->map)
 834     (*base->map)(gobj());
 835 }
 836
 837 void Gnome::Canvas::Item::unmap_vfunc()
 838 {
 839   BaseClassType *const base = static_cast<BaseClassType*>(
 840       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 841   );
 842
 843   if(base && base->unmap)
 844     (*base->unmap)(gobj());
 845 }
 846
 847 ArtUta* Gnome::Canvas::Item::coverage_vfunc()
 848 {
 849   BaseClassType *const base = static_cast<BaseClassType*>(
 850       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 851   );
 852
 853   if(base && base->coverage)
 854     return (*base->coverage)(gobj());
 855
 856   typedef ArtUta* RType;
 857   return RType();
 858 }
 859
 860 void Gnome::Canvas::Item::draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height)
 861 {
 862   BaseClassType *const base = static_cast<BaseClassType*>(
 863       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 864   );
 865
 866   if(base && base->draw)
 867     (*base->draw)(gobj(),Glib::unwrap(drawable),x,y,width,height);
 868 }
 869
 870 void Gnome::Canvas::Item::render_vfunc(GnomeCanvasBuf* buf)
 871 {
 872   BaseClassType *const base = static_cast<BaseClassType*>(
 873       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 874   );
 875
 876   if(base && base->render)
 877     (*base->render)(gobj(),buf);
 878 }
 879
 880 double Gnome::Canvas::Item::point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item)
 881 {
 882   BaseClassType *const base = static_cast<BaseClassType*>(
 883       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 884   );
 885
 886   if(base && base->point)
 887     return (*base->point)(gobj(),x,y,cx,cy,actual_item);
 888
 889   typedef double RType;
 890   return RType();
 891 }
 892
 893 void Gnome::Canvas::Item::bounds_vfunc(double* x1, double* y1, double* x2, double* y2)
 894 {
 895   BaseClassType *const base = static_cast<BaseClassType*>(
 896       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 897   );
 898
 899   if(base && base->bounds)
 900     (*base->bounds)(gobj(),x1,y1,x2,y2);
 901 }
 902
 903
 904 } // namespace Canvas
 905
 906 } // namespace Gnome
 907
 908