libs/gtkmm2/gtk/gtkmm/texttag.h

   1 // -*- c++ -*-
   2 // Generated by gtkmmproc -- DO NOT MODIFY!
   3 #ifndef _GTKMM_TEXTTAG_H
   4 #define _GTKMM_TEXTTAG_H
   5
   6 #include <glibmm.h>
   7
   8 /* $Id$ */
   9
  10 /* texttag.h
  11  *
  12  * Copyright (C) 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
  30 #include <gtkmm/object.h>
  31 #include <gtkmm/enums.h>
  32 #include <gdkmm/bitmap.h>
  33 #include <gdkmm/color.h>
  34 #include <pangomm/fontdescription.h>
  35 #include <pangomm/tabarray.h>
  36
  37
  38 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  39 typedef struct _GtkTextTag GtkTextTag;
  40 typedef struct _GtkTextTagClass GtkTextTagClass;
  41 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  42
  43
  44 namespace Gtk
  45 { class TextTag_Class; } // namespace Gtk
  46 namespace Gtk
  47 {
  48
  49 class TextIter;
  50
  51 /** Typedefed as Gtk::TextBuffer::Tag.
  52  *
  53  * Text in a buffer can be marked with tags. A tag is an attribute that can be applied to some range of text. For example, a tag
  54  * might be called "bold" and might make the text inside the tag bold. However, the tag concept is more general than that; tags don't
  55  * have to affect appearance. They can instead affect the behavior of mouse and key presses, "lock" a range of text so the user
  56  * can't edit it, or countless other things.
  57  * One tag can be applied to any number of text ranges in any number of @link Gtk::TextBuffer Gtk::TextBuffers@endlink.
  58  *
  59  * Each tag is stored in a @link Gtk::TextTagTable Gtk::TextBuffer::TagTable@endlink, and Tags should be in the
  60  * @link Gtk::TextTagTable Gtk::TextBuffer::TagTable@endlink for a given Gtk::TextBuffer before using
  61  * them with that buffer.
  62  *
  63  * Tags can have names, which is convenient sometimes (for example, you can name your tag that makes things bold "bold"), but
  64  * they can also be anonymous (which is convenient if you're creating tags on-the-fly).
  65  *
  66  * Gtk::TextBuffer::create_tag() is the best way to create tags. See the demo for numerous examples.
  67  *
  68  * @ingroup TextView
  69  */
  70
  71 class TextTag : public Glib::Object
  72 {
  73
  74 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  75
  76 public:
  77   typedef TextTag CppObjectType;
  78   typedef TextTag_Class CppClassType;
  79   typedef GtkTextTag BaseObjectType;
  80   typedef GtkTextTagClass BaseClassType;
  81
  82 private:  friend class TextTag_Class;
  83   static CppClassType texttag_class_;
  84
  85 private:
  86   // noncopyable
  87   TextTag(const TextTag&);
  88   TextTag& operator=(const TextTag&);
  89
  90 protected:
  91   explicit TextTag(const Glib::ConstructParams& construct_params);
  92   explicit TextTag(GtkTextTag* castitem);
  93
  94 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  95
  96 public:
  97   virtual ~TextTag();
  98
  99 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 100   static GType get_type()      G_GNUC_CONST;
 101   static GType get_base_type() G_GNUC_CONST;
 102 #endif
 103
 104   ///Provides access to the underlying C GObject.
 105   GtkTextTag*       gobj()       { return reinterpret_cast<GtkTextTag*>(gobject_); }
 106
 107   ///Provides access to the underlying C GObject.
 108   const GtkTextTag* gobj() const { return reinterpret_cast<GtkTextTag*>(gobject_); }
 109
 110   ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
 111   GtkTextTag* gobj_copy();
 112
 113 private:
 114
 115 protected:
 116   TextTag();
 117   explicit TextTag(const Glib::ustring& name);
 118
 119 public:
 120
 121   static Glib::RefPtr<TextTag> create();
 122
 123
 124   static Glib::RefPtr<TextTag> create(const Glib::ustring& name);
 125
 126
 127   /** Get the tag priority.
 128    * @return The tag's priority.
 129    */
 130   int get_priority() const;
 131
 132   /** Sets the priority of a Gtk::TextTag. Valid priorities are
 133    * start at 0 and go to one less than Gtk::TextTagTable::get_size().
 134    * Each tag in a table has a unique priority; setting the priority
 135    * of one tag shifts the priorities of all the other tags in the
 136    * table to maintain a unique priority for each tag. Higher priority
 137    * tags "win" if two tags both set the same text attribute. When adding
 138    * a tag to a tag table, it will be assigned the highest priority in
 139    * the table by default; so normally the precedence of a set of tags
 140    * is the order in which they were added to the table, or created with
 141    * Gtk::TextBuffer::create_tag(), which adds the tag to the buffer's table
 142    * automatically.
 143    * @param priority The new priority.
 144    */
 145   void set_priority(int priority);
 146
 147   /** Emits the "event" signal on the Gtk::TextTag.
 148    * @param event_object Object that received the event, such as a widget.
 149    * @param event The event.
 150    * @param iter Location where the event was received.
 151    * @return Result of signal emission (whether the event was handled).
 152    */
 153   bool event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter);
 154
 155
 156   Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > signal_event();
 157
 158
 159   /** Name used to refer to the text tag. NULL for anonymous tags.
 160    *
 161    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 162    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 163    * the value of the property changes.
 164    */
 165   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
 166
 167  //construct-only.
 168   /** Background color as a string.
 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_WriteOnly<Glib::ustring> property_background() ;
 175
 176 /** Background color as a string.
 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<Glib::ustring> property_background() const;
 183
 184   /** Foreground color as a string.
 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_WriteOnly<Glib::ustring> property_foreground() ;
 191
 192 /** Foreground color as a string.
 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<Glib::ustring> property_foreground() const;
 199
 200   /** Background color as a (possibly unallocated) GdkColor.
 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<Gdk::Color> property_background_gdk() ;
 207
 208 /** Background color as a (possibly unallocated) GdkColor.
 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<Gdk::Color> property_background_gdk() const;
 215
 216   /** Foreground color as a (possibly unallocated) GdkColor.
 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<Gdk::Color> property_foreground_gdk() ;
 223
 224 /** Foreground color as a (possibly unallocated) GdkColor.
 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<Gdk::Color> property_foreground_gdk() const;
 231
 232   /** Bitmap to use as a mask when drawing the text background.
 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< Glib::RefPtr<Gdk::Bitmap> > property_background_stipple() ;
 239
 240 /** Bitmap to use as a mask when drawing the text background.
 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< Glib::RefPtr<Gdk::Bitmap> > property_background_stipple() const;
 247
 248   /** Bitmap to use as a mask when drawing the text foreground.
 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< Glib::RefPtr<Gdk::Bitmap> > property_foreground_stipple() ;
 255
 256 /** Bitmap to use as a mask when drawing the text foreground.
 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< Glib::RefPtr<Gdk::Bitmap> > property_foreground_stipple() const;
 263
 264   /** Font description as a string
 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<Glib::ustring> property_font() ;
 271
 272 /** Font description as a string
 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<Glib::ustring> property_font() const;
 279
 280   /** Font description as a PangoFontDescription struct.
 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<Pango::FontDescription> property_font_desc() ;
 287
 288 /** Font description as a PangoFontDescription struct.
 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<Pango::FontDescription> property_font_desc() const;
 295
 296   /** Name of the font family
 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<Glib::ustring> property_family() ;
 303
 304 /** Name of the font family
 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<Glib::ustring> property_family() const;
 311
 312   /** Font style as a PangoStyle
 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<Pango::Style> property_style() ;
 319
 320 /** Font style as a PangoStyle
 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<Pango::Style> property_style() const;
 327
 328   /** Font variant as a PangoVariant
 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<Pango::Variant> property_variant() ;
 335
 336 /** Font variant as a PangoVariant
 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<Pango::Variant> property_variant() const;
 343
 344   /** Font weight as an integer
 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<int> property_weight() ;
 351
 352 /** Font weight as an integer
 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<int> property_weight() const;
 359
 360   /** Font stretch as a PangoStretch
 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<Pango::Stretch> property_stretch() ;
 367
 368 /** Font stretch as a PangoStretch
 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<Pango::Stretch> property_stretch() const;
 375
 376   /** Font size in Pango units.
 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_size() ;
 383
 384 /** Font size in Pango units.
 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_size() const;
 391
 392   /** Font size in points.
 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<double> property_size_points() ;
 399
 400 /** Font size in points.
 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<double> property_size_points() const;
 407
 408   /** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
 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<double> property_scale() ;
 415
 416 /** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
 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<double> property_scale() const;
 423
 424   /** Pixels of blank space above paragraphs.
 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_pixels_above_lines() ;
 431
 432 /** Pixels of blank space above paragraphs.
 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_pixels_above_lines() const;
 439
 440   /** Pixels of blank space below paragraphs.
 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_pixels_below_lines() ;
 447
 448 /** Pixels of blank space below paragraphs.
 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_pixels_below_lines() const;
 455
 456   /** Pixels of blank space between wrapped lines in a paragraph.
 457    *
 458    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 459    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 460    * the value of the property changes.
 461    */
 462   Glib::PropertyProxy<int> property_pixels_inside_wrap() ;
 463
 464 /** Pixels of blank space between wrapped lines in a paragraph.
 465    *
 466    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 467    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 468    * the value of the property changes.
 469    */
 470   Glib::PropertyProxy_ReadOnly<int> property_pixels_inside_wrap() const;
 471
 472   /** Whether the text can be modified by the user.
 473    *
 474    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 475    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 476    * the value of the property changes.
 477    */
 478   Glib::PropertyProxy<bool> property_editable() ;
 479
 480 /** Whether the text can be modified by the user.
 481    *
 482    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 483    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 484    * the value of the property changes.
 485    */
 486   Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
 487
 488   /** Whether to wrap lines never
 489    *
 490    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 491    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 492    * the value of the property changes.
 493    */
 494   Glib::PropertyProxy<WrapMode> property_wrap_mode() ;
 495
 496 /** Whether to wrap lines never
 497    *
 498    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 499    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 500    * the value of the property changes.
 501    */
 502   Glib::PropertyProxy_ReadOnly<WrapMode> property_wrap_mode() const;
 503
 504   /** Left
 505    *
 506    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 507    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 508    * the value of the property changes.
 509    */
 510   Glib::PropertyProxy<Justification> property_justification() ;
 511
 512 /** Left
 513    *
 514    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 515    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 516    * the value of the property changes.
 517    */
 518   Glib::PropertyProxy_ReadOnly<Justification> property_justification() const;
 519
 520   /** Text direction
 521    *
 522    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 523    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 524    * the value of the property changes.
 525    */
 526   Glib::PropertyProxy<TextDirection> property_direction() ;
 527
 528 /** Text direction
 529    *
 530    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 531    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 532    * the value of the property changes.
 533    */
 534   Glib::PropertyProxy_ReadOnly<TextDirection> property_direction() const;
 535
 536   /** Width of the left margin in pixels.
 537    *
 538    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 539    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 540    * the value of the property changes.
 541    */
 542   Glib::PropertyProxy<int> property_left_margin() ;
 543
 544 /** Width of the left margin in pixels.
 545    *
 546    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 547    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 548    * the value of the property changes.
 549    */
 550   Glib::PropertyProxy_ReadOnly<int> property_left_margin() const;
 551
 552   /** Amount to indent the paragraph
 553    *
 554    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 555    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 556    * the value of the property changes.
 557    */
 558   Glib::PropertyProxy<int> property_indent() ;
 559
 560 /** Amount to indent the paragraph
 561    *
 562    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 563    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 564    * the value of the property changes.
 565    */
 566   Glib::PropertyProxy_ReadOnly<int> property_indent() const;
 567
 568   /** Whether to strike through the text.
 569    *
 570    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 571    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 572    * the value of the property changes.
 573    */
 574   Glib::PropertyProxy<bool> property_strikethrough() ;
 575
 576 /** Whether to strike through the text.
 577    *
 578    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 579    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 580    * the value of the property changes.
 581    */
 582   Glib::PropertyProxy_ReadOnly<bool> property_strikethrough() const;
 583
 584   /** Width of the right margin in pixels.
 585    *
 586    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 587    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 588    * the value of the property changes.
 589    */
 590   Glib::PropertyProxy<int> property_right_margin() ;
 591
 592 /** Width of the right margin in pixels.
 593    *
 594    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 595    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 596    * the value of the property changes.
 597    */
 598   Glib::PropertyProxy_ReadOnly<int> property_right_margin() const;
 599
 600   /** Style of underline for this text.
 601    *
 602    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 603    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 604    * the value of the property changes.
 605    */
 606   Glib::PropertyProxy<Pango::Underline> property_underline() ;
 607
 608 /** Style of underline for this text.
 609    *
 610    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 611    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 612    * the value of the property changes.
 613    */
 614   Glib::PropertyProxy_ReadOnly<Pango::Underline> property_underline() const;
 615
 616   /** Offset of text above the baseline (below the baseline if rise is negative) in pixels.
 617    *
 618    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 619    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 620    * the value of the property changes.
 621    */
 622   Glib::PropertyProxy<int> property_rise() ;
 623
 624 /** Offset of text above the baseline (below the baseline if rise is negative) in pixels.
 625    *
 626    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 627    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 628    * the value of the property changes.
 629    */
 630   Glib::PropertyProxy_ReadOnly<int> property_rise() const;
 631
 632   /** Whether the background color fills the entire line height or only the height of the tagged characters.
 633    *
 634    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 635    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 636    * the value of the property changes.
 637    */
 638   Glib::PropertyProxy<bool> property_background_full_height() ;
 639
 640 /** Whether the background color fills the entire line height or only the height of the tagged characters.
 641    *
 642    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 643    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 644    * the value of the property changes.
 645    */
 646   Glib::PropertyProxy_ReadOnly<bool> property_background_full_height() const;
 647
 648   /** The language this text is in
 649    *
 650    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 651    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 652    * the value of the property changes.
 653    */
 654   Glib::PropertyProxy<Glib::ustring> property_language() ;
 655
 656 /** The language this text is in
 657    *
 658    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 659    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 660    * the value of the property changes.
 661    */
 662   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_language() const;
 663
 664   /** Custom tabs for this text.
 665    *
 666    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 667    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 668    * the value of the property changes.
 669    */
 670   Glib::PropertyProxy<Pango::TabArray> property_tabs() ;
 671
 672 /** Custom tabs for this text.
 673    *
 674    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 675    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 676    * the value of the property changes.
 677    */
 678   Glib::PropertyProxy_ReadOnly<Pango::TabArray> property_tabs() const;
 679
 680   /** Whether this text is hidden. Not implemented in GTK 2.0.
 681    *
 682    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 683    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 684    * the value of the property changes.
 685    */
 686   Glib::PropertyProxy<bool> property_invisible() ;
 687
 688 /** Whether this text is hidden. Not implemented in GTK 2.0.
 689    *
 690    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 691    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 692    * the value of the property changes.
 693    */
 694   Glib::PropertyProxy_ReadOnly<bool> property_invisible() const;
 695
 696   /** Whether this tag affects the background color.
 697    *
 698    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 699    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 700    * the value of the property changes.
 701    */
 702   Glib::PropertyProxy<bool> property_background_set() ;
 703
 704 /** Whether this tag affects the background color.
 705    *
 706    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 707    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 708    * the value of the property changes.
 709    */
 710   Glib::PropertyProxy_ReadOnly<bool> property_background_set() const;
 711
 712   /** Whether this tag affects the foreground color.
 713    *
 714    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 715    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 716    * the value of the property changes.
 717    */
 718   Glib::PropertyProxy<bool> property_foreground_set() ;
 719
 720 /** Whether this tag affects the foreground color.
 721    *
 722    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 723    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 724    * the value of the property changes.
 725    */
 726   Glib::PropertyProxy_ReadOnly<bool> property_foreground_set() const;
 727
 728   /** Whether this tag affects the background stipple.
 729    *
 730    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 731    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 732    * the value of the property changes.
 733    */
 734   Glib::PropertyProxy<bool> property_background_stipple_set() ;
 735
 736 /** Whether this tag affects the background stipple.
 737    *
 738    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 739    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 740    * the value of the property changes.
 741    */
 742   Glib::PropertyProxy_ReadOnly<bool> property_background_stipple_set() const;
 743
 744   /** Whether this tag affects the foreground stipple.
 745    *
 746    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 747    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 748    * the value of the property changes.
 749    */
 750   Glib::PropertyProxy<bool> property_foreground_stipple_set() ;
 751
 752 /** Whether this tag affects the foreground stipple.
 753    *
 754    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 755    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 756    * the value of the property changes.
 757    */
 758   Glib::PropertyProxy_ReadOnly<bool> property_foreground_stipple_set() const;
 759
 760   /** Whether this tag affects the font family.
 761    *
 762    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 763    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 764    * the value of the property changes.
 765    */
 766   Glib::PropertyProxy<bool> property_family_set() ;
 767
 768 /** Whether this tag affects the font family.
 769    *
 770    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 771    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 772    * the value of the property changes.
 773    */
 774   Glib::PropertyProxy_ReadOnly<bool> property_family_set() const;
 775
 776   /** Whether this tag affects the font style.
 777    *
 778    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 779    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 780    * the value of the property changes.
 781    */
 782   Glib::PropertyProxy<bool> property_style_set() ;
 783
 784 /** Whether this tag affects the font style.
 785    *
 786    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 787    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 788    * the value of the property changes.
 789    */
 790   Glib::PropertyProxy_ReadOnly<bool> property_style_set() const;
 791
 792   /** Whether this tag affects the font variant.
 793    *
 794    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 795    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 796    * the value of the property changes.
 797    */
 798   Glib::PropertyProxy<bool> property_variant_set() ;
 799
 800 /** Whether this tag affects the font variant.
 801    *
 802    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 803    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 804    * the value of the property changes.
 805    */
 806   Glib::PropertyProxy_ReadOnly<bool> property_variant_set() const;
 807
 808   /** Whether this tag affects the font weight.
 809    *
 810    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 811    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 812    * the value of the property changes.
 813    */
 814   Glib::PropertyProxy<bool> property_weight_set() ;
 815
 816 /** Whether this tag affects the font weight.
 817    *
 818    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 819    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 820    * the value of the property changes.
 821    */
 822   Glib::PropertyProxy_ReadOnly<bool> property_weight_set() const;
 823
 824   /** Whether this tag affects the font stretch.
 825    *
 826    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 827    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 828    * the value of the property changes.
 829    */
 830   Glib::PropertyProxy<bool> property_stretch_set() ;
 831
 832 /** Whether this tag affects the font stretch.
 833    *
 834    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 835    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 836    * the value of the property changes.
 837    */
 838   Glib::PropertyProxy_ReadOnly<bool> property_stretch_set() const;
 839
 840   /** Whether this tag affects the font size.
 841    *
 842    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 843    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 844    * the value of the property changes.
 845    */
 846   Glib::PropertyProxy<bool> property_size_set() ;
 847
 848 /** Whether this tag affects the font size.
 849    *
 850    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 851    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 852    * the value of the property changes.
 853    */
 854   Glib::PropertyProxy_ReadOnly<bool> property_size_set() const;
 855
 856   /** Whether this tag scales the font size by a factor.
 857    *
 858    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 859    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 860    * the value of the property changes.
 861    */
 862   Glib::PropertyProxy<bool> property_scale_set() ;
 863
 864 /** Whether this tag scales the font size by a factor.
 865    *
 866    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 867    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 868    * the value of the property changes.
 869    */
 870   Glib::PropertyProxy_ReadOnly<bool> property_scale_set() const;
 871
 872   /** Whether this tag affects the number of pixels above lines.
 873    *
 874    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 875    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 876    * the value of the property changes.
 877    */
 878   Glib::PropertyProxy<bool> property_pixels_above_lines_set() ;
 879
 880 /** Whether this tag affects the number of pixels above lines.
 881    *
 882    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 883    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 884    * the value of the property changes.
 885    */
 886   Glib::PropertyProxy_ReadOnly<bool> property_pixels_above_lines_set() const;
 887
 888   /** Whether this tag affects the number of pixels above lines.
 889    *
 890    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 891    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 892    * the value of the property changes.
 893    */
 894   Glib::PropertyProxy<bool> property_pixels_below_lines_set() ;
 895
 896 /** Whether this tag affects the number of pixels above lines.
 897    *
 898    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 899    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 900    * the value of the property changes.
 901    */
 902   Glib::PropertyProxy_ReadOnly<bool> property_pixels_below_lines_set() const;
 903
 904   /** Whether this tag affects the number of pixels between wrapped lines.
 905    *
 906    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 907    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 908    * the value of the property changes.
 909    */
 910   Glib::PropertyProxy<bool> property_pixels_inside_wrap_set() ;
 911
 912 /** Whether this tag affects the number of pixels between wrapped lines.
 913    *
 914    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 915    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 916    * the value of the property changes.
 917    */
 918   Glib::PropertyProxy_ReadOnly<bool> property_pixels_inside_wrap_set() const;
 919
 920   /** Whether this tag affects text editability.
 921    *
 922    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 923    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 924    * the value of the property changes.
 925    */
 926   Glib::PropertyProxy<bool> property_editable_set() ;
 927
 928 /** Whether this tag affects text editability.
 929    *
 930    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 931    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 932    * the value of the property changes.
 933    */
 934   Glib::PropertyProxy_ReadOnly<bool> property_editable_set() const;
 935
 936   /** Whether this tag affects line wrap mode.
 937    *
 938    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 939    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 940    * the value of the property changes.
 941    */
 942   Glib::PropertyProxy<bool> property_wrap_mode_set() ;
 943
 944 /** Whether this tag affects line wrap mode.
 945    *
 946    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 947    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 948    * the value of the property changes.
 949    */
 950   Glib::PropertyProxy_ReadOnly<bool> property_wrap_mode_set() const;
 951
 952   /** Whether this tag affects paragraph justification.
 953    *
 954    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 955    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 956    * the value of the property changes.
 957    */
 958   Glib::PropertyProxy<bool> property_justification_set() ;
 959
 960 /** Whether this tag affects paragraph justification.
 961    *
 962    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 963    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 964    * the value of the property changes.
 965    */
 966   Glib::PropertyProxy_ReadOnly<bool> property_justification_set() const;
 967
 968   /** Whether this tag affects the left margin.
 969    *
 970    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 971    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 972    * the value of the property changes.
 973    */
 974   Glib::PropertyProxy<bool> property_left_margin_set() ;
 975
 976 /** Whether this tag affects the left margin.
 977    *
 978    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 979    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 980    * the value of the property changes.
 981    */
 982   Glib::PropertyProxy_ReadOnly<bool> property_left_margin_set() const;
 983
 984   /** Whether this tag affects indentation.
 985    *
 986    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 987    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 988    * the value of the property changes.
 989    */
 990   Glib::PropertyProxy<bool> property_indent_set() ;
 991
 992 /** Whether this tag affects indentation.
 993    *
 994    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 995    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 996    * the value of the property changes.
 997    */
 998   Glib::PropertyProxy_ReadOnly<bool> property_indent_set() const;
 999
