libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h

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