libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/cellrenderertext.h>
   5 #include <gtkmm/private/cellrenderertext_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 #include <gtk/gtkcellrenderertext.h>
  29
  30 namespace Gtk
  31 {
  32
  33 #ifdef GLIBMM_PROPERTIES_ENABLED
  34 Glib::PropertyProxy_Base CellRendererText::_property_renderable()
  35 {
  36   return property_text();
  37 }
  38 #else
  39 Glib::ustring CellRendererText::_property_renderable()
  40 {
  41   return "text";
  42 }
  43 #endif //#GLIBMM_PROPERTIES_ENABLED
  44
  45 void CellRendererText::edited(const Glib::ustring& path, const Glib::ustring& new_text)
  46 {
  47   g_signal_emit_by_name(gobj(), "edited", path.c_str(), new_text.c_str());
  48 }
  49
  50 } // namespace Gtk
  51
  52
  53 namespace
  54 {
  55
  56
  57 static void CellRendererText_signal_edited_callback(GtkCellRendererText* self, const gchar* p0,const gchar* p1,void* data)
  58 {
  59   using namespace Gtk;
  60   typedef sigc::slot< void,const Glib::ustring&,const Glib::ustring& > SlotType;
  61
  62   // Do not try to call a signal on a disassociated wrapper.
  63   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
  64   {
  65     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  66     try
  67     {
  68     #endif //GLIBMM_EXCEPTIONS_ENABLED
  69       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
  70         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
  71 , Glib::convert_const_gchar_ptr_to_ustring(p1)
  72 );
  73     #ifdef GLIBMM_EXCEPTIONS_ENABLED
  74     }
  75     catch(...)
  76     {
  77       Glib::exception_handlers_invoke();
  78     }
  79     #endif //GLIBMM_EXCEPTIONS_ENABLED
  80   }
  81 }
  82
  83 static const Glib::SignalProxyInfo CellRendererText_signal_edited_info =
  84 {
  85   "edited",
  86   (GCallback) &CellRendererText_signal_edited_callback,
  87   (GCallback) &CellRendererText_signal_edited_callback
  88 };
  89
  90
  91 } // anonymous namespace
  92
  93
  94 namespace Glib
  95 {
  96
  97 Gtk::CellRendererText* wrap(GtkCellRendererText* object, bool take_copy)
  98 {
  99   return dynamic_cast<Gtk::CellRendererText *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 100 }
 101
 102 } /* namespace Glib */
 103
 104 namespace Gtk
 105 {
 106
 107
 108 /* The *_Class implementation: */
 109
 110 const Glib::Class& CellRendererText_Class::init()
 111 {
 112   if(!gtype_) // create the GType if necessary
 113   {
 114     // Glib::Class has to know the class init function to clone custom types.
 115     class_init_func_ = &CellRendererText_Class::class_init_function;
 116
 117     // This is actually just optimized away, apparently with no harm.
 118     // Make sure that the parent type has been created.
 119     //CppClassParent::CppObjectType::get_type();
 120
 121     // Create the wrapper type, with the same class/instance size as the base type.
 122     register_derived_type(gtk_cell_renderer_text_get_type());
 123
 124     // Add derived versions of interfaces, if the C type implements any interfaces:
 125   }
 126
 127   return *this;
 128 }
 129
 130 void CellRendererText_Class::class_init_function(void* g_class, void* class_data)
 131 {
 132   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 133   CppClassParent::class_init_function(klass, class_data);
 134
 135 #ifdef GLIBMM_VFUNCS_ENABLED
 136 #endif //GLIBMM_VFUNCS_ENABLED
 137
 138 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 139   klass->edited = &edited_callback;
 140 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 141 }
 142
 143 #ifdef GLIBMM_VFUNCS_ENABLED
 144 #endif //GLIBMM_VFUNCS_ENABLED
 145
 146 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 147 void CellRendererText_Class::edited_callback(GtkCellRendererText* self, const gchar* p0, const gchar* p1)
 148 {
 149   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
 150       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 151
 152   // Non-gtkmmproc-generated custom classes implicitly call the default
 153   // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 154   // generated classes can use this optimisation, which avoids the unnecessary
 155   // parameter conversions if there is no possibility of the virtual function
 156   // being overridden:
 157   if(obj && obj->is_derived_())
 158   {
 159     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 160     try // Trap C++ exceptions which would normally be lost because this is a C callback.
 161     {
 162     #endif //GLIBMM_EXCEPTIONS_ENABLED
 163       // Call the virtual member method, which derived classes might override.
 164       obj->on_edited(Glib::convert_const_gchar_ptr_to_ustring(p0)
 165 , Glib::convert_const_gchar_ptr_to_ustring(p1)
 166 );
 167     #ifdef GLIBMM_EXCEPTIONS_ENABLED
 168     }
 169     catch(...)
 170     {
 171       Glib::exception_handlers_invoke();
 172     }
 173     #endif //GLIBMM_EXCEPTIONS_ENABLED
 174   }
 175   else
 176   {
 177     BaseClassType *const base = static_cast<BaseClassType*>(
 178         g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 179     );
 180
 181     // Call the original underlying C function:
 182     if(base && base->edited)
 183       (*base->edited)(self, p0, p1);
 184   }
 185 }
 186 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 187
 188
 189 Glib::ObjectBase* CellRendererText_Class::wrap_new(GObject* o)
 190 {
 191   return manage(new CellRendererText((GtkCellRendererText*)(o)));
 192
 193 }
 194
 195
 196 /* The implementation: */
 197
 198 CellRendererText::CellRendererText(const Glib::ConstructParams& construct_params)
 199 :
 200   Gtk::CellRenderer(construct_params)
 201 {
 202   }
 203
 204 CellRendererText::CellRendererText(GtkCellRendererText* castitem)
 205 :
 206   Gtk::CellRenderer((GtkCellRenderer*)(castitem))
 207 {
 208   }
 209
 210 CellRendererText::~CellRendererText()
 211 {
 212   destroy_();
 213 }
 214
 215 CellRendererText::CppClassType CellRendererText::cellrenderertext_class_; // initialize static member
 216
 217 GType CellRendererText::get_type()
 218 {
 219   return cellrenderertext_class_.init().get_type();
 220 }
 221
 222 GType CellRendererText::get_base_type()
 223 {
 224   return gtk_cell_renderer_text_get_type();
 225 }
 226
 227
 228 CellRendererText::CellRendererText()
 229 :
 230   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
 231   Gtk::CellRenderer(Glib::ConstructParams(cellrenderertext_class_.init()))
 232 {
 233   }
 234
 235 void CellRendererText::set_fixed_height_from_font(int number_of_rows)
 236 {
 237 gtk_cell_renderer_text_set_fixed_height_from_font(gobj(), number_of_rows);
 238 }
 239
 240
 241 Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& > CellRendererText::signal_edited()
 242 {
 243   return Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& >(this, &CellRendererText_signal_edited_info);
 244 }
 245
 246
 247 #ifdef GLIBMM_PROPERTIES_ENABLED
 248 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_text()
 249 {
 250   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 251 }
 252 #endif //GLIBMM_PROPERTIES_ENABLED
 253
 254 #ifdef GLIBMM_PROPERTIES_ENABLED
 255 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_text() const
 256 {
 257   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 258 }
 259 #endif //GLIBMM_PROPERTIES_ENABLED
 260
 261 #ifdef GLIBMM_PROPERTIES_ENABLED
 262 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_markup()
 263 {
 264   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "markup");
 265 }
 266 #endif //GLIBMM_PROPERTIES_ENABLED
 267
 268 #ifdef GLIBMM_PROPERTIES_ENABLED
 269 Glib::PropertyProxy<Pango::AttrList> CellRendererText::property_attributes()
 270 {
 271   return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
 272 }
 273 #endif //GLIBMM_PROPERTIES_ENABLED
 274
 275 #ifdef GLIBMM_PROPERTIES_ENABLED
 276 Glib::PropertyProxy_ReadOnly<Pango::AttrList> CellRendererText::property_attributes() const
 277 {
 278   return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
 279 }
 280 #endif //GLIBMM_PROPERTIES_ENABLED
 281
 282 #ifdef GLIBMM_PROPERTIES_ENABLED
 283 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_background()
 284 {
 285   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "background");
 286 }
 287 #endif //GLIBMM_PROPERTIES_ENABLED
 288
 289 #ifdef GLIBMM_PROPERTIES_ENABLED
 290 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_foreground()
 291 {
 292   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "foreground");
 293 }
 294 #endif //GLIBMM_PROPERTIES_ENABLED
 295
 296 #ifdef GLIBMM_PROPERTIES_ENABLED
 297 Glib::PropertyProxy<Gdk::Color> CellRendererText::property_background_gdk()
 298 {
 299   return Glib::PropertyProxy<Gdk::Color>(this, "background-gdk");
 300 }
 301 #endif //GLIBMM_PROPERTIES_ENABLED
 302
 303 #ifdef GLIBMM_PROPERTIES_ENABLED
 304 Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRendererText::property_background_gdk() const
 305 {
 306   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "background-gdk");
 307 }
 308 #endif //GLIBMM_PROPERTIES_ENABLED
 309
 310 #ifdef GLIBMM_PROPERTIES_ENABLED
 311 Glib::PropertyProxy<Gdk::Color> CellRendererText::property_foreground_gdk()
 312 {
 313   return Glib::PropertyProxy<Gdk::Color>(this, "foreground-gdk");
 314 }
 315 #endif //GLIBMM_PROPERTIES_ENABLED
 316
 317 #ifdef GLIBMM_PROPERTIES_ENABLED
 318 Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRendererText::property_foreground_gdk() const
 319 {
 320   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "foreground-gdk");
 321 }
 322 #endif //GLIBMM_PROPERTIES_ENABLED
 323
 324 #ifdef GLIBMM_PROPERTIES_ENABLED
 325 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_font()
 326 {
 327   return Glib::PropertyProxy<Glib::ustring>(this, "font");
 328 }
 329 #endif //GLIBMM_PROPERTIES_ENABLED
 330
 331 #ifdef GLIBMM_PROPERTIES_ENABLED
 332 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_font() const
 333 {
 334   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
 335 }
 336 #endif //GLIBMM_PROPERTIES_ENABLED
 337
 338 #ifdef GLIBMM_PROPERTIES_ENABLED
 339 Glib::PropertyProxy<Pango::FontDescription> CellRendererText::property_font_desc()
 340 {
 341   return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
 342 }
 343 #endif //GLIBMM_PROPERTIES_ENABLED
 344
 345 #ifdef GLIBMM_PROPERTIES_ENABLED
 346 Glib::PropertyProxy_ReadOnly<Pango::FontDescription> CellRendererText::property_font_desc() const
 347 {
 348   return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
 349 }
 350 #endif //GLIBMM_PROPERTIES_ENABLED
 351
 352 #ifdef GLIBMM_PROPERTIES_ENABLED
 353 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_family()
 354 {
 355   return Glib::PropertyProxy<Glib::ustring>(this, "family");
 356 }
 357 #endif //GLIBMM_PROPERTIES_ENABLED
 358
 359 #ifdef GLIBMM_PROPERTIES_ENABLED
 360 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_family() const
 361 {
 362   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
 363 }
 364 #endif //GLIBMM_PROPERTIES_ENABLED
 365
 366 #ifdef GLIBMM_PROPERTIES_ENABLED
 367 Glib::PropertyProxy<Pango::Style> CellRendererText::property_style()
 368 {
 369   return Glib::PropertyProxy<Pango::Style>(this, "style");
 370 }
 371 #endif //GLIBMM_PROPERTIES_ENABLED
 372
 373 #ifdef GLIBMM_PROPERTIES_ENABLED
 374 Glib::PropertyProxy_ReadOnly<Pango::Style> CellRendererText::property_style() const
 375 {
 376   return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
 377 }
 378 #endif //GLIBMM_PROPERTIES_ENABLED
 379
 380 #ifdef GLIBMM_PROPERTIES_ENABLED
 381 Glib::PropertyProxy<Pango::Variant> CellRendererText::property_variant()
 382 {
 383   return Glib::PropertyProxy<Pango::Variant>(this, "variant");
 384 }
 385 #endif //GLIBMM_PROPERTIES_ENABLED
 386
 387 #ifdef GLIBMM_PROPERTIES_ENABLED
 388 Glib::PropertyProxy_ReadOnly<Pango::Variant> CellRendererText::property_variant() const
 389 {
 390   return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
 391 }
 392 #endif //GLIBMM_PROPERTIES_ENABLED
 393
 394 #ifdef GLIBMM_PROPERTIES_ENABLED
 395 Glib::PropertyProxy<int> CellRendererText::property_weight()
 396 {
 397   return Glib::PropertyProxy<int>(this, "weight");
 398 }
 399 #endif //GLIBMM_PROPERTIES_ENABLED
 400
 401 #ifdef GLIBMM_PROPERTIES_ENABLED
 402 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_weight() const
 403 {
 404   return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
 405 }
 406 #endif //GLIBMM_PROPERTIES_ENABLED
 407
 408 #ifdef GLIBMM_PROPERTIES_ENABLED
 409 Glib::PropertyProxy<Pango::Stretch> CellRendererText::property_stretch()
 410 {
 411   return Glib::PropertyProxy<Pango::Stretch>(this, "stretch");
 412 }
 413 #endif //GLIBMM_PROPERTIES_ENABLED
 414
 415 #ifdef GLIBMM_PROPERTIES_ENABLED
 416 Glib::PropertyProxy_ReadOnly<Pango::Stretch> CellRendererText::property_stretch() const
 417 {
 418   return Glib::PropertyProxy_ReadOnly<Pango::Stretch>(this, "stretch");
 419 }
 420 #endif //GLIBMM_PROPERTIES_ENABLED
 421
 422 #ifdef GLIBMM_PROPERTIES_ENABLED
 423 Glib::PropertyProxy<int> CellRendererText::property_size()
 424 {
 425   return Glib::PropertyProxy<int>(this, "size");
 426 }
 427 #endif //GLIBMM_PROPERTIES_ENABLED
 428
 429 #ifdef GLIBMM_PROPERTIES_ENABLED
 430 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_size() const
 431 {
 432   return Glib::PropertyProxy_ReadOnly<int>(this, "size");
 433 }
 434 #endif //GLIBMM_PROPERTIES_ENABLED
 435
 436 #ifdef GLIBMM_PROPERTIES_ENABLED
 437 Glib::PropertyProxy<double> CellRendererText::property_size_points()
 438 {
 439   return Glib::PropertyProxy<double>(this, "size-points");
 440 }
 441 #endif //GLIBMM_PROPERTIES_ENABLED
 442
 443 #ifdef GLIBMM_PROPERTIES_ENABLED
 444 Glib::PropertyProxy_ReadOnly<double> CellRendererText::property_size_points() const
 445 {
 446   return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
 447 }
 448 #endif //GLIBMM_PROPERTIES_ENABLED
 449
 450 #ifdef GLIBMM_PROPERTIES_ENABLED
 451 Glib::PropertyProxy<double> CellRendererText::property_scale()
 452 {
 453   return Glib::PropertyProxy<double>(this, "scale");
 454 }
 455 #endif //GLIBMM_PROPERTIES_ENABLED
 456
 457 #ifdef GLIBMM_PROPERTIES_ENABLED
 458 Glib::PropertyProxy_ReadOnly<double> CellRendererText::property_scale() const
 459 {
 460   return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
 461 }
 462 #endif //GLIBMM_PROPERTIES_ENABLED
 463
 464 #ifdef GLIBMM_PROPERTIES_ENABLED
 465 Glib::PropertyProxy<bool> CellRendererText::property_editable()
 466 {
 467   return Glib::PropertyProxy<bool>(this, "editable");
 468 }
 469 #endif //GLIBMM_PROPERTIES_ENABLED
 470
 471 #ifdef GLIBMM_PROPERTIES_ENABLED
 472 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_editable() const
 473 {
 474   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 475 }
 476 #endif //GLIBMM_PROPERTIES_ENABLED
 477
 478 #ifdef GLIBMM_PROPERTIES_ENABLED
 479 Glib::PropertyProxy<bool> CellRendererText::property_strikethrough()
 480 {
 481   return Glib::PropertyProxy<bool>(this, "strikethrough");
 482 }
 483 #endif //GLIBMM_PROPERTIES_ENABLED
 484
 485 #ifdef GLIBMM_PROPERTIES_ENABLED
 486 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_strikethrough() const
 487 {
 488   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
 489 }
 490 #endif //GLIBMM_PROPERTIES_ENABLED
 491
 492 #ifdef GLIBMM_PROPERTIES_ENABLED
 493 Glib::PropertyProxy<Pango::Underline> CellRendererText::property_underline()
 494 {
 495   return Glib::PropertyProxy<Pango::Underline>(this, "underline");
 496 }
 497 #endif //GLIBMM_PROPERTIES_ENABLED
 498
 499 #ifdef GLIBMM_PROPERTIES_ENABLED
 500 Glib::PropertyProxy_ReadOnly<Pango::Underline> CellRendererText::property_underline() const
 501 {
 502   return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
 503 }
 504 #endif //GLIBMM_PROPERTIES_ENABLED
 505
 506 #ifdef GLIBMM_PROPERTIES_ENABLED
 507 Glib::PropertyProxy<int> CellRendererText::property_rise()
 508 {
 509   return Glib::PropertyProxy<int>(this, "rise");
 510 }
 511 #endif //GLIBMM_PROPERTIES_ENABLED
 512
 513 #ifdef GLIBMM_PROPERTIES_ENABLED
 514 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_rise() const
 515 {
 516   return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
 517 }
 518 #endif //GLIBMM_PROPERTIES_ENABLED
 519
 520 #ifdef GLIBMM_PROPERTIES_ENABLED
 521 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_language()
 522 {
 523   return Glib::PropertyProxy<Glib::ustring>(this, "language");
 524 }
 525 #endif //GLIBMM_PROPERTIES_ENABLED
 526
 527 #ifdef GLIBMM_PROPERTIES_ENABLED
 528 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_language() const
 529 {
 530   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "language");
 531 }
 532 #endif //GLIBMM_PROPERTIES_ENABLED
 533
 534 #ifdef GLIBMM_PROPERTIES_ENABLED
 535 Glib::PropertyProxy<Pango::EllipsizeMode> CellRendererText::property_ellipsize()
 536 {
 537   return Glib::PropertyProxy<Pango::EllipsizeMode>(this, "ellipsize");
 538 }
 539 #endif //GLIBMM_PROPERTIES_ENABLED
 540
 541 #ifdef GLIBMM_PROPERTIES_ENABLED
 542 Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode> CellRendererText::property_ellipsize() const
 543 {
 544   return Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode>(this, "ellipsize");
 545 }
 546 #endif //GLIBMM_PROPERTIES_ENABLED
 547
 548 #ifdef GLIBMM_PROPERTIES_ENABLED
 549 Glib::PropertyProxy<int> CellRendererText::property_width_chars()
 550 {
 551   return Glib::PropertyProxy<int>(this, "width-chars");
 552 }
 553 #endif //GLIBMM_PROPERTIES_ENABLED
 554
 555 #ifdef GLIBMM_PROPERTIES_ENABLED
 556 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_width_chars() const
 557 {
 558   return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
 559 }
 560 #endif //GLIBMM_PROPERTIES_ENABLED
 561
 562 #ifdef GLIBMM_PROPERTIES_ENABLED
 563 Glib::PropertyProxy<Pango::WrapMode> CellRendererText::property_wrap_mode()
 564 {
 565   return Glib::PropertyProxy<Pango::WrapMode>(this, "wrap-mode");
 566 }
 567 #endif //GLIBMM_PROPERTIES_ENABLED
 568
 569 #ifdef GLIBMM_PROPERTIES_ENABLED
 570 Glib::PropertyProxy_ReadOnly<Pango::WrapMode> CellRendererText::property_wrap_mode() const
 571 {
 572   return Glib::PropertyProxy_ReadOnly<Pango::WrapMode>(this, "wrap-mode");
 573 }
 574 #endif //GLIBMM_PROPERTIES_ENABLED
 575
 576 #ifdef GLIBMM_PROPERTIES_ENABLED
 577 Glib::PropertyProxy<int> CellRendererText::property_wrap_width()
 578 {
 579   return Glib::PropertyProxy<int>(this, "wrap-width");
 580 }
 581 #endif //GLIBMM_PROPERTIES_ENABLED
 582
 583 #ifdef GLIBMM_PROPERTIES_ENABLED
 584 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_wrap_width() const
 585 {
 586   return Glib::PropertyProxy_ReadOnly<int>(this, "wrap-width");
 587 }
 588 #endif //GLIBMM_PROPERTIES_ENABLED
 589
 590 #ifdef GLIBMM_PROPERTIES_ENABLED
 591 Glib::PropertyProxy<Pango::Alignment> CellRendererText::property_alignment()
 592 {
 593   return Glib::PropertyProxy<Pango::Alignment>(this, "alignment");
 594 }
 595 #endif //GLIBMM_PROPERTIES_ENABLED
 596
 597 #ifdef GLIBMM_PROPERTIES_ENABLED
 598 Glib::PropertyProxy_ReadOnly<Pango::Alignment> CellRendererText::property_alignment() const
 599 {
 600   return Glib::PropertyProxy_ReadOnly<Pango::Alignment>(this, "alignment");
 601 }
 602 #endif //GLIBMM_PROPERTIES_ENABLED
 603
 604 #ifdef GLIBMM_PROPERTIES_ENABLED
 605 Glib::PropertyProxy<bool> CellRendererText::property_background_set()
 606 {
 607   return Glib::PropertyProxy<bool>(this, "background-set");
 608 }
 609 #endif //GLIBMM_PROPERTIES_ENABLED
 610
 611 #ifdef GLIBMM_PROPERTIES_ENABLED
 612 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_background_set() const
 613 {
 614   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-set");
 615 }
 616 #endif //GLIBMM_PROPERTIES_ENABLED
 617
 618 #ifdef GLIBMM_PROPERTIES_ENABLED
 619 Glib::PropertyProxy<bool> CellRendererText::property_foreground_set()
 620 {
 621   return Glib::PropertyProxy<bool>(this, "foreground-set");
 622 }
 623 #endif //GLIBMM_PROPERTIES_ENABLED
 624
 625 #ifdef GLIBMM_PROPERTIES_ENABLED
 626 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_foreground_set() const
 627 {
 628   return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-set");
 629 }
 630 #endif //GLIBMM_PROPERTIES_ENABLED
 631
 632 #ifdef GLIBMM_PROPERTIES_ENABLED
 633 Glib::PropertyProxy<bool> CellRendererText::property_family_set()
 634 {
 635   return Glib::PropertyProxy<bool>(this, "family-set");
 636 }
 637 #endif //GLIBMM_PROPERTIES_ENABLED
 638
 639 #ifdef GLIBMM_PROPERTIES_ENABLED
 640 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_family_set() const
 641 {
 642   return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
 643 }
 644 #endif //GLIBMM_PROPERTIES_ENABLED
 645
 646 #ifdef GLIBMM_PROPERTIES_ENABLED
 647 Glib::PropertyProxy<bool> CellRendererText::property_style_set()
 648 {
 649   return Glib::PropertyProxy<bool>(this, "style-set");
 650 }
 651 #endif //GLIBMM_PROPERTIES_ENABLED
 652
 653 #ifdef GLIBMM_PROPERTIES_ENABLED
 654 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_style_set() const
 655 {
 656   return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
 657 }
 658 #endif //GLIBMM_PROPERTIES_ENABLED
 659
 660 #ifdef GLIBMM_PROPERTIES_ENABLED
 661 Glib::PropertyProxy<bool> CellRendererText::property_variant_set()
 662 {
 663   return Glib::PropertyProxy<bool>(this, "variant-set");
 664 }
 665 #endif //GLIBMM_PROPERTIES_ENABLED
 666
 667 #ifdef GLIBMM_PROPERTIES_ENABLED
 668 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_variant_set() const
 669 {
 670   return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
 671 }
 672 #endif //GLIBMM_PROPERTIES_ENABLED
 673
 674 #ifdef GLIBMM_PROPERTIES_ENABLED
 675 Glib::PropertyProxy<bool> CellRendererText::property_weight_set()
 676 {
 677   return Glib::PropertyProxy<bool>(this, "weight-set");
 678 }
 679 #endif //GLIBMM_PROPERTIES_ENABLED
 680
 681 #ifdef GLIBMM_PROPERTIES_ENABLED
 682 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_weight_set() const
 683 {
 684   return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
 685 }
 686 #endif //GLIBMM_PROPERTIES_ENABLED
 687
 688 #ifdef GLIBMM_PROPERTIES_ENABLED
 689 Glib::PropertyProxy<bool> CellRendererText::property_stretch_set()
 690 {
 691   return Glib::PropertyProxy<bool>(this, "stretch-set");
 692 }
 693 #endif //GLIBMM_PROPERTIES_ENABLED
 694
 695 #ifdef GLIBMM_PROPERTIES_ENABLED
 696 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_stretch_set() const
 697 {
 698   return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
 699 }
 700 #endif //GLIBMM_PROPERTIES_ENABLED
 701
 702 #ifdef GLIBMM_PROPERTIES_ENABLED
 703 Glib::PropertyProxy<bool> CellRendererText::property_size_set()
 704 {
 705   return Glib::PropertyProxy<bool>(this, "size-set");
 706 }
 707 #endif //GLIBMM_PROPERTIES_ENABLED
 708
 709 #ifdef GLIBMM_PROPERTIES_ENABLED
 710 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_size_set() const
 711 {
 712   return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
 713 }
 714 #endif //GLIBMM_PROPERTIES_ENABLED
 715
 716 #ifdef GLIBMM_PROPERTIES_ENABLED
 717 Glib::PropertyProxy<bool> CellRendererText::property_scale_set()
 718 {
 719   return Glib::PropertyProxy<bool>(this, "scale-set");
 720 }
 721 #endif //GLIBMM_PROPERTIES_ENABLED
 722
 723 #ifdef GLIBMM_PROPERTIES_ENABLED
 724 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_scale_set() const
 725 {
 726   return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
 727 }
 728 #endif //GLIBMM_PROPERTIES_ENABLED
 729
 730 #ifdef GLIBMM_PROPERTIES_ENABLED
 731 Glib::PropertyProxy<bool> CellRendererText::property_editable_set()
 732 {
 733   return Glib::PropertyProxy<bool>(this, "editable-set");
 734 }
 735 #endif //GLIBMM_PROPERTIES_ENABLED
 736
 737 #ifdef GLIBMM_PROPERTIES_ENABLED
 738 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_editable_set() const
 739 {
 740   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable-set");
 741 }
 742 #endif //GLIBMM_PROPERTIES_ENABLED
 743
 744 #ifdef GLIBMM_PROPERTIES_ENABLED
 745 Glib::PropertyProxy<bool> CellRendererText::property_strikethrough_set()
 746 {
 747   return Glib::PropertyProxy<bool>(this, "strikethrough-set");
 748 }
 749 #endif //GLIBMM_PROPERTIES_ENABLED
 750
 751 #ifdef GLIBMM_PROPERTIES_ENABLED
 752 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_strikethrough_set() const
 753 {
 754   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
 755 }
 756 #endif //GLIBMM_PROPERTIES_ENABLED
 757
 758 #ifdef GLIBMM_PROPERTIES_ENABLED
 759 Glib::PropertyProxy<bool> CellRendererText::property_underline_set()
 760 {
 761   return Glib::PropertyProxy<bool>(this, "underline-set");
 762 }
 763 #endif //GLIBMM_PROPERTIES_ENABLED
 764
 765 #ifdef GLIBMM_PROPERTIES_ENABLED
 766 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_underline_set() const
 767 {
 768   return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
 769 }
 770 #endif //GLIBMM_PROPERTIES_ENABLED
 771
 772 #ifdef GLIBMM_PROPERTIES_ENABLED
 773 Glib::PropertyProxy<bool> CellRendererText::property_rise_set()
 774 {
 775   return Glib::PropertyProxy<bool>(this, "rise-set");
 776 }
 777 #endif //GLIBMM_PROPERTIES_ENABLED
 778
 779 #ifdef GLIBMM_PROPERTIES_ENABLED
 780 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_rise_set() const
 781 {
 782   return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
 783 }
 784 #endif //GLIBMM_PROPERTIES_ENABLED
 785
 786 #ifdef GLIBMM_PROPERTIES_ENABLED
 787 Glib::PropertyProxy<bool> CellRendererText::property_language_set()
 788 {
 789   return Glib::PropertyProxy<bool>(this, "language-set");
 790 }
 791 #endif //GLIBMM_PROPERTIES_ENABLED
 792
 793 #ifdef GLIBMM_PROPERTIES_ENABLED
 794 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_language_set() const
 795 {
 796   return Glib::PropertyProxy_ReadOnly<bool>(this, "language-set");
 797 }
 798 #endif //GLIBMM_PROPERTIES_ENABLED
 799
 800 #ifdef GLIBMM_PROPERTIES_ENABLED
 801 Glib::PropertyProxy<bool> CellRendererText::property_ellipsize_set()
 802 {
 803   return Glib::PropertyProxy<bool>(this, "ellipsize-set");
 804 }
 805 #endif //GLIBMM_PROPERTIES_ENABLED
 806
 807 #ifdef GLIBMM_PROPERTIES_ENABLED
 808 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_ellipsize_set() const
 809 {
 810   return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize-set");
 811 }
 812 #endif //GLIBMM_PROPERTIES_ENABLED
 813
 814 #ifdef GLIBMM_PROPERTIES_ENABLED
 815 Glib::PropertyProxy<bool> CellRendererText::property_single_paragraph_mode()
 816 {
 817   return Glib::PropertyProxy<bool>(this, "single-paragraph-mode");
 818 }
 819 #endif //GLIBMM_PROPERTIES_ENABLED
 820
 821 #ifdef GLIBMM_PROPERTIES_ENABLED
 822 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_single_paragraph_mode() const
 823 {
 824   return Glib::PropertyProxy_ReadOnly<bool>(this, "single-paragraph-mode");
 825 }
 826 #endif //GLIBMM_PROPERTIES_ENABLED
 827
 828
 829 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 830 void Gtk::CellRendererText::on_edited(const Glib::ustring& path, const Glib::ustring& new_text)
 831 {
 832   BaseClassType *const base = static_cast<BaseClassType*>(
 833       g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 834   );
 835
 836   if(base && base->edited)
 837     (*base->edited)(gobj(),path.c_str(),new_text.c_str());
 838 }
 839 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 840
 841 #ifdef GLIBMM_VFUNCS_ENABLED
 842 #endif //GLIBMM_VFUNCS_ENABLED
 843
 844
 845 } // namespace Gtk
 846
 847