libs/gtkmm2/gtk/gtkmm/texttag.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/texttag.h>
   5 #include <gtkmm/private/texttag_p.h>
   6
   7 // -*- c++ -*-
   8 /* $Id$ */
   9
  10 /*
  11  *
  12  * Copyright 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 #include <gtkmm/textbuffer.h>
  30 #include <gtkmm/textiter.h>
  31 #include <gtk/gtktexttag.h>
  32 namespace
  33 {
  34
  35
  36 static gboolean TextTag_signal_event_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2,void* data)
  37 {
  38   using namespace Gtk;
  39   typedef sigc::slot< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > SlotType;
  40
  41   // Do not try to call a signal on a disassociated wrapper.
  42   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  43   {
  44     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  45     try
  46     {
  47     #endif //GLIBMM_EXCEPTIONS_ENABLED
  48       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  49         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
  50 , p1, Glib::wrap(p2)
  51 ));
  52     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  53     }
  54     catch(...)
  55     {
  56       Glib::exception_handlers_invoke();
  57     }
  58     #endif //GLIBMM_EXCEPTIONS_ENABLED
  59   }
  60
  61   typedef gboolean RType;
  62   return RType();
  63 }
  64
  65 static gboolean TextTag_signal_event_notify_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2, void* data)
  66 {
  67   using namespace Gtk;
  68   typedef sigc::slot< void,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > SlotType;
  69
  70   // Do not try to call a signal on a disassociated wrapper.
  71   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  72   {
  73     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  74     try
  75     {
  76     #endif //GLIBMM_EXCEPTIONS_ENABLED
  77       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  78         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
  79 , p1, Glib::wrap(p2)
  80 );
  81     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  82     }
  83     catch(...)
  84     {
  85       Glib::exception_handlers_invoke();
  86     }
  87     #endif //GLIBMM_EXCEPTIONS_ENABLED
  88   }
  89
  90   typedef gboolean RType;
  91   return RType();
  92 }
  93
  94 static const Glib::SignalProxyInfo TextTag_signal_event_info =
  95 {
  96   "event",
  97   (GCallback) &TextTag_signal_event_callback,
  98   (GCallback) &TextTag_signal_event_notify_callback
  99 };
 100
 101
 102 } // anonymous namespace
 103
 104
 105 namespace Glib
 106 {
 107
 108 Glib::RefPtr<Gtk::TextTag> wrap(GtkTextTag* object, bool take_copy)
 109 {
 110   return Glib::RefPtr<Gtk::TextTag>( dynamic_cast<Gtk::TextTag*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
 111   //We use dynamic_cast<> in case of multiple inheritance.
 112 }
 113
 114 } /* namespace Glib */
 115
 116
 117 namespace Gtk
 118 {
 119
 120
 121 /* The *_Class implementation: */
 122
 123 const Glib::Class& TextTag_Class::init()
 124 {
 125   if(!gtype_) // create the GType if necessary
 126   {
 127     // Glib::Class has to know the class init function to clone custom types.
 128     class_init_func_ = &TextTag_Class::class_init_function;
 129
 130     // This is actually just optimized away, apparently with no harm.
 131     // Make sure that the parent type has been created.
 132     //CppClassParent::CppObjectType::get_type();
 133
 134     // Create the wrapper type, with the same class/instance size as the base type.
 135     register_derived_type(gtk_text_tag_get_type());
 136
 137     // Add derived versions of interfaces, if the C type implements any interfaces:
 138   }
 139
 140   return *this;
 141 }
 142
 143 void TextTag_Class::class_init_function(void* g_class, void* class_data)
 144 {
 145   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 146   CppClassParent::class_init_function(klass, class_data);
 147
 148 #ifdef GLIBMM_VFUNCS_ENABLED
 149 #endif //GLIBMM_VFUNCS_ENABLED
 150
 151 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 152   klass->event = &event_callback;
 153 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 154 }
 155
 156 #ifdef GLIBMM_VFUNCS_ENABLED
 157 #endif //GLIBMM_VFUNCS_ENABLED
 158
 159 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 160 gboolean TextTag_Class::event_callback(GtkTextTag* self, GObject* p0, GdkEvent* p1, const GtkTextIter* p2)
 161 {
 162   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 163       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 164
 165   // Non-gtkmmproc-generated custom classes implicitly call the default
 166   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 167   // generated classes can use this optimisation, which avoids the unnecessary
 168   // parameter conversions if there is no possibility of the virtual function
 169   // being overridden:
 170   if(obj_base && obj_base->is_derived_())
 171   {
 172     CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 173     if(obj) // This can be NULL during destruction.
 174     {
 175       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 176       try // Trap C++ exceptions which would normally be lost because this is a C callback.
 177       {
 178       #endif //GLIBMM_EXCEPTIONS_ENABLED
 179         // Call the virtual member method, which derived classes might override.
 180         return static_cast<int>(obj->on_event(Glib::wrap(p0, true)
 181 , p1, Glib::wrap(p2)
 182 ));
 183       #ifdef GLIBMM_EXCEPTIONS_ENABLED
 184       }
 185       catch(...)
 186       {
 187         Glib::exception_handlers_invoke();
 188       }
 189       #endif //GLIBMM_EXCEPTIONS_ENABLED
 190     }
 191   }
 192
 193   BaseClassType *const base = static_cast<BaseClassType*>(
 194         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 195     );
 196
 197   // Call the original underlying C function:
 198   if(base && base->event)
 199     return (*base->event)(self, p0, p1, p2);
 200
 201   typedef gboolean RType;
 202   return RType();
 203 }
 204 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 205
 206
 207 Glib::ObjectBase* TextTag_Class::wrap_new(GObject* object)
 208 {
 209   return new TextTag((GtkTextTag*)object);
 210 }
 211
 212
 213 /* The implementation: */
 214
 215 GtkTextTag* TextTag::gobj_copy()
 216 {
 217   reference();
 218   return gobj();
 219 }
 220
 221 TextTag::TextTag(const Glib::ConstructParams& construct_params)
 222 :
 223   Glib::Object(construct_params)
 224 {}
 225
 226 TextTag::TextTag(GtkTextTag* castitem)
 227 :
 228   Glib::Object((GObject*)(castitem))
 229 {}
 230
 231 TextTag::~TextTag()
 232 {}
 233
 234
 235 TextTag::CppClassType TextTag::texttag_class_; // initialize static member
 236
 237 GType TextTag::get_type()
 238 {
 239   return texttag_class_.init().get_type();
 240 }
 241
 242 GType TextTag::get_base_type()
 243 {
 244   return gtk_text_tag_get_type();
 245 }
 246
 247
 248 TextTag::TextTag()
 249 :
 250   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 251   Glib::ObjectBase(0),
 252   Glib::Object(Glib::ConstructParams(texttag_class_.init()))
 253 {
 254   }
 255
 256 TextTag::TextTag(const Glib::ustring& name)
 257 :
 258   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 259   Glib::ObjectBase(0),
 260   Glib::Object(Glib::ConstructParams(texttag_class_.init(), "name", name.c_str(), static_cast<char*>(0)))
 261 {
 262   }
 263
 264 Glib::RefPtr<TextTag> TextTag::create()
 265 {
 266   return Glib::RefPtr<TextTag>( new TextTag() );
 267 }
 268 Glib::RefPtr<TextTag> TextTag::create(const Glib::ustring& name)
 269 {
 270   return Glib::RefPtr<TextTag>( new TextTag(name) );
 271 }
 272 int TextTag::get_priority() const
 273 {
 274   return gtk_text_tag_get_priority(const_cast<GtkTextTag*>(gobj()));
 275 }
 276
 277 void TextTag::set_priority(int priority)
 278 {
 279 gtk_text_tag_set_priority(gobj(), priority);
 280 }
 281
 282 bool TextTag::event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)
 283 {
 284   return gtk_text_tag_event(gobj(), Glib::unwrap(event_object), event, (iter).gobj());
 285 }
 286
 287
 288 Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > TextTag::signal_event()
 289 {
 290   return Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& >(this, &TextTag_signal_event_info);
 291 }
 292
 293
 294 #ifdef GLIBMM_PROPERTIES_ENABLED
 295 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_name() const
 296 {
 297   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
 298 }
 299 #endif //GLIBMM_PROPERTIES_ENABLED
 300
 301 #ifdef GLIBMM_PROPERTIES_ENABLED
 302 Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_background()
 303 {
 304   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "background");
 305 }
 306 #endif //GLIBMM_PROPERTIES_ENABLED
 307
 308 #ifdef GLIBMM_PROPERTIES_ENABLED
 309 Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_foreground()
 310 {
 311   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "foreground");
 312 }
 313 #endif //GLIBMM_PROPERTIES_ENABLED
 314
 315 #ifdef GLIBMM_PROPERTIES_ENABLED
 316 Glib::PropertyProxy<Gdk::Color> TextTag::property_background_gdk()
 317 {
 318   return Glib::PropertyProxy<Gdk::Color>(this, "background-gdk");
 319 }
 320 #endif //GLIBMM_PROPERTIES_ENABLED
 321
 322 #ifdef GLIBMM_PROPERTIES_ENABLED
 323 Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_background_gdk() const
 324 {
 325   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "background-gdk");
 326 }
 327 #endif //GLIBMM_PROPERTIES_ENABLED
 328
 329 #ifdef GLIBMM_PROPERTIES_ENABLED
 330 Glib::PropertyProxy<Gdk::Color> TextTag::property_foreground_gdk()
 331 {
 332   return Glib::PropertyProxy<Gdk::Color>(this, "foreground-gdk");
 333 }
 334 #endif //GLIBMM_PROPERTIES_ENABLED
 335
 336 #ifdef GLIBMM_PROPERTIES_ENABLED
 337 Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_foreground_gdk() const
 338 {
 339   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "foreground-gdk");
 340 }
 341 #endif //GLIBMM_PROPERTIES_ENABLED
 342
 343 #ifdef GLIBMM_PROPERTIES_ENABLED
 344 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_background_stipple()
 345 {
 346   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "background-stipple");
 347 }
 348 #endif //GLIBMM_PROPERTIES_ENABLED
 349
 350 #ifdef GLIBMM_PROPERTIES_ENABLED
 351 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_background_stipple() const
 352 {
 353   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "background-stipple");
 354 }
 355 #endif //GLIBMM_PROPERTIES_ENABLED
 356
 357 #ifdef GLIBMM_PROPERTIES_ENABLED
 358 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_foreground_stipple()
 359 {
 360   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "foreground-stipple");
 361 }
 362 #endif //GLIBMM_PROPERTIES_ENABLED
 363
 364 #ifdef GLIBMM_PROPERTIES_ENABLED
 365 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_foreground_stipple() const
 366 {
 367   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "foreground-stipple");
 368 }
 369 #endif //GLIBMM_PROPERTIES_ENABLED
 370
 371 #ifdef GLIBMM_PROPERTIES_ENABLED
 372 Glib::PropertyProxy<Glib::ustring> TextTag::property_font()
 373 {
 374   return Glib::PropertyProxy<Glib::ustring>(this, "font");
 375 }
 376 #endif //GLIBMM_PROPERTIES_ENABLED
 377
 378 #ifdef GLIBMM_PROPERTIES_ENABLED
 379 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_font() const
 380 {
 381   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
 382 }
 383 #endif //GLIBMM_PROPERTIES_ENABLED
 384
 385 #ifdef GLIBMM_PROPERTIES_ENABLED
 386 Glib::PropertyProxy<Pango::FontDescription> TextTag::property_font_desc()
 387 {
 388   return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
 389 }
 390 #endif //GLIBMM_PROPERTIES_ENABLED
 391
 392 #ifdef GLIBMM_PROPERTIES_ENABLED
 393 Glib::PropertyProxy_ReadOnly<Pango::FontDescription> TextTag::property_font_desc() const
 394 {
 395   return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
 396 }
 397 #endif //GLIBMM_PROPERTIES_ENABLED
 398
 399 #ifdef GLIBMM_PROPERTIES_ENABLED
 400 Glib::PropertyProxy<Glib::ustring> TextTag::property_family()
 401 {
 402   return Glib::PropertyProxy<Glib::ustring>(this, "family");
 403 }
 404 #endif //GLIBMM_PROPERTIES_ENABLED
 405
 406 #ifdef GLIBMM_PROPERTIES_ENABLED
 407 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_family() const
 408 {
 409   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
 410 }
 411 #endif //GLIBMM_PROPERTIES_ENABLED
 412
 413 #ifdef GLIBMM_PROPERTIES_ENABLED
 414 Glib::PropertyProxy<Pango::Style> TextTag::property_style()
 415 {
 416   return Glib::PropertyProxy<Pango::Style>(this, "style");
 417 }
 418 #endif //GLIBMM_PROPERTIES_ENABLED
 419
 420 #ifdef GLIBMM_PROPERTIES_ENABLED
 421 Glib::PropertyProxy_ReadOnly<Pango::Style> TextTag::property_style() const
 422 {
 423   return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
 424 }
 425 #endif //GLIBMM_PROPERTIES_ENABLED
 426
 427 #ifdef GLIBMM_PROPERTIES_ENABLED
 428 Glib::PropertyProxy<Pango::Variant> TextTag::property_variant()
 429 {
 430   return Glib::PropertyProxy<Pango::Variant>(this, "variant");
 431 }
 432 #endif //GLIBMM_PROPERTIES_ENABLED
 433
 434 #ifdef GLIBMM_PROPERTIES_ENABLED
 435 Glib::PropertyProxy_ReadOnly<Pango::Variant> TextTag::property_variant() const
 436 {
 437   return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
 438 }
 439 #endif //GLIBMM_PROPERTIES_ENABLED
 440
 441 #ifdef GLIBMM_PROPERTIES_ENABLED
 442 Glib::PropertyProxy<int> TextTag::property_weight()
 443 {
 444   return Glib::PropertyProxy<int>(this, "weight");
 445 }
 446 #endif //GLIBMM_PROPERTIES_ENABLED
 447
 448 #ifdef GLIBMM_PROPERTIES_ENABLED
 449 Glib::PropertyProxy_ReadOnly<int> TextTag::property_weight() const
 450 {
 451   return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
 452 }
 453 #endif //GLIBMM_PROPERTIES_ENABLED
 454
 455 #ifdef GLIBMM_PROPERTIES_ENABLED
 456 Glib::PropertyProxy<Pango::Stretch> TextTag::property_stretch()
 457 {
 458   return Glib::PropertyProxy<Pango::Stretch>(this, "stretch");
 459 }
 460 #endif //GLIBMM_PROPERTIES_ENABLED
 461
 462 #ifdef GLIBMM_PROPERTIES_ENABLED
 463 Glib::PropertyProxy_ReadOnly<Pango::Stretch> TextTag::property_stretch() const
 464 {
 465   return Glib::PropertyProxy_ReadOnly<Pango::Stretch>(this, "stretch");
 466 }
 467 #endif //GLIBMM_PROPERTIES_ENABLED
 468
 469 #ifdef GLIBMM_PROPERTIES_ENABLED
 470 Glib::PropertyProxy<int> TextTag::property_size()
 471 {
 472   return Glib::PropertyProxy<int>(this, "size");
 473 }
 474 #endif //GLIBMM_PROPERTIES_ENABLED
 475
 476 #ifdef GLIBMM_PROPERTIES_ENABLED
 477 Glib::PropertyProxy_ReadOnly<int> TextTag::property_size() const
 478 {
 479   return Glib::PropertyProxy_ReadOnly<int>(this, "size");
 480 }
 481 #endif //GLIBMM_PROPERTIES_ENABLED
 482
 483 #ifdef GLIBMM_PROPERTIES_ENABLED
 484 Glib::PropertyProxy<double> TextTag::property_size_points()
 485 {
 486   return Glib::PropertyProxy<double>(this, "size-points");
 487 }
 488 #endif //GLIBMM_PROPERTIES_ENABLED
 489
 490 #ifdef GLIBMM_PROPERTIES_ENABLED
 491 Glib::PropertyProxy_ReadOnly<double> TextTag::property_size_points() const
 492 {
 493   return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
 494 }
 495 #endif //GLIBMM_PROPERTIES_ENABLED
 496
 497 #ifdef GLIBMM_PROPERTIES_ENABLED
 498 Glib::PropertyProxy<double> TextTag::property_scale()
 499 {
 500   return Glib::PropertyProxy<double>(this, "scale");
 501 }
 502 #endif //GLIBMM_PROPERTIES_ENABLED
 503
 504 #ifdef GLIBMM_PROPERTIES_ENABLED
 505 Glib::PropertyProxy_ReadOnly<double> TextTag::property_scale() const
 506 {
 507   return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
 508 }
 509 #endif //GLIBMM_PROPERTIES_ENABLED
 510
 511 #ifdef GLIBMM_PROPERTIES_ENABLED
 512 Glib::PropertyProxy<int> TextTag::property_pixels_above_lines()
 513 {
 514   return Glib::PropertyProxy<int>(this, "pixels-above-lines");
 515 }
 516 #endif //GLIBMM_PROPERTIES_ENABLED
 517
 518 #ifdef GLIBMM_PROPERTIES_ENABLED
 519 Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_above_lines() const
 520 {
 521   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
 522 }
 523 #endif //GLIBMM_PROPERTIES_ENABLED
 524
 525 #ifdef GLIBMM_PROPERTIES_ENABLED
 526 Glib::PropertyProxy<int> TextTag::property_pixels_below_lines()
 527 {
 528   return Glib::PropertyProxy<int>(this, "pixels-below-lines");
 529 }
 530 #endif //GLIBMM_PROPERTIES_ENABLED
 531
 532 #ifdef GLIBMM_PROPERTIES_ENABLED
 533 Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_below_lines() const
 534 {
 535   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
 536 }
 537 #endif //GLIBMM_PROPERTIES_ENABLED
 538
 539 #ifdef GLIBMM_PROPERTIES_ENABLED
 540 Glib::PropertyProxy<int> TextTag::property_pixels_inside_wrap()
 541 {
 542   return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
 543 }
 544 #endif //GLIBMM_PROPERTIES_ENABLED
 545
 546 #ifdef GLIBMM_PROPERTIES_ENABLED
 547 Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_inside_wrap() const
 548 {
 549   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
 550 }
 551 #endif //GLIBMM_PROPERTIES_ENABLED
 552
 553 #ifdef GLIBMM_PROPERTIES_ENABLED
 554 Glib::PropertyProxy<bool> TextTag::property_editable()
 555 {
 556   return Glib::PropertyProxy<bool>(this, "editable");
 557 }
 558 #endif //GLIBMM_PROPERTIES_ENABLED
 559
 560 #ifdef GLIBMM_PROPERTIES_ENABLED
 561 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_editable() const
 562 {
 563   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 564 }
 565 #endif //GLIBMM_PROPERTIES_ENABLED
 566
 567 #ifdef GLIBMM_PROPERTIES_ENABLED
 568 Glib::PropertyProxy<WrapMode> TextTag::property_wrap_mode()
 569 {
 570   return Glib::PropertyProxy<WrapMode>(this, "wrap-mode");
 571 }
 572 #endif //GLIBMM_PROPERTIES_ENABLED
 573
 574 #ifdef GLIBMM_PROPERTIES_ENABLED
 575 Glib::PropertyProxy_ReadOnly<WrapMode> TextTag::property_wrap_mode() const
 576 {
 577   return Glib::PropertyProxy_ReadOnly<WrapMode>(this, "wrap-mode");
 578 }
 579 #endif //GLIBMM_PROPERTIES_ENABLED
 580
 581 #ifdef GLIBMM_PROPERTIES_ENABLED
 582 Glib::PropertyProxy<Justification> TextTag::property_justification()
 583 {
 584   return Glib::PropertyProxy<Justification>(this, "justification");
 585 }
 586 #endif //GLIBMM_PROPERTIES_ENABLED
 587
 588 #ifdef GLIBMM_PROPERTIES_ENABLED
 589 Glib::PropertyProxy_ReadOnly<Justification> TextTag::property_justification() const
 590 {
 591   return Glib::PropertyProxy_ReadOnly<Justification>(this, "justification");
 592 }
 593 #endif //GLIBMM_PROPERTIES_ENABLED
 594
 595 #ifdef GLIBMM_PROPERTIES_ENABLED
 596 Glib::PropertyProxy<TextDirection> TextTag::property_direction()
 597 {
 598   return Glib::PropertyProxy<TextDirection>(this, "direction");
 599 }
 600 #endif //GLIBMM_PROPERTIES_ENABLED
 601
 602 #ifdef GLIBMM_PROPERTIES_ENABLED
 603 Glib::PropertyProxy_ReadOnly<TextDirection> TextTag::property_direction() const
 604 {
 605   return Glib::PropertyProxy_ReadOnly<TextDirection>(this, "direction");
 606 }
 607 #endif //GLIBMM_PROPERTIES_ENABLED
 608
 609 #ifdef GLIBMM_PROPERTIES_ENABLED
 610 Glib::PropertyProxy<int> TextTag::property_left_margin()
 611 {
 612   return Glib::PropertyProxy<int>(this, "left-margin");
 613 }
 614 #endif //GLIBMM_PROPERTIES_ENABLED
 615
 616 #ifdef GLIBMM_PROPERTIES_ENABLED
 617 Glib::PropertyProxy_ReadOnly<int> TextTag::property_left_margin() const
 618 {
 619   return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
 620 }
 621 #endif //GLIBMM_PROPERTIES_ENABLED
 622
 623 #ifdef GLIBMM_PROPERTIES_ENABLED
 624 Glib::PropertyProxy<int> TextTag::property_indent()
 625 {
 626   return Glib::PropertyProxy<int>(this, "indent");
 627 }
 628 #endif //GLIBMM_PROPERTIES_ENABLED
 629
 630 #ifdef GLIBMM_PROPERTIES_ENABLED
 631 Glib::PropertyProxy_ReadOnly<int> TextTag::property_indent() const
 632 {
 633   return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
 634 }
 635 #endif //GLIBMM_PROPERTIES_ENABLED
 636
 637 #ifdef GLIBMM_PROPERTIES_ENABLED
 638 Glib::PropertyProxy<bool> TextTag::property_strikethrough()
 639 {
 640   return Glib::PropertyProxy<bool>(this, "strikethrough");
 641 }
 642 #endif //GLIBMM_PROPERTIES_ENABLED
 643
 644 #ifdef GLIBMM_PROPERTIES_ENABLED
 645 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_strikethrough() const
 646 {
 647   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
 648 }
 649 #endif //GLIBMM_PROPERTIES_ENABLED
 650
 651 #ifdef GLIBMM_PROPERTIES_ENABLED
 652 Glib::PropertyProxy<int> TextTag::property_right_margin()
 653 {
 654   return Glib::PropertyProxy<int>(this, "right-margin");
 655 }
 656 #endif //GLIBMM_PROPERTIES_ENABLED
 657
 658 #ifdef GLIBMM_PROPERTIES_ENABLED
 659 Glib::PropertyProxy_ReadOnly<int> TextTag::property_right_margin() const
 660 {
 661   return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
 662 }
 663 #endif //GLIBMM_PROPERTIES_ENABLED
 664
 665 #ifdef GLIBMM_PROPERTIES_ENABLED
 666 Glib::PropertyProxy<Pango::Underline> TextTag::property_underline()
 667 {
 668   return Glib::PropertyProxy<Pango::Underline>(this, "underline");
 669 }
 670 #endif //GLIBMM_PROPERTIES_ENABLED
 671
 672 #ifdef GLIBMM_PROPERTIES_ENABLED
 673 Glib::PropertyProxy_ReadOnly<Pango::Underline> TextTag::property_underline() const
 674 {
 675   return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
 676 }
 677 #endif //GLIBMM_PROPERTIES_ENABLED
 678
 679 #ifdef GLIBMM_PROPERTIES_ENABLED
 680 Glib::PropertyProxy<int> TextTag::property_rise()
 681 {
 682   return Glib::PropertyProxy<int>(this, "rise");
 683 }
 684 #endif //GLIBMM_PROPERTIES_ENABLED
 685
 686 #ifdef GLIBMM_PROPERTIES_ENABLED
 687 Glib::PropertyProxy_ReadOnly<int> TextTag::property_rise() const
 688 {
 689   return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
 690 }
 691 #endif //GLIBMM_PROPERTIES_ENABLED
 692
 693 #ifdef GLIBMM_PROPERTIES_ENABLED
 694 Glib::PropertyProxy<bool> TextTag::property_background_full_height()
 695 {
 696   return Glib::PropertyProxy<bool>(this, "background-full-height");
 697 }
 698 #endif //GLIBMM_PROPERTIES_ENABLED
 699
 700 #ifdef GLIBMM_PROPERTIES_ENABLED
 701 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_full_height() const
 702 {
 703   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-full-height");
 704 }
 705 #endif //GLIBMM_PROPERTIES_ENABLED
 706
 707 #ifdef GLIBMM_PROPERTIES_ENABLED
 708 Glib::PropertyProxy<Glib::ustring> TextTag::property_language()
 709 {
 710   return Glib::PropertyProxy<Glib::ustring>(this, "language");
 711 }
 712 #endif //GLIBMM_PROPERTIES_ENABLED
 713
 714 #ifdef GLIBMM_PROPERTIES_ENABLED
 715 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_language() const
 716 {
 717   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "language");
 718 }
 719 #endif //GLIBMM_PROPERTIES_ENABLED
 720
 721 #ifdef GLIBMM_PROPERTIES_ENABLED
 722 Glib::PropertyProxy<Pango::TabArray> TextTag::property_tabs()
 723 {
 724   return Glib::PropertyProxy<Pango::TabArray>(this, "tabs");
 725 }
 726 #endif //GLIBMM_PROPERTIES_ENABLED
 727
 728 #ifdef GLIBMM_PROPERTIES_ENABLED
 729 Glib::PropertyProxy_ReadOnly<Pango::TabArray> TextTag::property_tabs() const
 730 {
 731   return Glib::PropertyProxy_ReadOnly<Pango::TabArray>(this, "tabs");
 732 }
 733 #endif //GLIBMM_PROPERTIES_ENABLED
 734
 735 #ifdef GLIBMM_PROPERTIES_ENABLED
 736 Glib::PropertyProxy<bool> TextTag::property_invisible()
 737 {
 738   return Glib::PropertyProxy<bool>(this, "invisible");
 739 }
 740 #endif //GLIBMM_PROPERTIES_ENABLED
 741
 742 #ifdef GLIBMM_PROPERTIES_ENABLED
 743 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_invisible() const
 744 {
 745   return Glib::PropertyProxy_ReadOnly<bool>(this, "invisible");
 746 }
 747 #endif //GLIBMM_PROPERTIES_ENABLED
 748
 749 #ifdef GLIBMM_PROPERTIES_ENABLED
 750 Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_paragraph_background()
 751 {
 752   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "paragraph-background");
 753 }
 754 #endif //GLIBMM_PROPERTIES_ENABLED
 755
 756 #ifdef GLIBMM_PROPERTIES_ENABLED
 757 Glib::PropertyProxy<Gdk::Color> TextTag::property_paragraph_background_gdk()
 758 {
 759   return Glib::PropertyProxy<Gdk::Color>(this, "paragraph-background-gdk");
 760 }
 761 #endif //GLIBMM_PROPERTIES_ENABLED
 762
 763 #ifdef GLIBMM_PROPERTIES_ENABLED
 764 Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_paragraph_background_gdk() const
 765 {
 766   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "paragraph-background-gdk");
 767 }
 768 #endif //GLIBMM_PROPERTIES_ENABLED
 769
 770 #ifdef GLIBMM_PROPERTIES_ENABLED
 771 Glib::PropertyProxy<bool> TextTag::property_accumulative_margin()
 772 {
 773   return Glib::PropertyProxy<bool>(this, "accumulative-margin");
 774 }
 775 #endif //GLIBMM_PROPERTIES_ENABLED
 776
 777 #ifdef GLIBMM_PROPERTIES_ENABLED
 778 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_accumulative_margin() const
 779 {
 780   return Glib::PropertyProxy_ReadOnly<bool>(this, "accumulative-margin");
 781 }
 782 #endif //GLIBMM_PROPERTIES_ENABLED
 783
 784 #ifdef GLIBMM_PROPERTIES_ENABLED
 785 Glib::PropertyProxy<bool> TextTag::property_background_set()
 786 {
 787   return Glib::PropertyProxy<bool>(this, "background-set");
 788 }
 789 #endif //GLIBMM_PROPERTIES_ENABLED
 790
 791 #ifdef GLIBMM_PROPERTIES_ENABLED
 792 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_set() const
 793 {
 794   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-set");
 795 }
 796 #endif //GLIBMM_PROPERTIES_ENABLED
 797
 798 #ifdef GLIBMM_PROPERTIES_ENABLED
 799 Glib::PropertyProxy<bool> TextTag::property_foreground_set()
 800 {
 801   return Glib::PropertyProxy<bool>(this, "foreground-set");
 802 }
 803 #endif //GLIBMM_PROPERTIES_ENABLED
 804
 805 #ifdef GLIBMM_PROPERTIES_ENABLED
 806 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_foreground_set() const
 807 {
 808   return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-set");
 809 }
 810 #endif //GLIBMM_PROPERTIES_ENABLED
 811
 812 #ifdef GLIBMM_PROPERTIES_ENABLED
 813 Glib::PropertyProxy<bool> TextTag::property_background_stipple_set()
 814 {
 815   return Glib::PropertyProxy<bool>(this, "background-stipple-set");
 816 }
 817 #endif //GLIBMM_PROPERTIES_ENABLED
 818
 819 #ifdef GLIBMM_PROPERTIES_ENABLED
 820 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_stipple_set() const
 821 {
 822   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-stipple-set");
 823 }
 824 #endif //GLIBMM_PROPERTIES_ENABLED
 825
 826 #ifdef GLIBMM_PROPERTIES_ENABLED
 827 Glib::PropertyProxy<bool> TextTag::property_foreground_stipple_set()
 828 {
 829   return Glib::PropertyProxy<bool>(this, "foreground-stipple-set");
 830 }
 831 #endif //GLIBMM_PROPERTIES_ENABLED
 832
 833 #ifdef GLIBMM_PROPERTIES_ENABLED
 834 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_foreground_stipple_set() const
 835 {
 836   return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-stipple-set");
 837 }
 838 #endif //GLIBMM_PROPERTIES_ENABLED
 839
 840 #ifdef GLIBMM_PROPERTIES_ENABLED
 841 Glib::PropertyProxy<bool> TextTag::property_family_set()
 842 {
 843   return Glib::PropertyProxy<bool>(this, "family-set");
 844 }
 845 #endif //GLIBMM_PROPERTIES_ENABLED
 846
 847 #ifdef GLIBMM_PROPERTIES_ENABLED
 848 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_family_set() const
 849 {
 850   return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
 851 }
 852 #endif //GLIBMM_PROPERTIES_ENABLED
 853
 854 #ifdef GLIBMM_PROPERTIES_ENABLED
 855 Glib::PropertyProxy<bool> TextTag::property_style_set()
 856 {
 857   return Glib::PropertyProxy<bool>(this, "style-set");
 858 }
 859 #endif //GLIBMM_PROPERTIES_ENABLED
 860
 861 #ifdef GLIBMM_PROPERTIES_ENABLED
 862 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_style_set() const
 863 {
 864   return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
 865 }
 866 #endif //GLIBMM_PROPERTIES_ENABLED
 867
 868 #ifdef GLIBMM_PROPERTIES_ENABLED
 869 Glib::PropertyProxy<bool> TextTag::property_variant_set()
 870 {
 871   return Glib::PropertyProxy<bool>(this, "variant-set");
 872 }
 873 #endif //GLIBMM_PROPERTIES_ENABLED
 874
 875 #ifdef GLIBMM_PROPERTIES_ENABLED
 876 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_variant_set() const
 877 {
 878   return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
 879 }
 880 #endif //GLIBMM_PROPERTIES_ENABLED
 881
 882 #ifdef GLIBMM_PROPERTIES_ENABLED
 883 Glib::PropertyProxy<bool> TextTag::property_weight_set()
 884 {
 885   return Glib::PropertyProxy<bool>(this, "weight-set");
 886 }
 887 #endif //GLIBMM_PROPERTIES_ENABLED
 888
 889 #ifdef GLIBMM_PROPERTIES_ENABLED
 890 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_weight_set() const
 891 {
 892   return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
 893 }
 894 #endif //GLIBMM_PROPERTIES_ENABLED
 895
 896 #ifdef GLIBMM_PROPERTIES_ENABLED
 897 Glib::PropertyProxy<bool> TextTag::property_stretch_set()
 898 {
 899   return Glib::PropertyProxy<bool>(this, "stretch-set");
 900 }
 901 #endif //GLIBMM_PROPERTIES_ENABLED
 902
 903 #ifdef GLIBMM_PROPERTIES_ENABLED
 904 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_stretch_set() const
 905 {
 906   return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
 907 }
 908 #endif //GLIBMM_PROPERTIES_ENABLED
 909
 910 #ifdef GLIBMM_PROPERTIES_ENABLED
 911 Glib::PropertyProxy<bool> TextTag::property_size_set()
 912 {
 913   return Glib::PropertyProxy<bool>(this, "size-set");
 914 }
 915 #endif //GLIBMM_PROPERTIES_ENABLED
 916
 917 #ifdef GLIBMM_PROPERTIES_ENABLED
 918 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_size_set() const
 919 {
 920   return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
 921 }
 922 #endif //GLIBMM_PROPERTIES_ENABLED
 923
 924 #ifdef GLIBMM_PROPERTIES_ENABLED
 925 Glib::PropertyProxy<bool> TextTag::property_scale_set()
 926 {
 927   return Glib::PropertyProxy<bool>(this, "scale-set");
 928 }
 929 #endif //GLIBMM_PROPERTIES_ENABLED
 930
 931 #ifdef GLIBMM_PROPERTIES_ENABLED
 932 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_scale_set() const
 933 {
 934   return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
 935 }
 936 #endif //GLIBMM_PROPERTIES_ENABLED
 937
 938 #ifdef GLIBMM_PROPERTIES_ENABLED
 939 Glib::PropertyProxy<bool> TextTag::property_pixels_above_lines_set()
 940 {
 941   return Glib::PropertyProxy<bool>(this, "pixels-above-lines-set");
 942 }
 943 #endif //GLIBMM_PROPERTIES_ENABLED
 944
 945 #ifdef GLIBMM_PROPERTIES_ENABLED
 946 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_above_lines_set() const
 947 {
 948   return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-above-lines-set");
 949 }
 950 #endif //GLIBMM_PROPERTIES_ENABLED
 951
 952 #ifdef GLIBMM_PROPERTIES_ENABLED
 953 Glib::PropertyProxy<bool> TextTag::property_pixels_below_lines_set()
 954 {
 955   return Glib::PropertyProxy<bool>(this, "pixels-below-lines-set");
 956 }
 957 #endif //GLIBMM_PROPERTIES_ENABLED
 958
 959 #ifdef GLIBMM_PROPERTIES_ENABLED
 960 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_below_lines_set() const
 961 {
 962   return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-below-lines-set");
 963 }
 964 #endif //GLIBMM_PROPERTIES_ENABLED
 965
 966 #ifdef GLIBMM_PROPERTIES_ENABLED
 967 Glib::PropertyProxy<bool> TextTag::property_pixels_inside_wrap_set()
 968 {
 969   return Glib::PropertyProxy<bool>(this, "pixels-inside-wrap-set");
 970 }
 971 #endif //GLIBMM_PROPERTIES_ENABLED
 972
 973 #ifdef GLIBMM_PROPERTIES_ENABLED
 974 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_inside_wrap_set() const
 975 {
 976   return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-inside-wrap-set");
 977 }
 978 #endif //GLIBMM_PROPERTIES_ENABLED
 979
 980 #ifdef GLIBMM_PROPERTIES_ENABLED
 981 Glib::PropertyProxy<bool> TextTag::property_editable_set()
 982 {
 983   return Glib::PropertyProxy<bool>(this, "editable-set");
 984 }
 985 #endif //GLIBMM_PROPERTIES_ENABLED
 986
 987 #ifdef GLIBMM_PROPERTIES_ENABLED
 988 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_editable_set() const
 989 {
 990   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable-set");
 991 }
 992 #endif //GLIBMM_PROPERTIES_ENABLED
 993
 994 #ifdef GLIBMM_PROPERTIES_ENABLED
 995 Glib::PropertyProxy<bool> TextTag::property_wrap_mode_set()
 996 {
 997   return Glib::PropertyProxy<bool>(this, "wrap-mode-set");
 998 }
 999 #endif //GLIBMM_PROPERTIES_ENABLED