1000   /** Whether this tag affects strikethrough.
1001    *
1002    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1003    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1004    * the value of the property changes.
1005    */
1006   Glib::PropertyProxy<bool> property_strikethrough_set() ;
1007
1008 /** Whether this tag affects strikethrough.
1009    *
1010    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1011    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1012    * the value of the property changes.
1013    */
1014   Glib::PropertyProxy_ReadOnly<bool> property_strikethrough_set() const;
1015
1016   /** Whether this tag affects the right margin.
1017    *
1018    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1019    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1020    * the value of the property changes.
1021    */
1022   Glib::PropertyProxy<bool> property_right_margin_set() ;
1023
1024 /** Whether this tag affects the right margin.
1025    *
1026    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1027    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1028    * the value of the property changes.
1029    */
1030   Glib::PropertyProxy_ReadOnly<bool> property_right_margin_set() const;
1031
1032   /** Whether this tag affects underlining.
1033    *
1034    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1035    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1036    * the value of the property changes.
1037    */
1038   Glib::PropertyProxy<bool> property_underline_set() ;
1039
1040 /** Whether this tag affects underlining.
1041    *
1042    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1043    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1044    * the value of the property changes.
1045    */
1046   Glib::PropertyProxy_ReadOnly<bool> property_underline_set() const;
1047
1048   /** Whether this tag affects the rise.
1049    *
1050    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1051    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1052    * the value of the property changes.
1053    */
1054   Glib::PropertyProxy<bool> property_rise_set() ;
1055
1056 /** Whether this tag affects the rise.
1057    *
1058    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1059    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1060    * the value of the property changes.
1061    */
1062   Glib::PropertyProxy_ReadOnly<bool> property_rise_set() const;
1063
1064   /** Whether this tag affects background height.
1065    *
1066    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1067    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1068    * the value of the property changes.
1069    */
1070   Glib::PropertyProxy<bool> property_background_full_height_set() ;
1071
1072 /** Whether this tag affects background height.
1073    *
1074    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1075    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1076    * the value of the property changes.
1077    */
1078   Glib::PropertyProxy_ReadOnly<bool> property_background_full_height_set() const;
1079
1080   /** Whether this tag affects the language the text is rendered as.
1081    *
1082    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1083    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1084    * the value of the property changes.
1085    */
1086   Glib::PropertyProxy<bool> property_language_set() ;
1087
1088 /** Whether this tag affects the language the text is rendered as.
1089    *
1090    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1091    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1092    * the value of the property changes.
1093    */
1094   Glib::PropertyProxy_ReadOnly<bool> property_language_set() const;
1095
1096   /** Whether this tag affects tabs.
1097    *
1098    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1099    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1100    * the value of the property changes.
1101    */
1102   Glib::PropertyProxy<bool> property_tabs_set() ;
1103
1104 /** Whether this tag affects tabs.
1105    *
1106    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1107    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1108    * the value of the property changes.
1109    */
1110   Glib::PropertyProxy_ReadOnly<bool> property_tabs_set() const;
1111
1112   /** Whether this tag affects text visibility.
1113    *
1114    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1115    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1116    * the value of the property changes.
1117    */
1118   Glib::PropertyProxy<bool> property_invisible_set() ;
1119
1120 /** Whether this tag affects text visibility.
1121    *
1122    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
1123    * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
1124    * the value of the property changes.
1125    */
1126   Glib::PropertyProxy_ReadOnly<bool> property_invisible_set() const;
1127
1128
1129 public:
1130
1131 public:
1132   //C++ methods used to invoke GTK+ virtual functions:
1133
1134 protected:
1135   //GTK+ Virtual Functions (override these to change behaviour):
1136
1137   //Default Signal Handlers::
1138   virtual bool on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter);
1139
1140
1141 };
1142
1143 } /* namespace Gtk */
1144
1145
1146 namespace Glib
1147 {
1148   /** @relates Gtk::TextTag
1149    * @param object The C instance
1150    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
1151    * @result A C++ instance that wraps this C instance.
1152    */
1153   Glib::RefPtr<Gtk::TextTag> wrap(GtkTextTag* object, bool take_copy = false);
1154 }
1155
1156
1157 #endif /* _GTKMM_TEXTTAG_H */
1158