libs/libgnomecanvasmm/libgnomecanvasmm/line.h

   1 // -*- c++ -*-
   2 // Generated by gtkmmproc -- DO NOT MODIFY!
   3 #ifndef _LIBGNOMECANVASMM_LINE_H
   4 #define _LIBGNOMECANVASMM_LINE_H
   5
   6 #include <glibmm.h>
   7
   8 /* $Id$ */
   9
  10 /* line.h
  11  *
  12  * Copyright (C) 1998 EMC Capital Management Inc.
  13  * Developed by Havoc Pennington <hp@pobox.com>
  14  *
  15  * Copyright (C) 1999 The Gtk-- Development Team
  16  *
  17  * This library is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU Library General Public
  19  * License as published by the Free Software Foundation; either
  20  * version 2 of the License, or (at your option) any later version.
  21  *
  22  * This library is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25  * Library General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU Library General Public
  28  * License along with this library; if not, write to the Free
  29  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30  */
  31
  32 #include <libgnomecanvasmm/item.h>
  33 #include <libgnomecanvas/gnome-canvas-line.h>
  34 #include <libgnomecanvas/gnome-canvas-util.h>
  35 #include <libgnomecanvas/libgnomecanvas.h>
  36 #include <vector>
  37
  38
  39 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  40 typedef struct _GnomeCanvasLine GnomeCanvasLine;
  41 typedef struct _GnomeCanvasLineClass GnomeCanvasLineClass;
  42 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  43
  44
  45 namespace Gnome
  46 {
  47
  48 namespace Canvas
  49 { class Line_Class; } // namespace Canvas
  50
  51 } // namespace Gnome
  52 namespace Gnome
  53 {
  54
  55 namespace Canvas
  56 {
  57
  58 class GnomeGroup;
  59
  60 // Sample use of Gnome_CanvasPoints :
  61
  62 //   Gnome_CanvasPoints points;
  63 //
  64 //   points.push_back(Art::Point(0, 0));
  65 //   points.push_back(Art::Point(100,0));
  66 //   points.push_back(Art::Point(0,100));
  67 //   points.push_back(Art::Point(100,100));
  68 //
  69 //   line = new Gnome_CanvasLine(&m_canvasgroup,points);
  70
  71 //using std::vector;
  72
  73 /** Wrapper for GnomeCanvasPoints.
  74  * GnomeCanvasPoints is actually a BoxedType,
  75  * but this acts in a similar way, with the advantage of acting like a std::vector.
  76  */
  77 class Points : public std::vector<Art::Point>
  78 {
  79 public:
  80   Points(size_type nbpoints = 0);
  81   explicit Points(GnomeCanvasPoints* castitem);
  82   ~Points();
  83
  84 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  85   typedef  GnomeCanvasPoints BaseObjectType;  //So that this works with tempaltes that are intended for normal BoxedTypes.
  86 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  87
  88   operator bool() const;
  89   bool is_null() const;
  90
  91   const GnomeCanvasPoints* gobj() const { return _gobj(); }
  92   GnomeCanvasPoints* gobj() { return _gobj(); }
  93   static GType get_type () { return GNOME_TYPE_CANVAS_POINTS; }
  94
  95 protected:
  96   GnomeCanvasPoints* _gobj() const;
  97   mutable GnomeCanvasPoints* points_;
  98   mutable bool owned_;
  99 };
 100
 101
 102 class Line : public Item
 103 {
 104   public:
 105 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 106   typedef Line CppObjectType;
 107   typedef Line_Class CppClassType;
 108   typedef GnomeCanvasLine BaseObjectType;
 109   typedef GnomeCanvasLineClass BaseClassType;
 110 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 111
 112   virtual ~Line();
 113
 114 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 115
 116 private:
 117   friend class Line_Class;
 118   static CppClassType line_class_;
 119
 120   // noncopyable
 121   Line(const Line&);
 122   Line& operator=(const Line&);
 123
 124 protected:
 125   explicit Line(const Glib::ConstructParams& construct_params);
 126   explicit Line(GnomeCanvasLine* castitem);
 127
 128 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 129
 130 public:
 131 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 132   static GType get_type()      G_GNUC_CONST;
 133   static GType get_base_type() G_GNUC_CONST;
 134 #endif
 135
 136   ///Provides access to the underlying C GtkObject.
 137   GnomeCanvasLine*       gobj()       { return reinterpret_cast<GnomeCanvasLine*>(gobject_); }
 138
 139   ///Provides access to the underlying C GtkObject.
 140   const GnomeCanvasLine* gobj() const { return reinterpret_cast<GnomeCanvasLine*>(gobject_); }
 141
 142
 143 public:
 144   //C++ methods used to invoke GTK+ virtual functions:
 145
 146 protected:
 147   //GTK+ Virtual Functions (override these to change behaviour):
 148
 149   //Default Signal Handlers::
 150
 151
 152 private:
 153
 154 public:
 155   explicit Line(Group& parent);
 156   Line(Group& parent, const Points& points);
 157
 158   /**
 159    *
 160    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 161    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 162    * the value of the property changes.
 163    */
 164   Glib::PropertyProxy<Points> property_points() ;
 165
 166 /**
 167    *
 168    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 169    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 170    * the value of the property changes.
 171    */
 172   Glib::PropertyProxy_ReadOnly<Points> property_points() const;
 173
 174   /**
 175    *
 176    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 177    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 178    * the value of the property changes.
 179    */
 180   Glib::PropertyProxy<Glib::ustring> property_fill_color() ;
 181
 182 /**
 183    *
 184    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 185    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 186    * the value of the property changes.
 187    */
 188   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_fill_color() const;
 189
 190   /**
 191    *
 192    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 193    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 194    * the value of the property changes.
 195    */
 196   Glib::PropertyProxy<Gdk::Color> property_fill_color_gdk() ;
 197
 198 /**
 199    *
 200    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 201    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 202    * the value of the property changes.
 203    */
 204   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_fill_color_gdk() const;
 205
 206   /**
 207    *
 208    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 209    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 210    * the value of the property changes.
 211    */
 212   Glib::PropertyProxy<guint> property_fill_color_rgba() ;
 213
 214 /**
 215    *
 216    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 217    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 218    * the value of the property changes.
 219    */
 220   Glib::PropertyProxy_ReadOnly<guint> property_fill_color_rgba() const;
 221
 222   /**
 223    *
 224    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 225    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 226    * the value of the property changes.
 227    */
 228   Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() ;
 229
 230 /**
 231    *
 232    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 233    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 234    * the value of the property changes.
 235    */
 236   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
 237
 238   /**
 239    *
 240    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 241    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 242    * the value of the property changes.
 243    */
 244   Glib::PropertyProxy<guint> property_width_pixels() ;
 245
 246 /**
 247    *
 248    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 249    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 250    * the value of the property changes.
 251    */
 252   Glib::PropertyProxy_ReadOnly<guint> property_width_pixels() const;
 253
 254   /**
 255    *
 256    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 257    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 258    * the value of the property changes.
 259    */
 260   Glib::PropertyProxy<double> property_width_units() ;
 261
 262 /**
 263    *
 264    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 265    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 266    * the value of the property changes.
 267    */
 268   Glib::PropertyProxy_ReadOnly<double> property_width_units() const;
 269
 270   /**
 271    *
 272    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 273    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 274    * the value of the property changes.
 275    */
 276   Glib::PropertyProxy<Gdk::CapStyle> property_cap_style() ;
 277
 278 /**
 279    *
 280    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 281    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 282    * the value of the property changes.
 283    */
 284   Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> property_cap_style() const;
 285
 286   /**
 287    *
 288    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 289    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 290    * the value of the property changes.
 291    */
 292   Glib::PropertyProxy<Gdk::JoinStyle> property_join_style() ;
 293
 294 /**
 295    *
 296    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 297    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 298    * the value of the property changes.
 299    */
 300   Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> property_join_style() const;
 301
 302   /**
 303    *
 304    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 305    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 306    * the value of the property changes.
 307    */
 308   Glib::PropertyProxy<Gdk::LineStyle> property_line_style() ;
 309
 310 /**
 311    *
 312    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 313    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 314    * the value of the property changes.
 315    */
 316   Glib::PropertyProxy_ReadOnly<Gdk::LineStyle> property_line_style() const;
 317
 318   /**
 319    *
 320    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 321    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 322    * the value of the property changes.
 323    */
 324   Glib::PropertyProxy<bool> property_first_arrowhead() ;
 325
 326 /**
 327    *
 328    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 329    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 330    * the value of the property changes.
 331    */
 332   Glib::PropertyProxy_ReadOnly<bool> property_first_arrowhead() const;
 333
 334   /**
 335    *
 336    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 337    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 338    * the value of the property changes.
 339    */
 340   Glib::PropertyProxy<bool> property_last_arrowhead() ;
 341
 342 /**
 343    *
 344    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 345    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 346    * the value of the property changes.
 347    */
 348   Glib::PropertyProxy_ReadOnly<bool> property_last_arrowhead() const;
 349
 350   /**
 351    *
 352    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 353    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 354    * the value of the property changes.
 355    */
 356   Glib::PropertyProxy<bool> property_smooth() ;
 357
 358 /**
 359    *
 360    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 361    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 362    * the value of the property changes.
 363    */
 364   Glib::PropertyProxy_ReadOnly<bool> property_smooth() const;
 365
 366   /**
 367    *
 368    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 369    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 370    * the value of the property changes.
 371    */
 372   Glib::PropertyProxy<guint> property_spline_steps() ;
 373
 374 /**
 375    *
 376    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 377    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 378    * the value of the property changes.
 379    */
 380   Glib::PropertyProxy_ReadOnly<guint> property_spline_steps() const;
 381
 382   /**
 383    *
 384    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 385    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 386    * the value of the property changes.
 387    */
 388   Glib::PropertyProxy<double> property_arrow_shape_a() ;
 389
 390 /**
 391    *
 392    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 393    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 394    * the value of the property changes.
 395    */
 396   Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_a() const;
 397
 398   /**
 399    *
 400    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 401    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 402    * the value of the property changes.
 403    */
 404   Glib::PropertyProxy<double> property_arrow_shape_b() ;
 405
 406 /**
 407    *
 408    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 409    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 410    * the value of the property changes.
 411    */
 412   Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_b() const;
 413
 414   /**
 415    *
 416    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 417    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 418    * the value of the property changes.
 419    */
 420   Glib::PropertyProxy<double> property_arrow_shape_c() ;
 421
 422 /**
 423    *
 424    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 425    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 426    * the value of the property changes.
 427    */
 428   Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_c() const;
 429
 430
 431 };
 432
 433 } /* namespace Canvas */
 434 } /* namespace Gnome */
 435
 436
 437 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 438 namespace Glib
 439 {
 440
 441 template <>
 442 class Value<Gnome::Canvas::Points> : public Value_Boxed<Gnome::Canvas::Points>
 443 {
 444 public:
 445   static GType value_type() G_GNUC_CONST;
 446 };
 447
 448 } // namespace Glib
 449 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 450
 451 namespace Glib
 452 {
 453   /** @relates Gnome::Canvas::Line
 454    * @param object The C instance
 455    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
 456    * @result A C++ instance that wraps this C instance.
 457    */
 458   Gnome::Canvas::Line* wrap(GnomeCanvasLine* object, bool take_copy = false);
 459 }
 460 #endif /* _LIBGNOMECANVASMM_LINE_H */
 461