1000
1001 #ifdef GLIBMM_PROPERTIES_ENABLED
1002 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_wrap_mode_set() const
1003 {
1004   return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap-mode-set");
1005 }
1006 #endif //GLIBMM_PROPERTIES_ENABLED
1007
1008 #ifdef GLIBMM_PROPERTIES_ENABLED
1009 Glib::PropertyProxy<bool> TextTag::property_justification_set()
1010 {
1011   return Glib::PropertyProxy<bool>(this, "justification-set");
1012 }
1013 #endif //GLIBMM_PROPERTIES_ENABLED
1014
1015 #ifdef GLIBMM_PROPERTIES_ENABLED
1016 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_justification_set() const
1017 {
1018   return Glib::PropertyProxy_ReadOnly<bool>(this, "justification-set");
1019 }
1020 #endif //GLIBMM_PROPERTIES_ENABLED
1021
1022 #ifdef GLIBMM_PROPERTIES_ENABLED
1023 Glib::PropertyProxy<bool> TextTag::property_left_margin_set()
1024 {
1025   return Glib::PropertyProxy<bool>(this, "left-margin-set");
1026 }
1027 #endif //GLIBMM_PROPERTIES_ENABLED
1028
1029 #ifdef GLIBMM_PROPERTIES_ENABLED
1030 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_left_margin_set() const
1031 {
1032   return Glib::PropertyProxy_ReadOnly<bool>(this, "left-margin-set");
1033 }
1034 #endif //GLIBMM_PROPERTIES_ENABLED
1035
1036 #ifdef GLIBMM_PROPERTIES_ENABLED
1037 Glib::PropertyProxy<bool> TextTag::property_indent_set()
1038 {
1039   return Glib::PropertyProxy<bool>(this, "indent-set");
1040 }
1041 #endif //GLIBMM_PROPERTIES_ENABLED
1042
1043 #ifdef GLIBMM_PROPERTIES_ENABLED
1044 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_indent_set() const
1045 {
1046   return Glib::PropertyProxy_ReadOnly<bool>(this, "indent-set");
1047 }
1048 #endif //GLIBMM_PROPERTIES_ENABLED
1049
1050 #ifdef GLIBMM_PROPERTIES_ENABLED
1051 Glib::PropertyProxy<bool> TextTag::property_strikethrough_set()
1052 {
1053   return Glib::PropertyProxy<bool>(this, "strikethrough-set");
1054 }
1055 #endif //GLIBMM_PROPERTIES_ENABLED
1056
1057 #ifdef GLIBMM_PROPERTIES_ENABLED
1058 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_strikethrough_set() const
1059 {
1060   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
1061 }
1062 #endif //GLIBMM_PROPERTIES_ENABLED
1063
1064 #ifdef GLIBMM_PROPERTIES_ENABLED
1065 Glib::PropertyProxy<bool> TextTag::property_right_margin_set()
1066 {
1067   return Glib::PropertyProxy<bool>(this, "right-margin-set");
1068 }
1069 #endif //GLIBMM_PROPERTIES_ENABLED
1070
1071 #ifdef GLIBMM_PROPERTIES_ENABLED
1072 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_right_margin_set() const
1073 {
1074   return Glib::PropertyProxy_ReadOnly<bool>(this, "right-margin-set");
1075 }
1076 #endif //GLIBMM_PROPERTIES_ENABLED
1077
1078 #ifdef GLIBMM_PROPERTIES_ENABLED
1079 Glib::PropertyProxy<bool> TextTag::property_underline_set()
1080 {
1081   return Glib::PropertyProxy<bool>(this, "underline-set");
1082 }
1083 #endif //GLIBMM_PROPERTIES_ENABLED
1084
1085 #ifdef GLIBMM_PROPERTIES_ENABLED
1086 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_underline_set() const
1087 {
1088   return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
1089 }
1090 #endif //GLIBMM_PROPERTIES_ENABLED
1091
1092 #ifdef GLIBMM_PROPERTIES_ENABLED
1093 Glib::PropertyProxy<bool> TextTag::property_rise_set()
1094 {
1095   return Glib::PropertyProxy<bool>(this, "rise-set");
1096 }
1097 #endif //GLIBMM_PROPERTIES_ENABLED
1098
1099 #ifdef GLIBMM_PROPERTIES_ENABLED
1100 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_rise_set() const
1101 {
1102   return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
1103 }
1104 #endif //GLIBMM_PROPERTIES_ENABLED
1105
1106 #ifdef GLIBMM_PROPERTIES_ENABLED
1107 Glib::PropertyProxy<bool> TextTag::property_background_full_height_set()
1108 {
1109   return Glib::PropertyProxy<bool>(this, "background-full-height-set");
1110 }
1111 #endif //GLIBMM_PROPERTIES_ENABLED
1112
1113 #ifdef GLIBMM_PROPERTIES_ENABLED
1114 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_full_height_set() const
1115 {
1116   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-full-height-set");
1117 }
1118 #endif //GLIBMM_PROPERTIES_ENABLED
1119
1120 #ifdef GLIBMM_PROPERTIES_ENABLED
1121 Glib::PropertyProxy<bool> TextTag::property_language_set()
1122 {
1123   return Glib::PropertyProxy<bool>(this, "language-set");
1124 }
1125 #endif //GLIBMM_PROPERTIES_ENABLED
1126
1127 #ifdef GLIBMM_PROPERTIES_ENABLED
1128 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_language_set() const
1129 {
1130   return Glib::PropertyProxy_ReadOnly<bool>(this, "language-set");
1131 }
1132 #endif //GLIBMM_PROPERTIES_ENABLED
1133
1134 #ifdef GLIBMM_PROPERTIES_ENABLED
1135 Glib::PropertyProxy<bool> TextTag::property_tabs_set()
1136 {
1137   return Glib::PropertyProxy<bool>(this, "tabs-set");
1138 }
1139 #endif //GLIBMM_PROPERTIES_ENABLED
1140
1141 #ifdef GLIBMM_PROPERTIES_ENABLED
1142 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_tabs_set() const
1143 {
1144   return Glib::PropertyProxy_ReadOnly<bool>(this, "tabs-set");
1145 }
1146 #endif //GLIBMM_PROPERTIES_ENABLED
1147
1148 #ifdef GLIBMM_PROPERTIES_ENABLED
1149 Glib::PropertyProxy<bool> TextTag::property_invisible_set()
1150 {
1151   return Glib::PropertyProxy<bool>(this, "invisible-set");
1152 }
1153 #endif //GLIBMM_PROPERTIES_ENABLED
1154
1155 #ifdef GLIBMM_PROPERTIES_ENABLED
1156 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_invisible_set() const
1157 {
1158   return Glib::PropertyProxy_ReadOnly<bool>(this, "invisible-set");
1159 }
1160 #endif //GLIBMM_PROPERTIES_ENABLED
1161
1162 #ifdef GLIBMM_PROPERTIES_ENABLED
1163 Glib::PropertyProxy<bool> TextTag::property_paragraph_background_set()
1164 {
1165   return Glib::PropertyProxy<bool>(this, "paragraph-background-set");
1166 }
1167 #endif //GLIBMM_PROPERTIES_ENABLED
1168
1169 #ifdef GLIBMM_PROPERTIES_ENABLED
1170 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_paragraph_background_set() const
1171 {
1172   return Glib::PropertyProxy_ReadOnly<bool>(this, "paragraph-background-set");
1173 }
1174 #endif //GLIBMM_PROPERTIES_ENABLED
1175
1176
1177 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
1178 bool Gtk::TextTag::on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)
1179 {
1180   BaseClassType *const base = static_cast<BaseClassType*>(
1181       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
1182   );
1183
1184   if(base && base->event)
1185     return (*base->event)(gobj(),Glib::unwrap(event_object),event,(iter).gobj());
1186
1187   typedef bool RType;
1188   return RType();
1189 }
1190 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
1191
1192 #ifdef GLIBMM_VFUNCS_ENABLED
1193 #endif //GLIBMM_VFUNCS_ENABLED
1194
1195
1196 } // namespace Gtk
1197
1198