Pileus Git - ~andy/gtk/blob - gtk/gtkcellrenderertext.c

   1 /* gtkcellrenderertext.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkcellrenderertext.h"
  23
  24 #include <stdlib.h>
  25
  26 #include "gtkeditable.h"
  27 #include "gtkentry.h"
  28 #include "gtksizerequest.h"
  29 #include "gtkmarshalers.h"
  30 #include "gtkintl.h"
  31 #include "gtkprivate.h"
  32 #include "gtktreeprivate.h"
  33
  34
  35 /**
  36  * SECTION:gtkcellrenderertext
  37  * @Short_description: Renders text in a cell
  38  * @Title: GtkCellRendererText
  39  *
  40  * A #GtkCellRendererText renders a given text in its cell, using the font, color and
  41  * style information provided by its properties. The text will be ellipsized if it is
  42  * too long and the #GtkCellRendererText:ellipsize property allows it.
  43  *
  44  * If the #GtkCellRenderer:mode is %GTK_CELL_RENDERER_MODE_EDITABLE,
  45  * the #GtkCellRendererText allows to edit its text using an entry.
  46  */
  47
  48
  49 static void gtk_cell_renderer_text_finalize   (GObject                  *object);
  50
  51 static void gtk_cell_renderer_text_get_property  (GObject                  *object,
  52                                                   guint                     param_id,
  53                                                   GValue                   *value,
  54                                                   GParamSpec               *pspec);
  55 static void gtk_cell_renderer_text_set_property  (GObject                  *object,
  56                                                   guint                     param_id,
  57                                                   const GValue             *value,
  58                                                   GParamSpec               *pspec);
  59 static void gtk_cell_renderer_text_render     (GtkCellRenderer          *cell,
  60                                                cairo_t                  *cr,
  61                                                GtkWidget                *widget,
  62                                                const GdkRectangle       *background_area,
  63                                                const GdkRectangle       *cell_area,
  64                                                GtkCellRendererState      flags);
  65
  66 static GtkCellEditable *gtk_cell_renderer_text_start_editing (GtkCellRenderer      *cell,
  67                                                               GdkEvent             *event,
  68                                                               GtkWidget            *widget,
  69                                                               const gchar          *path,
  70                                                               const GdkRectangle   *background_area,
  71                                                               const GdkRectangle   *cell_area,
  72                                                               GtkCellRendererState  flags);
  73
  74 static void       gtk_cell_renderer_text_get_preferred_width            (GtkCellRenderer       *cell,
  75                                                                          GtkWidget             *widget,
  76                                                                          gint                  *minimal_size,
  77                                                                          gint                  *natural_size);
  78 static void       gtk_cell_renderer_text_get_preferred_height           (GtkCellRenderer       *cell,
  79                                                                          GtkWidget             *widget,
  80                                                                          gint                  *minimal_size,
  81                                                                          gint                  *natural_size);
  82 static void       gtk_cell_renderer_text_get_preferred_height_for_width (GtkCellRenderer       *cell,
  83                                                                          GtkWidget             *widget,
  84                                                                          gint                   width,
  85                                                                          gint                  *minimum_height,
  86                                                                          gint                  *natural_height);
  87 static void       gtk_cell_renderer_text_get_aligned_area               (GtkCellRenderer       *cell,
  88                                                                          GtkWidget             *widget,
  89                                                                          GtkCellRendererState   flags,
  90                                                                          const GdkRectangle    *cell_area,
  91                                                                          GdkRectangle          *aligned_area);
  92
  93
  94
  95 enum {
  96   EDITED,
  97   LAST_SIGNAL
  98 };
  99
 100 enum {
 101   PROP_0,
 102
 103   PROP_TEXT,
 104   PROP_MARKUP,
 105   PROP_ATTRIBUTES,
 106   PROP_SINGLE_PARAGRAPH_MODE,
 107   PROP_WIDTH_CHARS,
 108   PROP_MAX_WIDTH_CHARS,
 109   PROP_WRAP_WIDTH,
 110   PROP_ALIGN,
 111
 112   /* Style args */
 113   PROP_BACKGROUND,
 114   PROP_FOREGROUND,
 115   PROP_BACKGROUND_GDK,
 116   PROP_FOREGROUND_GDK,
 117   PROP_BACKGROUND_RGBA,
 118   PROP_FOREGROUND_RGBA,
 119   PROP_FONT,
 120   PROP_FONT_DESC,
 121   PROP_FAMILY,
 122   PROP_STYLE,
 123   PROP_VARIANT,
 124   PROP_WEIGHT,
 125   PROP_STRETCH,
 126   PROP_SIZE,
 127   PROP_SIZE_POINTS,
 128   PROP_SCALE,
 129   PROP_EDITABLE,
 130   PROP_STRIKETHROUGH,
 131   PROP_UNDERLINE,
 132   PROP_RISE,
 133   PROP_LANGUAGE,
 134   PROP_ELLIPSIZE,
 135   PROP_WRAP_MODE,
 136
 137   /* Whether-a-style-arg-is-set args */
 138   PROP_BACKGROUND_SET,
 139   PROP_FOREGROUND_SET,
 140   PROP_FAMILY_SET,
 141   PROP_STYLE_SET,
 142   PROP_VARIANT_SET,
 143   PROP_WEIGHT_SET,
 144   PROP_STRETCH_SET,
 145   PROP_SIZE_SET,
 146   PROP_SCALE_SET,
 147   PROP_EDITABLE_SET,
 148   PROP_STRIKETHROUGH_SET,
 149   PROP_UNDERLINE_SET,
 150   PROP_RISE_SET,
 151   PROP_LANGUAGE_SET,
 152   PROP_ELLIPSIZE_SET,
 153   PROP_ALIGN_SET
 154 };
 155
 156 static guint text_cell_renderer_signals [LAST_SIGNAL];
 157
 158 #define GTK_CELL_RENDERER_TEXT_PATH "gtk-cell-renderer-text-path"
 159
 160 struct _GtkCellRendererTextPrivate
 161 {
 162   GtkWidget *entry;
 163
 164   PangoAlignment        align;
 165   PangoAttrList        *extra_attrs;
 166   GdkRGBA               foreground;
 167   GdkRGBA               background;
 168   PangoEllipsizeMode    ellipsize;
 169   PangoFontDescription *font;
 170   PangoLanguage        *language;
 171   PangoUnderline        underline_style;
 172   PangoWrapMode         wrap_mode;
 173
 174   gboolean in_entry_menu;
 175
 176   gchar *text;
 177
 178   gdouble font_scale;
 179
 180   gint rise;
 181   gint fixed_height_rows;
 182   gint width_chars;
 183   gint max_width_chars;
 184   gint wrap_width;
 185
 186   guint strikethrough     : 1;
 187   guint editable          : 1;
 188   guint scale_set         : 1;
 189   guint foreground_set    : 1;
 190   guint background_set    : 1;
 191   guint underline_set     : 1;
 192   guint rise_set          : 1;
 193   guint strikethrough_set : 1;
 194   guint editable_set      : 1;
 195   guint calc_fixed_height : 1;
 196   guint single_paragraph  : 1;
 197   guint language_set      : 1;
 198   guint markup_set        : 1;
 199   guint ellipsize_set     : 1;
 200   guint align_set         : 1;
 201
 202   gulong focus_out_id;
 203   gulong populate_popup_id;
 204   gulong entry_menu_popdown_timeout;
 205 };
 206
 207 G_DEFINE_TYPE (GtkCellRendererText, gtk_cell_renderer_text, GTK_TYPE_CELL_RENDERER)
 208
 209 static void
 210 gtk_cell_renderer_text_init (GtkCellRendererText *celltext)
 211 {
 212   GtkCellRendererTextPrivate *priv;
 213   GtkCellRenderer *cell = GTK_CELL_RENDERER (celltext);
 214
 215   celltext->priv = G_TYPE_INSTANCE_GET_PRIVATE (celltext,
 216                                                 GTK_TYPE_CELL_RENDERER_TEXT,
 217                                                 GtkCellRendererTextPrivate);
 218   priv = celltext->priv;
 219
 220   gtk_cell_renderer_set_alignment (cell, 0.0, 0.5);
 221   gtk_cell_renderer_set_padding (cell, 2, 2);
 222   priv->font_scale = 1.0;
 223   priv->fixed_height_rows = -1;
 224   priv->font = pango_font_description_new ();
 225
 226   priv->width_chars = -1;
 227   priv->max_width_chars = -1;
 228   priv->wrap_width = -1;
 229   priv->wrap_mode = PANGO_WRAP_CHAR;
 230   priv->align = PANGO_ALIGN_LEFT;
 231   priv->align_set = FALSE;
 232 }
 233
 234 static void
 235 gtk_cell_renderer_text_class_init (GtkCellRendererTextClass *class)
 236 {
 237   GObjectClass *object_class = G_OBJECT_CLASS (class);
 238   GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
 239
 240   object_class->finalize = gtk_cell_renderer_text_finalize;
 241
 242   object_class->get_property = gtk_cell_renderer_text_get_property;
 243   object_class->set_property = gtk_cell_renderer_text_set_property;
 244
 245   cell_class->render = gtk_cell_renderer_text_render;
 246   cell_class->start_editing = gtk_cell_renderer_text_start_editing;
 247   cell_class->get_preferred_width = gtk_cell_renderer_text_get_preferred_width;
 248   cell_class->get_preferred_height = gtk_cell_renderer_text_get_preferred_height;
 249   cell_class->get_preferred_height_for_width = gtk_cell_renderer_text_get_preferred_height_for_width;
 250   cell_class->get_aligned_area = gtk_cell_renderer_text_get_aligned_area;
 251
 252   g_object_class_install_property (object_class,
 253                                    PROP_TEXT,
 254                                    g_param_spec_string ("text",
 255                                                         P_("Text"),
 256                                                         P_("Text to render"),
 257                                                         NULL,
 258                                                         GTK_PARAM_READWRITE));
 259
 260   g_object_class_install_property (object_class,
 261                                    PROP_MARKUP,
 262                                    g_param_spec_string ("markup",
 263                                                         P_("Markup"),
 264                                                         P_("Marked up text to render"),
 265                                                         NULL,
 266                                                         GTK_PARAM_WRITABLE));
 267
 268   g_object_class_install_property (object_class,
 269                                    PROP_ATTRIBUTES,
 270                                    g_param_spec_boxed ("attributes",
 271                                                        P_("Attributes"),
 272                                                        P_("A list of style attributes to apply to the text of the renderer"),
 273                                                        PANGO_TYPE_ATTR_LIST,
 274                                                        GTK_PARAM_READWRITE));
 275
 276   g_object_class_install_property (object_class,
 277                                    PROP_SINGLE_PARAGRAPH_MODE,
 278                                    g_param_spec_boolean ("single-paragraph-mode",
 279                                                          P_("Single Paragraph Mode"),
 280                                                          P_("Whether to keep all text in a single paragraph"),
 281                                                          FALSE,
 282                                                          GTK_PARAM_READWRITE));
 283
 284
 285   g_object_class_install_property (object_class,
 286                                    PROP_BACKGROUND,
 287                                    g_param_spec_string ("background",
 288                                                         P_("Background color name"),
 289                                                         P_("Background color as a string"),
 290                                                         NULL,
 291                                                         GTK_PARAM_WRITABLE));
 292
 293   g_object_class_install_property (object_class,
 294                                    PROP_BACKGROUND_GDK,
 295                                    g_param_spec_boxed ("background-gdk",
 296                                                        P_("Background color"),
 297                                                        P_("Background color as a GdkColor"),
 298                                                        GDK_TYPE_COLOR,
 299                                                        GTK_PARAM_READWRITE));
 300
 301   /**
 302    * GtkCellRendererText:background-rgba:
 303    *
 304    * Background color as a #GdkRGBA
 305    *
 306    * Since: 3.0
 307    */
 308   g_object_class_install_property (object_class,
 309                                    PROP_BACKGROUND_RGBA,
 310                                    g_param_spec_boxed ("background-rgba",
 311                                                        P_("Background color as RGBA"),
 312                                                        P_("Background color as a GdkRGBA"),
 313                                                        GDK_TYPE_RGBA,
 314                                                        GTK_PARAM_READWRITE));
 315   g_object_class_install_property (object_class,
 316                                    PROP_FOREGROUND,
 317                                    g_param_spec_string ("foreground",
 318                                                         P_("Foreground color name"),
 319                                                         P_("Foreground color as a string"),
 320                                                         NULL,
 321                                                         GTK_PARAM_WRITABLE));
 322
 323   g_object_class_install_property (object_class,
 324                                    PROP_FOREGROUND_GDK,
 325                                    g_param_spec_boxed ("foreground-gdk",
 326                                                        P_("Foreground color"),
 327                                                        P_("Foreground color as a GdkColor"),
 328                                                        GDK_TYPE_COLOR,
 329                                                        GTK_PARAM_READWRITE));
 330
 331   /**
 332    * GtkCellRendererText:foreground-rgba:
 333    *
 334    * Foreground color as a #GdkRGBA
 335    *
 336    * Since: 3.0
 337    */
 338   g_object_class_install_property (object_class,
 339                                    PROP_FOREGROUND_RGBA,
 340                                    g_param_spec_boxed ("foreground-rgba",
 341                                                        P_("Foreground color as RGBA"),
 342                                                        P_("Foreground color as a GdkRGBA"),
 343                                                        GDK_TYPE_RGBA,
 344                                                        GTK_PARAM_READWRITE));
 345
 346
 347   g_object_class_install_property (object_class,
 348                                    PROP_EDITABLE,
 349                                    g_param_spec_boolean ("editable",
 350                                                          P_("Editable"),
 351                                                          P_("Whether the text can be modified by the user"),
 352                                                          FALSE,
 353                                                          GTK_PARAM_READWRITE));
 354
 355   g_object_class_install_property (object_class,
 356                                    PROP_FONT,
 357                                    g_param_spec_string ("font",
 358                                                         P_("Font"),
 359                                                         P_("Font description as a string, e.g. \"Sans Italic 12\""),
 360                                                         NULL,
 361                                                         GTK_PARAM_READWRITE));
 362
 363   g_object_class_install_property (object_class,
 364                                    PROP_FONT_DESC,
 365                                    g_param_spec_boxed ("font-desc",
 366                                                        P_("Font"),
 367                                                        P_("Font description as a PangoFontDescription struct"),
 368                                                        PANGO_TYPE_FONT_DESCRIPTION,
 369                                                        GTK_PARAM_READWRITE));
 370
 371
 372   g_object_class_install_property (object_class,
 373                                    PROP_FAMILY,
 374                                    g_param_spec_string ("family",
 375                                                         P_("Font family"),
 376                                                         P_("Name of the font family, e.g. Sans, Helvetica, Times, Monospace"),
 377                                                         NULL,
 378                                                         GTK_PARAM_READWRITE));
 379
 380   g_object_class_install_property (object_class,
 381                                    PROP_STYLE,
 382                                    g_param_spec_enum ("style",
 383                                                       P_("Font style"),
 384                                                       P_("Font style"),
 385                                                       PANGO_TYPE_STYLE,
 386                                                       PANGO_STYLE_NORMAL,
 387                                                       GTK_PARAM_READWRITE));
 388
 389   g_object_class_install_property (object_class,
 390                                    PROP_VARIANT,
 391                                    g_param_spec_enum ("variant",
 392                                                      P_("Font variant"),
 393                                                      P_("Font variant"),
 394                                                       PANGO_TYPE_VARIANT,
 395                                                       PANGO_VARIANT_NORMAL,
 396                                                       GTK_PARAM_READWRITE));
 397
 398   g_object_class_install_property (object_class,
 399                                    PROP_WEIGHT,
 400                                    g_param_spec_int ("weight",
 401                                                      P_("Font weight"),
 402                                                      P_("Font weight"),
 403                                                      0,
 404                                                      G_MAXINT,
 405                                                      PANGO_WEIGHT_NORMAL,
 406                                                      GTK_PARAM_READWRITE));
 407
 408    g_object_class_install_property (object_class,
 409                                    PROP_STRETCH,
 410                                    g_param_spec_enum ("stretch",
 411                                                       P_("Font stretch"),
 412                                                       P_("Font stretch"),
 413                                                       PANGO_TYPE_STRETCH,
 414                                                       PANGO_STRETCH_NORMAL,
 415                                                       GTK_PARAM_READWRITE));
 416
 417   g_object_class_install_property (object_class,
 418                                    PROP_SIZE,
 419                                    g_param_spec_int ("size",
 420                                                      P_("Font size"),
 421                                                      P_("Font size"),
 422                                                      0,
 423                                                      G_MAXINT,
 424                                                      0,
 425                                                      GTK_PARAM_READWRITE));
 426
 427   g_object_class_install_property (object_class,
 428                                    PROP_SIZE_POINTS,
 429                                    g_param_spec_double ("size-points",
 430                                                         P_("Font points"),
 431                                                         P_("Font size in points"),
 432                                                         0.0,
 433                                                         G_MAXDOUBLE,
 434                                                         0.0,
 435                                                         GTK_PARAM_READWRITE));
 436
 437   g_object_class_install_property (object_class,
 438                                    PROP_SCALE,
 439                                    g_param_spec_double ("scale",
 440                                                         P_("Font scale"),
 441                                                         P_("Font scaling factor"),
 442                                                         0.0,
 443                                                         G_MAXDOUBLE,
 444                                                         1.0,
 445                                                         GTK_PARAM_READWRITE));
 446
 447   g_object_class_install_property (object_class,
 448                                    PROP_RISE,
 449                                    g_param_spec_int ("rise",
 450                                                      P_("Rise"),
 451                                                      P_("Offset of text above the baseline "
 452                                                         "(below the baseline if rise is negative)"),
 453                                                      -G_MAXINT,
 454                                                      G_MAXINT,
 455                                                      0,
 456                                                      GTK_PARAM_READWRITE));
 457
 458
 459   g_object_class_install_property (object_class,
 460                                    PROP_STRIKETHROUGH,
 461                                    g_param_spec_boolean ("strikethrough",
 462                                                          P_("Strikethrough"),
 463                                                          P_("Whether to strike through the text"),
 464                                                          FALSE,
 465                                                          GTK_PARAM_READWRITE));
 466
 467   g_object_class_install_property (object_class,
 468                                    PROP_UNDERLINE,
 469                                    g_param_spec_enum ("underline",
 470                                                       P_("Underline"),
 471                                                       P_("Style of underline for this text"),
 472                                                       PANGO_TYPE_UNDERLINE,
 473                                                       PANGO_UNDERLINE_NONE,
 474                                                       GTK_PARAM_READWRITE));
 475
 476   g_object_class_install_property (object_class,
 477                                    PROP_LANGUAGE,
 478                                    g_param_spec_string ("language",
 479                                                         P_("Language"),
 480                                                         P_("The language this text is in, as an ISO code. "
 481                                                            "Pango can use this as a hint when rendering the text. "
 482                                                            "If you don't understand this parameter, you probably don't need it"),
 483                                                         NULL,
 484                                                         GTK_PARAM_READWRITE));
 485
 486
 487   /**
 488    * GtkCellRendererText:ellipsize:
 489    *
 490    * Specifies the preferred place to ellipsize the string, if the cell renderer
 491    * does not have enough room to display the entire string. Setting it to
 492    * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
 493    * for another way of making the text fit into a given width.
 494    *
 495    * Since: 2.6
 496    */
 497   g_object_class_install_property (object_class,
 498                                    PROP_ELLIPSIZE,
 499                                    g_param_spec_enum ("ellipsize",
 500                                                       P_("Ellipsize"),
 501                                                       P_("The preferred place to ellipsize the string, "
 502                                                          "if the cell renderer does not have enough room "
 503                                                          "to display the entire string"),
 504                                                       PANGO_TYPE_ELLIPSIZE_MODE,
 505                                                       PANGO_ELLIPSIZE_NONE,
 506                                                       GTK_PARAM_READWRITE));
 507
 508   /**
 509    * GtkCellRendererText:width-chars:
 510    *
 511    * The desired width of the cell, in characters. If this property is set to
 512    * -1, the width will be calculated automatically, otherwise the cell will
 513    * request either 3 characters or the property value, whichever is greater.
 514    *
 515    * Since: 2.6
 516    **/
 517   g_object_class_install_property (object_class,
 518                                    PROP_WIDTH_CHARS,
 519                                    g_param_spec_int ("width-chars",
 520                                                      P_("Width In Characters"),
 521                                                      P_("The desired width of the label, in characters"),
 522                                                      -1,
 523                                                      G_MAXINT,
 524                                                      -1,
 525                                                      GTK_PARAM_READWRITE));
 526
 527
 528   /**
 529    * GtkCellRendererText:max-width-chars:
 530    *
 531    * The desired maximum width of the cell, in characters. If this property
 532    * is set to -1, the width will be calculated automatically.
 533    *
 534    * For cell renderers that ellipsize or wrap text; this property
 535    * controls the maximum reported width of the cell. The
 536    * cell should not receive any greater allocation unless it is
 537    * set to expand in its #GtkCellLayout and all of the cell's siblings
 538    * have received their natural width.
 539    *
 540    * Since: 3.0
 541    **/
 542   g_object_class_install_property (object_class,
 543                                    PROP_MAX_WIDTH_CHARS,
 544                                    g_param_spec_int ("max-width-chars",
 545                                                      P_("Maximum Width In Characters"),
 546                                                      P_("The maximum width of the cell, in characters"),
 547                                                      -1,
 548                                                      G_MAXINT,
 549                                                      -1,
 550                                                      GTK_PARAM_READWRITE));
 551
 552   /**
 553    * GtkCellRendererText:wrap-mode:
 554    *
 555    * Specifies how to break the string into multiple lines, if the cell
 556    * renderer does not have enough room to display the entire string.
 557    * This property has no effect unless the wrap-width property is set.
 558    *
 559    * Since: 2.8
 560    */
 561   g_object_class_install_property (object_class,
 562                                    PROP_WRAP_MODE,
 563                                    g_param_spec_enum ("wrap-mode",
 564                                                       P_("Wrap mode"),
 565                                                       P_("How to break the string into multiple lines, "
 566                                                          "if the cell renderer does not have enough room "
 567                                                          "to display the entire string"),
 568                                                       PANGO_TYPE_WRAP_MODE,
 569                                                       PANGO_WRAP_CHAR,
 570                                                       GTK_PARAM_READWRITE));
 571
 572   /**
 573    * GtkCellRendererText:wrap-width:
 574    *
 575    * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
 576    * be used to influence at what character positions the line breaks can be placed.
 577    * Setting wrap-width to -1 turns wrapping off.
 578    *
 579    * Since: 2.8
 580    */
 581   g_object_class_install_property (object_class,
 582                                    PROP_WRAP_WIDTH,
 583                                    g_param_spec_int ("wrap-width",
 584                                                      P_("Wrap width"),
 585                                                      P_("The width at which the text is wrapped"),
 586                                                      -1,
 587                                                      G_MAXINT,
 588                                                      -1,
 589                                                      GTK_PARAM_READWRITE));
 590
 591   /**
 592    * GtkCellRendererText:alignment:
 593    *
 594    * Specifies how to align the lines of text with respect to each other.
 595    *
 596    * Note that this property describes how to align the lines of text in
 597    * case there are several of them. The "xalign" property of #GtkCellRenderer,
 598    * on the other hand, sets the horizontal alignment of the whole text.
 599    *
 600    * Since: 2.10
 601    */
 602   g_object_class_install_property (object_class,
 603                                    PROP_ALIGN,
 604                                    g_param_spec_enum ("alignment",
 605                                                       P_("Alignment"),
 606                                                       P_("How to align the lines"),
 607                                                       PANGO_TYPE_ALIGNMENT,
 608                                                       PANGO_ALIGN_LEFT,
 609                                                       GTK_PARAM_READWRITE));
 610
 611
 612
 613   /* Style props are set or not */
 614
 615 #define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
 616
 617   ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
 618                 P_("Background set"),
 619                 P_("Whether this tag affects the background color"));
 620
 621   ADD_SET_PROP ("foreground-set", PROP_FOREGROUND_SET,
 622                 P_("Foreground set"),
 623                 P_("Whether this tag affects the foreground color"));
 624
 625   ADD_SET_PROP ("editable-set", PROP_EDITABLE_SET,
 626                 P_("Editability set"),
 627                 P_("Whether this tag affects text editability"));
 628
 629   ADD_SET_PROP ("family-set", PROP_FAMILY_SET,
 630                 P_("Font family set"),
 631                 P_("Whether this tag affects the font family"));
 632
 633   ADD_SET_PROP ("style-set", PROP_STYLE_SET,
 634                 P_("Font style set"),
 635                 P_("Whether this tag affects the font style"));
 636
 637   ADD_SET_PROP ("variant-set", PROP_VARIANT_SET,
 638                 P_("Font variant set"),
 639                 P_("Whether this tag affects the font variant"));
 640
 641   ADD_SET_PROP ("weight-set", PROP_WEIGHT_SET,
 642                 P_("Font weight set"),
 643                 P_("Whether this tag affects the font weight"));
 644
 645   ADD_SET_PROP ("stretch-set", PROP_STRETCH_SET,
 646                 P_("Font stretch set"),
 647                 P_("Whether this tag affects the font stretch"));
 648
 649   ADD_SET_PROP ("size-set", PROP_SIZE_SET,
 650                 P_("Font size set"),
 651                 P_("Whether this tag affects the font size"));
 652
 653   ADD_SET_PROP ("scale-set", PROP_SCALE_SET,
 654                 P_("Font scale set"),
 655                 P_("Whether this tag scales the font size by a factor"));
 656
 657   ADD_SET_PROP ("rise-set", PROP_RISE_SET,
 658                 P_("Rise set"),
 659                 P_("Whether this tag affects the rise"));
 660
 661   ADD_SET_PROP ("strikethrough-set", PROP_STRIKETHROUGH_SET,
 662                 P_("Strikethrough set"),
 663                 P_("Whether this tag affects strikethrough"));
 664
 665   ADD_SET_PROP ("underline-set", PROP_UNDERLINE_SET,
 666                 P_("Underline set"),
 667                 P_("Whether this tag affects underlining"));
 668
 669   ADD_SET_PROP ("language-set", PROP_LANGUAGE_SET,
 670                 P_("Language set"),
 671                 P_("Whether this tag affects the language the text is rendered as"));
 672
 673   ADD_SET_PROP ("ellipsize-set", PROP_ELLIPSIZE_SET,
 674                 P_("Ellipsize set"),
 675                 P_("Whether this tag affects the ellipsize mode"));
 676
 677   ADD_SET_PROP ("align-set", PROP_ALIGN_SET,
 678                 P_("Align set"),
 679                 P_("Whether this tag affects the alignment mode"));
 680
 681   /**
 682    * GtkCellRendererText::edited
 683    * @renderer: the object which received the signal
 684    * @path: the path identifying the edited cell
 685    * @new_text: the new text
 686    *
 687    * This signal is emitted after @renderer has been edited.
 688    *
 689    * It is the responsibility of the application to update the model
 690    * and store @new_text at the position indicated by @path.
 691    */
 692   text_cell_renderer_signals [EDITED] =
 693     g_signal_new (I_("edited"),
 694                   G_OBJECT_CLASS_TYPE (object_class),
 695                   G_SIGNAL_RUN_LAST,
 696                   G_STRUCT_OFFSET (GtkCellRendererTextClass, edited),
 697                   NULL, NULL,
 698                   _gtk_marshal_VOID__STRING_STRING,
 699                   G_TYPE_NONE, 2,
 700                   G_TYPE_STRING,
 701                   G_TYPE_STRING);
 702
 703   g_type_class_add_private (object_class, sizeof (GtkCellRendererTextPrivate));
 704 }
 705
 706 static void
 707 gtk_cell_renderer_text_finalize (GObject *object)
 708 {
 709   GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);
 710   GtkCellRendererTextPrivate *priv = celltext->priv;
 711
 712   pango_font_description_free (priv->font);
 713
 714   g_free (priv->text);
 715
 716   if (priv->extra_attrs)
 717     pango_attr_list_unref (priv->extra_attrs);
 718
 719   if (priv->language)
 720     g_object_unref (priv->language);
 721
 722   G_OBJECT_CLASS (gtk_cell_renderer_text_parent_class)->finalize (object);
 723 }
 724
 725 static PangoFontMask
 726 get_property_font_set_mask (guint prop_id)
 727 {
 728   switch (prop_id)
 729     {
 730     case PROP_FAMILY_SET:
 731       return PANGO_FONT_MASK_FAMILY;
 732     case PROP_STYLE_SET:
 733       return PANGO_FONT_MASK_STYLE;
 734     case PROP_VARIANT_SET:
 735       return PANGO_FONT_MASK_VARIANT;
 736     case PROP_WEIGHT_SET:
 737       return PANGO_FONT_MASK_WEIGHT;
 738     case PROP_STRETCH_SET:
 739       return PANGO_FONT_MASK_STRETCH;
 740     case PROP_SIZE_SET:
 741       return PANGO_FONT_MASK_SIZE;
 742     }
 743
 744   return 0;
 745 }
 746
 747 static void
 748 gtk_cell_renderer_text_get_property (GObject        *object,
 749                                      guint           param_id,
 750                                      GValue         *value,
 751                                      GParamSpec     *pspec)
 752 {
 753   GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);
 754   GtkCellRendererTextPrivate *priv = celltext->priv;
 755
 756   switch (param_id)
 757     {
 758     case PROP_TEXT:
 759       g_value_set_string (value, priv->text);
 760       break;
 761
 762     case PROP_ATTRIBUTES:
 763       g_value_set_boxed (value, priv->extra_attrs);
 764       break;
 765
 766     case PROP_SINGLE_PARAGRAPH_MODE:
 767       g_value_set_boolean (value, priv->single_paragraph);
 768       break;
 769
 770     case PROP_BACKGROUND_GDK:
 771       {
 772         GdkColor color;
 773
 774         color.red = (guint16) (priv->background.red * 65535);
 775         color.green = (guint16) (priv->background.green * 65535);
 776         color.blue = (guint16) (priv->background.blue * 65535);
 777
 778         g_value_set_boxed (value, &color);
 779       }
 780       break;
 781
 782     case PROP_FOREGROUND_GDK:
 783       {
 784         GdkColor color;
 785
 786         color.red = (guint16) (priv->foreground.red * 65535);
 787         color.green = (guint16) (priv->foreground.green * 65535);
 788         color.blue = (guint16) (priv->foreground.blue * 65535);
 789
 790         g_value_set_boxed (value, &color);
 791       }
 792       break;
 793
 794     case PROP_BACKGROUND_RGBA:
 795       g_value_set_boxed (value, &priv->background);
 796       break;
 797
 798     case PROP_FOREGROUND_RGBA:
 799       g_value_set_boxed (value, &priv->foreground);
 800       break;
 801
 802     case PROP_FONT:
 803         g_value_take_string (value, pango_font_description_to_string (priv->font));
 804       break;
 805
 806     case PROP_FONT_DESC:
 807       g_value_set_boxed (value, priv->font);
 808       break;
 809
 810     case PROP_FAMILY:
 811       g_value_set_string (value, pango_font_description_get_family (priv->font));
 812       break;
 813
 814     case PROP_STYLE:
 815       g_value_set_enum (value, pango_font_description_get_style (priv->font));
 816       break;
 817
 818     case PROP_VARIANT:
 819       g_value_set_enum (value, pango_font_description_get_variant (priv->font));
 820       break;
 821
 822     case PROP_WEIGHT:
 823       g_value_set_int (value, pango_font_description_get_weight (priv->font));
 824       break;
 825
 826     case PROP_STRETCH:
 827       g_value_set_enum (value, pango_font_description_get_stretch (priv->font));
 828       break;
 829
 830     case PROP_SIZE:
 831       g_value_set_int (value, pango_font_description_get_size (priv->font));
 832       break;
 833
 834     case PROP_SIZE_POINTS:
 835       g_value_set_double (value, ((double)pango_font_description_get_size (priv->font)) / (double)PANGO_SCALE);
 836       break;
 837
 838     case PROP_SCALE:
 839       g_value_set_double (value, priv->font_scale);
 840       break;
 841
 842     case PROP_EDITABLE:
 843       g_value_set_boolean (value, priv->editable);
 844       break;
 845
 846     case PROP_STRIKETHROUGH:
 847       g_value_set_boolean (value, priv->strikethrough);
 848       break;
 849
 850     case PROP_UNDERLINE:
 851       g_value_set_enum (value, priv->underline_style);
 852       break;
 853
 854     case PROP_RISE:
 855       g_value_set_int (value, priv->rise);
 856       break;
 857
 858     case PROP_LANGUAGE:
 859       g_value_set_static_string (value, pango_language_to_string (priv->language));
 860       break;
 861
 862     case PROP_ELLIPSIZE:
 863       g_value_set_enum (value, priv->ellipsize);
 864       break;
 865
 866     case PROP_WRAP_MODE:
 867       g_value_set_enum (value, priv->wrap_mode);
 868       break;
 869
 870     case PROP_WRAP_WIDTH:
 871       g_value_set_int (value, priv->wrap_width);
 872       break;
 873
 874     case PROP_ALIGN:
 875       g_value_set_enum (value, priv->align);
 876       break;
 877
 878     case PROP_BACKGROUND_SET:
 879       g_value_set_boolean (value, priv->background_set);
 880       break;
 881
 882     case PROP_FOREGROUND_SET:
 883       g_value_set_boolean (value, priv->foreground_set);
 884       break;
 885
 886     case PROP_FAMILY_SET:
 887     case PROP_STYLE_SET:
 888     case PROP_VARIANT_SET:
 889     case PROP_WEIGHT_SET:
 890     case PROP_STRETCH_SET:
 891     case PROP_SIZE_SET:
 892       {
 893         PangoFontMask mask = get_property_font_set_mask (param_id);
 894         g_value_set_boolean (value, (pango_font_description_get_set_fields (priv->font) & mask) != 0);
 895
 896         break;
 897       }
 898
 899     case PROP_SCALE_SET:
 900       g_value_set_boolean (value, priv->scale_set);
 901       break;
 902
 903     case PROP_EDITABLE_SET:
 904       g_value_set_boolean (value, priv->editable_set);
 905       break;
 906
 907     case PROP_STRIKETHROUGH_SET:
 908       g_value_set_boolean (value, priv->strikethrough_set);
 909       break;
 910
 911     case PROP_UNDERLINE_SET:
 912       g_value_set_boolean (value, priv->underline_set);
 913       break;
 914
 915     case  PROP_RISE_SET:
 916       g_value_set_boolean (value, priv->rise_set);
 917       break;
 918
 919     case PROP_LANGUAGE_SET:
 920       g_value_set_boolean (value, priv->language_set);
 921       break;
 922
 923     case PROP_ELLIPSIZE_SET:
 924       g_value_set_boolean (value, priv->ellipsize_set);
 925       break;
 926
 927     case PROP_ALIGN_SET:
 928       g_value_set_boolean (value, priv->align_set);
 929       break;
 930
 931     case PROP_WIDTH_CHARS:
 932       g_value_set_int (value, priv->width_chars);
 933       break;
 934
 935     case PROP_MAX_WIDTH_CHARS:
 936       g_value_set_int (value, priv->max_width_chars);
 937       break;
 938
 939     case PROP_BACKGROUND:
 940     case PROP_FOREGROUND:
 941     case PROP_MARKUP:
 942     default:
 943       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 944       break;
 945     }
 946 }
 947
 948
 949 static void
 950 set_bg_color (GtkCellRendererText *celltext,
 951               GdkRGBA             *rgba)
 952 {
 953   GtkCellRendererTextPrivate *priv = celltext->priv;
 954
 955   if (rgba)
 956     {
 957       if (!priv->background_set)
 958         {
 959           priv->background_set = TRUE;
 960           g_object_notify (G_OBJECT (celltext), "background-set");
 961         }
 962
 963       priv->background = *rgba;
 964     }
 965   else
 966     {
 967       if (priv->background_set)
 968         {
 969           priv->background_set = FALSE;
 970           g_object_notify (G_OBJECT (celltext), "background-set");
 971         }
 972     }
 973 }
 974
 975
 976 static void
 977 set_fg_color (GtkCellRendererText *celltext,
 978               GdkRGBA             *rgba)
 979 {
 980   GtkCellRendererTextPrivate *priv = celltext->priv;
 981
 982   if (rgba)
 983     {
 984       if (!priv->foreground_set)
 985         {
 986           priv->foreground_set = TRUE;
 987           g_object_notify (G_OBJECT (celltext), "foreground-set");
 988         }
 989
 990       priv->foreground = *rgba;
 991     }
 992   else
 993     {
 994       if (priv->foreground_set)
 995         {
 996           priv->foreground_set = FALSE;
 997           g_object_notify (G_OBJECT (celltext), "foreground-set");
 998         }
 999     }
1000 }
1001
1002 static PangoFontMask
1003 set_font_desc_fields (PangoFontDescription *desc,
1004                       PangoFontMask         to_set)
1005 {
1006   PangoFontMask changed_mask = 0;
1007
1008   if (to_set & PANGO_FONT_MASK_FAMILY)
1009     {
1010       const char *family = pango_font_description_get_family (desc);
1011       if (!family)
1012         {
1013           family = "sans";
1014           changed_mask |= PANGO_FONT_MASK_FAMILY;
1015         }
1016
1017       pango_font_description_set_family (desc, family);
1018     }
1019   if (to_set & PANGO_FONT_MASK_STYLE)
1020     pango_font_description_set_style (desc, pango_font_description_get_style (desc));
1021   if (to_set & PANGO_FONT_MASK_VARIANT)
1022     pango_font_description_set_variant (desc, pango_font_description_get_variant (desc));
1023   if (to_set & PANGO_FONT_MASK_WEIGHT)
1024     pango_font_description_set_weight (desc, pango_font_description_get_weight (desc));
1025   if (to_set & PANGO_FONT_MASK_STRETCH)
1026     pango_font_description_set_stretch (desc, pango_font_description_get_stretch (desc));
1027   if (to_set & PANGO_FONT_MASK_SIZE)
1028     {
1029       gint size = pango_font_description_get_size (desc);
1030       if (size <= 0)
1031         {
1032           size = 10 * PANGO_SCALE;
1033           changed_mask |= PANGO_FONT_MASK_SIZE;
1034         }
1035
1036       pango_font_description_set_size (desc, size);
1037     }
1038
1039   return changed_mask;
1040 }
1041
1042 static void
1043 notify_set_changed (GObject       *object,
1044                     PangoFontMask  changed_mask)
1045 {
1046   if (changed_mask & PANGO_FONT_MASK_FAMILY)
1047     g_object_notify (object, "family-set");
1048   if (changed_mask & PANGO_FONT_MASK_STYLE)
1049     g_object_notify (object, "style-set");
1050   if (changed_mask & PANGO_FONT_MASK_VARIANT)
1051     g_object_notify (object, "variant-set");
1052   if (changed_mask & PANGO_FONT_MASK_WEIGHT)
1053     g_object_notify (object, "weight-set");
1054   if (changed_mask & PANGO_FONT_MASK_STRETCH)
1055     g_object_notify (object, "stretch-set");
1056   if (changed_mask & PANGO_FONT_MASK_SIZE)
1057     g_object_notify (object, "size-set");
1058 }
1059
1060 static void
1061 notify_fields_changed (GObject       *object,
1062                        PangoFontMask  changed_mask)
1063 {
1064   if (changed_mask & PANGO_FONT_MASK_FAMILY)
1065     g_object_notify (object, "family");
1066   if (changed_mask & PANGO_FONT_MASK_STYLE)
1067     g_object_notify (object, "style");
1068   if (changed_mask & PANGO_FONT_MASK_VARIANT)
1069     g_object_notify (object, "variant");
1070   if (changed_mask & PANGO_FONT_MASK_WEIGHT)
1071     g_object_notify (object, "weight");
1072   if (changed_mask & PANGO_FONT_MASK_STRETCH)
1073     g_object_notify (object, "stretch");
1074   if (changed_mask & PANGO_FONT_MASK_SIZE)
1075     g_object_notify (object, "size");
1076 }
1077
1078 static void
1079 set_font_description (GtkCellRendererText  *celltext,
1080                       PangoFontDescription *font_desc)
1081 {
1082   GtkCellRendererTextPrivate *priv = celltext->priv;
1083   GObject *object = G_OBJECT (celltext);
1084   PangoFontDescription *new_font_desc;
1085   PangoFontMask old_mask, new_mask, changed_mask, set_changed_mask;
1086
1087   if (font_desc)
1088     new_font_desc = pango_font_description_copy (font_desc);
1089   else
1090     new_font_desc = pango_font_description_new ();
1091
1092   old_mask = pango_font_description_get_set_fields (priv->font);
1093   new_mask = pango_font_description_get_set_fields (new_font_desc);
1094
1095   changed_mask = old_mask | new_mask;
1096   set_changed_mask = old_mask ^ new_mask;
1097
1098   pango_font_description_free (priv->font);
1099   priv->font = new_font_desc;
1100
1101   g_object_freeze_notify (object);
1102
1103   g_object_notify (object, "font-desc");
1104   g_object_notify (object, "font");
1105
1106   if (changed_mask & PANGO_FONT_MASK_FAMILY)
1107     g_object_notify (object, "family");
1108   if (changed_mask & PANGO_FONT_MASK_STYLE)
1109     g_object_notify (object, "style");
1110   if (changed_mask & PANGO_FONT_MASK_VARIANT)
1111     g_object_notify (object, "variant");
1112   if (changed_mask & PANGO_FONT_MASK_WEIGHT)
1113     g_object_notify (object, "weight");
1114   if (changed_mask & PANGO_FONT_MASK_STRETCH)
1115     g_object_notify (object, "stretch");
1116   if (changed_mask & PANGO_FONT_MASK_SIZE)
1117     {
1118       g_object_notify (object, "size");
1119       g_object_notify (object, "size-points");
1120     }
1121
1122   notify_set_changed (object, set_changed_mask);
1123
1124   g_object_thaw_notify (object);
1125 }
1126
1127 static void
1128 gtk_cell_renderer_text_set_property (GObject      *object,
1129                                      guint         param_id,
1130                                      const GValue *value,
1131                                      GParamSpec   *pspec)
1132 {
1133   GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);
1134   GtkCellRendererTextPrivate *priv = celltext->priv;
1135
1136   switch (param_id)
1137     {
1138     case PROP_TEXT:
1139       g_free (priv->text);
1140
1141       if (priv->markup_set)
1142         {
1143           if (priv->extra_attrs)
1144             pango_attr_list_unref (priv->extra_attrs);
1145           priv->extra_attrs = NULL;
1146           priv->markup_set = FALSE;
1147         }
1148
1149       priv->text = g_value_dup_string (value);
1150       g_object_notify (object, "text");
1151       break;
1152
1153     case PROP_ATTRIBUTES:
1154       if (priv->extra_attrs)
1155         pango_attr_list_unref (priv->extra_attrs);
1156
1157       priv->extra_attrs = g_value_get_boxed (value);
1158       if (priv->extra_attrs)
1159         pango_attr_list_ref (priv->extra_attrs);
1160       break;
1161     case PROP_MARKUP:
1162       {
1163         const gchar *str;
1164         gchar *text = NULL;
1165         GError *error = NULL;
1166         PangoAttrList *attrs = NULL;
1167
1168         str = g_value_get_string (value);
1169         if (str && !pango_parse_markup (str,
1170                                         -1,
1171                                         0,
1172                                         &attrs,
1173                                         &text,
1174                                         NULL,
1175                                         &error))
1176           {
1177             g_warning ("Failed to set text from markup due to error parsing markup: %s",
1178                        error->message);
1179             g_error_free (error);
1180             return;
1181           }
1182
1183         g_free (priv->text);
1184
1185         if (priv->extra_attrs)
1186           pango_attr_list_unref (priv->extra_attrs);
1187
1188         priv->text = text;
1189         priv->extra_attrs = attrs;
1190         priv->markup_set = TRUE;
1191       }
1192       break;
1193
1194     case PROP_SINGLE_PARAGRAPH_MODE:
1195       priv->single_paragraph = g_value_get_boolean (value);
1196       break;
1197
1198     case PROP_BACKGROUND:
1199       {
1200         GdkRGBA rgba;
1201
1202         if (!g_value_get_string (value))
1203           set_bg_color (celltext, NULL);       /* reset to background_set to FALSE */
1204         else if (gdk_rgba_parse (g_value_get_string (value), &rgba))
1205           set_bg_color (celltext, &rgba);
1206         else
1207           g_warning ("Don't know color `%s'", g_value_get_string (value));
1208
1209         g_object_notify (object, "background-gdk");
1210       }
1211       break;
1212
1213     case PROP_FOREGROUND:
1214       {
1215         GdkRGBA rgba;
1216
1217         if (!g_value_get_string (value))
1218           set_fg_color (celltext, NULL);       /* reset to foreground_set to FALSE */
1219         else if (gdk_rgba_parse (g_value_get_string (value), &rgba))
1220           set_fg_color (celltext, &rgba);
1221         else
1222           g_warning ("Don't know color `%s'", g_value_get_string (value));
1223
1224         g_object_notify (object, "foreground-gdk");
1225       }
1226       break;
1227
1228     case PROP_BACKGROUND_GDK:
1229       {
1230         GdkColor *color;
1231
1232         color = g_value_get_boxed (value);
1233         if (color)
1234           {
1235             GdkRGBA rgba;
1236
1237             rgba.red = color->red / 65535.;
1238             rgba.green = color->green / 65535.;
1239             rgba.blue = color->blue / 65535.;
1240             rgba.alpha = 1;
1241
1242             set_bg_color (celltext, &rgba);
1243           }
1244         else
1245           {
1246             set_bg_color (celltext, NULL);
1247           }
1248       }
1249       break;
1250
1251     case PROP_FOREGROUND_GDK:
1252       {
1253         GdkColor *color;
1254
1255         color = g_value_get_boxed (value);
1256         if (color)
1257           {
1258             GdkRGBA rgba;
1259
1260             rgba.red = color->red / 65535.;
1261             rgba.green = color->green / 65535.;
1262             rgba.blue = color->blue / 65535.;
1263             rgba.alpha = 1;
1264
1265             set_fg_color (celltext, &rgba);
1266           }
1267         else
1268           {
1269             set_fg_color (celltext, NULL);
1270           }
1271       }
1272       break;
1273
1274     case PROP_BACKGROUND_RGBA:
1275       /* This notifies the GObject itself. */
1276       set_bg_color (celltext, g_value_get_boxed (value));
1277       break;
1278
1279     case PROP_FOREGROUND_RGBA:
1280       /* This notifies the GObject itself. */
1281       set_fg_color (celltext, g_value_get_boxed (value));
1282       break;
1283
1284     case PROP_FONT:
1285       {
1286         PangoFontDescription *font_desc = NULL;
1287         const gchar *name;
1288
1289         name = g_value_get_string (value);
1290
1291         if (name)
1292           font_desc = pango_font_description_from_string (name);
1293
1294         set_font_description (celltext, font_desc);
1295
1296         pango_font_description_free (font_desc);
1297
1298         if (priv->fixed_height_rows != -1)
1299           priv->calc_fixed_height = TRUE;
1300       }
1301       break;
1302
1303     case PROP_FONT_DESC:
1304       set_font_description (celltext, g_value_get_boxed (value));
1305
1306       if (priv->fixed_height_rows != -1)
1307         priv->calc_fixed_height = TRUE;
1308       break;
1309
1310     case PROP_FAMILY:
1311     case PROP_STYLE:
1312     case PROP_VARIANT:
1313     case PROP_WEIGHT:
1314     case PROP_STRETCH:
1315     case PROP_SIZE:
1316     case PROP_SIZE_POINTS:
1317       {
1318         PangoFontMask old_set_mask = pango_font_description_get_set_fields (priv->font);
1319
1320         switch (param_id)
1321           {
1322           case PROP_FAMILY:
1323             pango_font_description_set_family (priv->font,
1324                                                g_value_get_string (value));
1325             break;
1326           case PROP_STYLE:
1327             pango_font_description_set_style (priv->font,
1328                                               g_value_get_enum (value));
1329             break;
1330           case PROP_VARIANT:
1331             pango_font_description_set_variant (priv->font,
1332                                                 g_value_get_enum (value));
1333             break;
1334           case PROP_WEIGHT:
1335             pango_font_description_set_weight (priv->font,
1336                                                g_value_get_int (value));
1337             break;
1338           case PROP_STRETCH:
1339             pango_font_description_set_stretch (priv->font,
1340                                                 g_value_get_enum (value));
1341             break;
1342           case PROP_SIZE:
1343             pango_font_description_set_size (priv->font,
1344                                              g_value_get_int (value));
1345             g_object_notify (object, "size-points");
1346             break;
1347           case PROP_SIZE_POINTS:
1348             pango_font_description_set_size (priv->font,
1349                                              g_value_get_double (value) * PANGO_SCALE);
1350             g_object_notify (object, "size");
1351             break;
1352           }
1353
1354         if (priv->fixed_height_rows != -1)
1355           priv->calc_fixed_height = TRUE;
1356
1357         notify_set_changed (object, old_set_mask & pango_font_description_get_set_fields (priv->font));
1358         g_object_notify (object, "font-desc");
1359         g_object_notify (object, "font");
1360
1361         break;
1362       }
1363
1364     case PROP_SCALE:
1365       priv->font_scale = g_value_get_double (value);
1366       priv->scale_set = TRUE;
1367       if (priv->fixed_height_rows != -1)
1368         priv->calc_fixed_height = TRUE;
1369       g_object_notify (object, "scale-set");
1370       break;
1371
1372     case PROP_EDITABLE:
1373       priv->editable = g_value_get_boolean (value);
1374       priv->editable_set = TRUE;
1375       if (priv->editable)
1376         g_object_set (celltext, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
1377       else
1378         g_object_set (celltext, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
1379       g_object_notify (object, "editable-set");
1380       break;
1381
1382     case PROP_STRIKETHROUGH:
1383       priv->strikethrough = g_value_get_boolean (value);
1384       priv->strikethrough_set = TRUE;
1385       g_object_notify (object, "strikethrough-set");
1386       break;
1387
1388     case PROP_UNDERLINE:
1389       priv->underline_style = g_value_get_enum (value);
1390       priv->underline_set = TRUE;
1391       g_object_notify (object, "underline-set");
1392
1393       break;
1394
1395     case PROP_RISE:
1396       priv->rise = g_value_get_int (value);
1397       priv->rise_set = TRUE;
1398       g_object_notify (object, "rise-set");
1399       if (priv->fixed_height_rows != -1)
1400         priv->calc_fixed_height = TRUE;
1401       break;
1402
1403     case PROP_LANGUAGE:
1404       priv->language_set = TRUE;
1405       if (priv->language)
1406         g_object_unref (priv->language);
1407       priv->language = pango_language_from_string (g_value_get_string (value));
1408       g_object_notify (object, "language-set");
1409       break;
1410
1411     case PROP_ELLIPSIZE:
1412       priv->ellipsize = g_value_get_enum (value);
1413       priv->ellipsize_set = TRUE;
1414       g_object_notify (object, "ellipsize-set");
1415       break;
1416
1417     case PROP_WRAP_MODE:
1418       priv->wrap_mode = g_value_get_enum (value);
1419       break;
1420
1421     case PROP_WRAP_WIDTH:
1422       priv->wrap_width = g_value_get_int (value);
1423       break;
1424
1425     case PROP_WIDTH_CHARS:
1426       priv->width_chars = g_value_get_int (value);
1427       break;
1428
1429     case PROP_MAX_WIDTH_CHARS:
1430       priv->max_width_chars = g_value_get_int (value);
1431       break;
1432
1433     case PROP_ALIGN:
1434       priv->align = g_value_get_enum (value);
1435       priv->align_set = TRUE;
1436       g_object_notify (object, "align-set");
1437       break;
1438
1439     case PROP_BACKGROUND_SET:
1440       priv->background_set = g_value_get_boolean (value);
1441       break;
1442
1443     case PROP_FOREGROUND_SET:
1444       priv->foreground_set = g_value_get_boolean (value);
1445       break;
1446
1447     case PROP_FAMILY_SET:
1448     case PROP_STYLE_SET:
1449     case PROP_VARIANT_SET:
1450     case PROP_WEIGHT_SET:
1451     case PROP_STRETCH_SET:
1452     case PROP_SIZE_SET:
1453       if (!g_value_get_boolean (value))
1454         {
1455           pango_font_description_unset_fields (priv->font,
1456                                                get_property_font_set_mask (param_id));
1457         }
1458       else
1459         {
1460           PangoFontMask changed_mask;
1461
1462           changed_mask = set_font_desc_fields (priv->font,
1463                                                get_property_font_set_mask (param_id));
1464           notify_fields_changed (G_OBJECT (celltext), changed_mask);
1465         }
1466       break;
1467
1468     case PROP_SCALE_SET:
1469       priv->scale_set = g_value_get_boolean (value);
1470       break;
1471
1472     case PROP_EDITABLE_SET:
1473       priv->editable_set = g_value_get_boolean (value);
1474       break;
1475
1476     case PROP_STRIKETHROUGH_SET:
1477       priv->strikethrough_set = g_value_get_boolean (value);
1478       break;
1479
1480     case PROP_UNDERLINE_SET:
1481       priv->underline_set = g_value_get_boolean (value);
1482       break;
1483
1484     case PROP_RISE_SET:
1485       priv->rise_set = g_value_get_boolean (value);
1486       break;
1487
1488     case PROP_LANGUAGE_SET:
1489       priv->language_set = g_value_get_boolean (value);
1490       break;
1491
1492     case PROP_ELLIPSIZE_SET:
1493       priv->ellipsize_set = g_value_get_boolean (value);
1494       break;
1495
1496     case PROP_ALIGN_SET:
1497       priv->align_set = g_value_get_boolean (value);
1498       break;
1499
1500     default:
1501       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1502       break;
1503     }
1504 }
1505
1506 /**
1507  * gtk_cell_renderer_text_new:
1508  *
1509  * Creates a new #GtkCellRendererText. Adjust how text is drawn using
1510  * object properties. Object properties can be
1511  * set globally (with g_object_set()). Also, with #GtkTreeViewColumn,
1512  * you can bind a property to a value in a #GtkTreeModel. For example,
1513  * you can bind the "text" property on the cell renderer to a string
1514  * value in the model, thus rendering a different string in each row
1515  * of the #GtkTreeView
1516  *
1517  * Return value: the new cell renderer
1518  **/
1519 GtkCellRenderer *
1520 gtk_cell_renderer_text_new (void)
1521 {
1522   return g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, NULL);
1523 }
1524
1525 static void
1526 add_attr (PangoAttrList  *attr_list,
1527           PangoAttribute *attr)
1528 {
1529   attr->start_index = 0;
1530   attr->end_index = G_MAXINT;
1531
1532   pango_attr_list_insert (attr_list, attr);
1533 }
1534
1535 static PangoLayout*
1536 get_layout (GtkCellRendererText *celltext,
1537             GtkWidget           *widget,
1538             const GdkRectangle  *cell_area,
1539             GtkCellRendererState flags)
1540 {
1541   GtkCellRendererTextPrivate *priv = celltext->priv;
1542   PangoAttrList *attr_list;
1543   PangoLayout *layout;
1544   PangoUnderline uline;
1545   gint xpad;
1546
1547   layout = gtk_widget_create_pango_layout (widget, priv->text);
1548
1549   gtk_cell_renderer_get_padding (GTK_CELL_RENDERER (celltext), &xpad, NULL);
1550
1551   if (priv->extra_attrs)
1552     attr_list = pango_attr_list_copy (priv->extra_attrs);
1553   else
1554     attr_list = pango_attr_list_new ();
1555
1556   pango_layout_set_single_paragraph_mode (layout, priv->single_paragraph);
1557
1558   if (cell_area)
1559     {
1560       /* Add options that affect appearance but not size */
1561
1562       /* note that background doesn't go here, since it affects
1563        * background_area not the PangoLayout area
1564        */
1565
1566       if (priv->foreground_set
1567           && (flags & GTK_CELL_RENDERER_SELECTED) == 0)
1568         {
1569           PangoColor color;
1570
1571           color.red = (guint16) (priv->foreground.red * 65535);
1572           color.green = (guint16) (priv->foreground.green * 65535);
1573           color.blue = (guint16) (priv->foreground.blue * 65535);
1574
1575           add_attr (attr_list,
1576                     pango_attr_foreground_new (color.red, color.green, color.blue));
1577         }
1578
1579       if (priv->strikethrough_set)
1580         add_attr (attr_list,
1581                   pango_attr_strikethrough_new (priv->strikethrough));
1582     }
1583
1584   add_attr (attr_list, pango_attr_font_desc_new (priv->font));
1585
1586   if (priv->scale_set &&
1587       priv->font_scale != 1.0)
1588     add_attr (attr_list, pango_attr_scale_new (priv->font_scale));
1589
1590   if (priv->underline_set)
1591     uline = priv->underline_style;
1592   else
1593     uline = PANGO_UNDERLINE_NONE;
1594
1595   if (priv->language_set)
1596     add_attr (attr_list, pango_attr_language_new (priv->language));
1597
1598   if ((flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT)
1599     {
1600       switch (uline)
1601         {
1602         case PANGO_UNDERLINE_NONE:
1603           uline = PANGO_UNDERLINE_SINGLE;
1604           break;
1605
1606         case PANGO_UNDERLINE_SINGLE:
1607           uline = PANGO_UNDERLINE_DOUBLE;
1608           break;
1609
1610         default:
1611           break;
1612         }
1613     }
1614
1615   if (uline != PANGO_UNDERLINE_NONE)
1616     add_attr (attr_list, pango_attr_underline_new (priv->underline_style));
1617
1618   if (priv->rise_set)
1619     add_attr (attr_list, pango_attr_rise_new (priv->rise));
1620
1621   /* Now apply the attributes as they will effect the outcome
1622    * of pango_layout_get_extents() */
1623   pango_layout_set_attributes (layout, attr_list);
1624   pango_attr_list_unref (attr_list);
1625
1626   if (priv->ellipsize_set)
1627     pango_layout_set_ellipsize (layout, priv->ellipsize);
1628   else
1629     pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_NONE);
1630
1631   if (priv->wrap_width != -1)
1632     {
1633       PangoRectangle rect;
1634       gint           width, text_width;
1635
1636       pango_layout_get_extents (layout, NULL, &rect);
1637       text_width = rect.width;
1638
1639       if (cell_area)
1640         width = (cell_area->width - xpad * 2) * PANGO_SCALE;
1641       else
1642         width = priv->wrap_width * PANGO_SCALE;
1643
1644       width = MIN (width, text_width);
1645
1646       pango_layout_set_width (layout, width);
1647       pango_layout_set_wrap (layout, priv->wrap_mode);
1648     }
1649   else
1650     {
1651       pango_layout_set_width (layout, -1);
1652       pango_layout_set_wrap (layout, PANGO_WRAP_CHAR);
1653     }
1654
1655   if (priv->align_set)
1656     pango_layout_set_alignment (layout, priv->align);
1657   else
1658     {
1659       PangoAlignment align;
1660
1661       if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
1662         align = PANGO_ALIGN_RIGHT;
1663       else
1664         align = PANGO_ALIGN_LEFT;
1665
1666       pango_layout_set_alignment (layout, align);
1667     }
1668
1669   return layout;
1670 }
1671
1672
1673 static void
1674 get_size (GtkCellRenderer    *cell,
1675           GtkWidget          *widget,
1676           const GdkRectangle *cell_area,
1677           PangoLayout        *layout,
1678           gint               *x_offset,
1679           gint               *y_offset,
1680           gint               *width,
1681           gint               *height)
1682 {
1683   GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
1684   GtkCellRendererTextPrivate *priv = celltext->priv;
1685   PangoRectangle rect;
1686   gint xpad, ypad;
1687   gint cell_width, cell_height;
1688
1689   gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
1690
1691   if (priv->calc_fixed_height)
1692     {
1693       PangoContext *context;
1694       PangoFontMetrics *metrics;
1695       PangoFontDescription *font_desc;
1696       gint row_height;
1697
1698       font_desc = pango_font_description_copy_static (gtk_widget_get_style (widget)->font_desc);
1699       pango_font_description_merge_static (font_desc, priv->font, TRUE);
1700
1701       if (priv->scale_set)
1702         pango_font_description_set_size (font_desc,
1703                                          priv->font_scale * pango_font_description_get_size (font_desc));
1704
1705       context = gtk_widget_get_pango_context (widget);
1706
1707       metrics = pango_context_get_metrics (context,
1708                                            font_desc,
1709                                            pango_context_get_language (context));
1710       row_height = (pango_font_metrics_get_ascent (metrics) +
1711                     pango_font_metrics_get_descent (metrics));
1712       pango_font_metrics_unref (metrics);
1713
1714       pango_font_description_free (font_desc);
1715
1716       gtk_cell_renderer_get_fixed_size (cell, &cell_width, &cell_height);
1717
1718       gtk_cell_renderer_set_fixed_size (cell,
1719                                         cell_width, 2 * ypad +
1720                                         priv->fixed_height_rows * PANGO_PIXELS (row_height));
1721
1722       if (height)
1723         {
1724           *height = cell_height;
1725           height = NULL;
1726         }
1727       priv->calc_fixed_height = FALSE;
1728       if (width == NULL)
1729         return;
1730     }
1731
1732   if (layout)
1733     g_object_ref (layout);
1734   else
1735     layout = get_layout (celltext, widget, NULL, 0);
1736
1737   pango_layout_get_pixel_extents (layout, NULL, &rect);
1738
1739   if (height)
1740     *height = ypad * 2 + rect.height;
1741
1742   if (width)
1743     *width = xpad * 2 + rect.x + rect.width;
1744
1745   if (cell_area)
1746     {
1747       gfloat xalign, yalign;
1748
1749       gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
1750
1751       if (x_offset)
1752         {
1753           if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
1754             *x_offset = (1.0 - xalign) * (cell_area->width - (rect.x + rect.width + (2 * xpad)));
1755           else
1756             *x_offset = xalign * (cell_area->width - (rect.x + rect.width + (2 * xpad)));
1757
1758           if ((priv->ellipsize_set && priv->ellipsize != PANGO_ELLIPSIZE_NONE) || priv->wrap_width != -1)
1759             *x_offset = MAX(*x_offset, 0);
1760         }
1761       if (y_offset)
1762         {
1763           *y_offset = yalign * (cell_area->height - (rect.height + (2 * ypad)));
1764           *y_offset = MAX (*y_offset, 0);
1765         }
1766     }
1767   else
1768     {
1769       if (x_offset) *x_offset = 0;
1770       if (y_offset) *y_offset = 0;
1771     }
1772
1773   g_object_unref (layout);
1774 }
1775
1776 static void
1777 gtk_cell_renderer_text_render (GtkCellRenderer      *cell,
1778                                cairo_t              *cr,
1779                                GtkWidget            *widget,
1780                                const GdkRectangle   *background_area,
1781                                const GdkRectangle   *cell_area,
1782                                GtkCellRendererState  flags)
1783
1784 {
1785   GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
1786   GtkCellRendererTextPrivate *priv = celltext->priv;
1787   PangoLayout *layout;
1788   GtkStateType state;
1789   gint x_offset = 0;
1790   gint y_offset = 0;
1791   gint xpad, ypad;
1792
1793   layout = get_layout (celltext, widget, cell_area, flags);
1794   get_size (cell, widget, cell_area, layout, &x_offset, &y_offset, NULL, NULL);
1795
1796   if (!gtk_cell_renderer_get_sensitive (cell))
1797     {
1798       state = GTK_STATE_INSENSITIVE;
1799     }
1800   else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
1801     {
1802       if (gtk_widget_has_focus (widget))
1803         state = GTK_STATE_SELECTED;
1804       else
1805         state = GTK_STATE_ACTIVE;
1806     }
1807   else if ((flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT &&
1808            gtk_widget_get_state (widget) == GTK_STATE_PRELIGHT)
1809     {
1810       state = GTK_STATE_PRELIGHT;
1811     }
1812   else
1813     {
1814       if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
1815         state = GTK_STATE_INSENSITIVE;
1816       else
1817         state = GTK_STATE_NORMAL;
1818     }
1819
1820   if (priv->background_set &&
1821       (flags & GTK_CELL_RENDERER_SELECTED) == 0)
1822     {
1823       gdk_cairo_rectangle (cr, background_area);
1824       gdk_cairo_set_source_rgba (cr, &priv->background);
1825       cairo_fill (cr);
1826     }
1827
1828   gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
1829
1830   if (priv->ellipsize_set && priv->ellipsize != PANGO_ELLIPSIZE_NONE)
1831     pango_layout_set_width (layout,
1832                             (cell_area->width - x_offset - 2 * xpad) * PANGO_SCALE);
1833   else if (priv->wrap_width == -1)
1834     pango_layout_set_width (layout, -1);
1835
1836   gtk_paint_layout (gtk_widget_get_style (widget),
1837                           cr,
1838                           state,
1839                           TRUE,
1840                           widget,
1841                           "cellrenderertext",
1842                           cell_area->x + x_offset + xpad,
1843                           cell_area->y + y_offset + ypad,
1844                           layout);
1845
1846   g_object_unref (layout);
1847 }
1848
1849 static void
1850 gtk_cell_renderer_text_editing_done (GtkCellEditable *entry,
1851                                      gpointer         data)
1852 {
1853   GtkCellRendererTextPrivate *priv;
1854   const gchar *path;
1855   const gchar *new_text;
1856   gboolean canceled;
1857
1858   priv = GTK_CELL_RENDERER_TEXT (data)->priv;
1859
1860   priv->entry = NULL;
1861
1862   if (priv->focus_out_id > 0)
1863     {
1864       g_signal_handler_disconnect (entry, priv->focus_out_id);
1865       priv->focus_out_id = 0;
1866     }
1867
1868   if (priv->populate_popup_id > 0)
1869     {
1870       g_signal_handler_disconnect (entry, priv->populate_popup_id);
1871       priv->populate_popup_id = 0;
1872     }
1873
1874   if (priv->entry_menu_popdown_timeout)
1875     {
1876       g_source_remove (priv->entry_menu_popdown_timeout);
1877       priv->entry_menu_popdown_timeout = 0;
1878     }
1879
1880   g_object_get (entry,
1881                 "editing-canceled", &canceled,
1882                 NULL);
1883   gtk_cell_renderer_stop_editing (GTK_CELL_RENDERER (data), canceled);
1884
1885   if (canceled)
1886     return;
1887
1888   path = g_object_get_data (G_OBJECT (entry), GTK_CELL_RENDERER_TEXT_PATH);
1889   new_text = gtk_entry_get_text (GTK_ENTRY (entry));
1890
1891   g_signal_emit (data, text_cell_renderer_signals[EDITED], 0, path, new_text);
1892 }
1893
1894 static gboolean
1895 popdown_timeout (gpointer data)
1896 {
1897   GtkCellRendererTextPrivate *priv;
1898
1899   priv = GTK_CELL_RENDERER_TEXT (data)->priv;
1900
1901   priv->entry_menu_popdown_timeout = 0;
1902
1903   if (!gtk_widget_has_focus (priv->entry))
1904     gtk_cell_renderer_text_editing_done (GTK_CELL_EDITABLE (priv->entry), data);
1905
1906   return FALSE;
1907 }
1908
1909 static void
1910 gtk_cell_renderer_text_popup_unmap (GtkMenu *menu,
1911                                     gpointer data)
1912 {
1913   GtkCellRendererTextPrivate *priv;
1914
1915   priv = GTK_CELL_RENDERER_TEXT (data)->priv;
1916
1917   priv->in_entry_menu = FALSE;
1918
1919   if (priv->entry_menu_popdown_timeout)
1920     return;
1921
1922   priv->entry_menu_popdown_timeout = gdk_threads_add_timeout (500, popdown_timeout,
1923                                                     data);
1924 }
1925
1926 static void
1927 gtk_cell_renderer_text_populate_popup (GtkEntry *entry,
1928                                        GtkMenu  *menu,
1929                                        gpointer  data)
1930 {
1931   GtkCellRendererTextPrivate *priv;
1932
1933   priv = GTK_CELL_RENDERER_TEXT (data)->priv;
1934
1935   if (priv->entry_menu_popdown_timeout)
1936     {
1937       g_source_remove (priv->entry_menu_popdown_timeout);
1938       priv->entry_menu_popdown_timeout = 0;
1939     }
1940
1941   priv->in_entry_menu = TRUE;
1942
1943   g_signal_connect (menu, "unmap",
1944                     G_CALLBACK (gtk_cell_renderer_text_popup_unmap), data);
1945 }
1946
1947 static gboolean
1948 gtk_cell_renderer_text_focus_out_event (GtkWidget *entry,
1949                                         GdkEvent  *event,
1950                                         gpointer   data)
1951 {
1952   GtkCellRendererTextPrivate *priv;
1953
1954   priv = GTK_CELL_RENDERER_TEXT (data)->priv;
1955
1956   if (priv->in_entry_menu)
1957     return FALSE;
1958
1959   g_object_set (entry,
1960                 "editing-canceled", TRUE,
1961                 NULL);
1962   gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
1963   gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
1964
1965   /* entry needs focus-out-event */
1966   return FALSE;
1967 }
1968
1969 static GtkCellEditable *
1970 gtk_cell_renderer_text_start_editing (GtkCellRenderer      *cell,
1971                                       GdkEvent             *event,
1972                                       GtkWidget            *widget,
1973                                       const gchar          *path,
1974                                       const GdkRectangle   *background_area,
1975                                       const GdkRectangle   *cell_area,
1976                                       GtkCellRendererState  flags)
1977 {
1978   GtkRequisition requisition;
1979   GtkCellRendererText *celltext;
1980   GtkCellRendererTextPrivate *priv;
1981   gfloat xalign, yalign;
1982
1983   celltext = GTK_CELL_RENDERER_TEXT (cell);
1984   priv = celltext->priv;
1985
1986   /* If the cell isn't editable we return NULL. */
1987   if (priv->editable == FALSE)
1988     return NULL;
1989
1990   gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
1991
1992   priv->entry = gtk_entry_new ();
1993   gtk_entry_set_has_frame (GTK_ENTRY (priv->entry), FALSE);
1994   gtk_entry_set_alignment (GTK_ENTRY (priv->entry), xalign);
1995
1996   if (priv->text)
1997     gtk_entry_set_text (GTK_ENTRY (priv->entry), priv->text);
1998   g_object_set_data_full (G_OBJECT (priv->entry), I_(GTK_CELL_RENDERER_TEXT_PATH), g_strdup (path), g_free);
1999
2000   gtk_editable_select_region (GTK_EDITABLE (priv->entry), 0, -1);
2001
2002   gtk_widget_get_preferred_size (priv->entry, &requisition, NULL);
2003   if (requisition.height < cell_area->height)
2004     {
2005       GtkBorder *style_border;
2006       GtkBorder border;
2007
2008       gtk_widget_style_get (priv->entry,
2009                             "inner-border", &style_border,
2010                             NULL);
2011
2012       if (style_border)
2013         {
2014           border = *style_border;
2015           g_boxed_free (GTK_TYPE_BORDER, style_border);
2016         }
2017       else
2018         {
2019           /* Since boxed style properties can't have default values ... */
2020           border.left = 2;
2021           border.right = 2;
2022         }
2023
2024       border.top = (cell_area->height - requisition.height) / 2;
2025       border.bottom = (cell_area->height - requisition.height) / 2;
2026       gtk_entry_set_inner_border (GTK_ENTRY (priv->entry), &border);
2027     }
2028
2029   priv->in_entry_menu = FALSE;
2030   if (priv->entry_menu_popdown_timeout)
2031     {
2032       g_source_remove (priv->entry_menu_popdown_timeout);
2033       priv->entry_menu_popdown_timeout = 0;
2034     }
2035
2036   g_signal_connect (priv->entry,
2037                     "editing-done",
2038                     G_CALLBACK (gtk_cell_renderer_text_editing_done),
2039                     celltext);
2040   priv->focus_out_id = g_signal_connect_after (priv->entry, "focus-out-event",
2041                                                G_CALLBACK (gtk_cell_renderer_text_focus_out_event),
2042                                                celltext);
2043   priv->populate_popup_id =
2044     g_signal_connect (priv->entry, "populate-popup",
2045                       G_CALLBACK (gtk_cell_renderer_text_populate_popup),
2046                       celltext);
2047
2048   gtk_widget_show (priv->entry);
2049
2050   return GTK_CELL_EDITABLE (priv->entry);
2051 }
2052
2053 /**
2054  * gtk_cell_renderer_text_set_fixed_height_from_font:
2055  * @renderer: A #GtkCellRendererText
2056  * @number_of_rows: Number of rows of text each cell renderer is allocated, or -1
2057  *
2058  * Sets the height of a renderer to explicitly be determined by the "font" and
2059  * "y_pad" property set on it.  Further changes in these properties do not
2060  * affect the height, so they must be accompanied by a subsequent call to this
2061  * function.  Using this function is unflexible, and should really only be used
2062  * if calculating the size of a cell is too slow (ie, a massive number of cells
2063  * displayed).  If @number_of_rows is -1, then the fixed height is unset, and
2064  * the height is determined by the properties again.
2065  **/
2066 void
2067 gtk_cell_renderer_text_set_fixed_height_from_font (GtkCellRendererText *renderer,
2068                                                    gint                 number_of_rows)
2069 {
2070   GtkCellRendererTextPrivate *priv;
2071   GtkCellRenderer *cell;
2072
2073   g_return_if_fail (GTK_IS_CELL_RENDERER_TEXT (renderer));
2074   g_return_if_fail (number_of_rows == -1 || number_of_rows > 0);
2075
2076   cell = GTK_CELL_RENDERER (renderer);
2077   priv = renderer->priv;
2078
2079   if (number_of_rows == -1)
2080     {
2081       gint width, height;
2082
2083       gtk_cell_renderer_get_fixed_size (cell, &width, &height);
2084       gtk_cell_renderer_set_fixed_size (cell, width, -1);
2085     }
2086   else
2087     {
2088       priv->fixed_height_rows = number_of_rows;
2089       priv->calc_fixed_height = TRUE;
2090     }
2091 }
2092
2093 static void
2094 gtk_cell_renderer_text_get_preferred_width (GtkCellRenderer *cell,
2095                                             GtkWidget       *widget,
2096                                             gint            *minimum_size,
2097                                             gint            *natural_size)
2098 {
2099   GtkCellRendererTextPrivate    *priv;
2100   GtkCellRendererText        *celltext;
2101   GtkStyle                   *style;
2102   PangoLayout                *layout;
2103   PangoContext               *context;
2104   PangoFontMetrics           *metrics;
2105   PangoRectangle              rect;
2106   gint char_width, digit_width, char_pixels, text_width, ellipsize_chars, guess_width, xpad;
2107   gint min_width, nat_width;
2108
2109   /* "width-chars" Hard-coded minimum width:
2110    *    - minimum size should be MAX (width-chars, strlen ("..."));
2111    *    - natural size should be MAX (width-chars, strlen (label->text));
2112    *
2113    * "wrap-width" User specified natural wrap width
2114    *    - minimum size should be MAX (width-chars, 0)
2115    *    - natural size should be MIN (wrap-width, strlen (label->text))
2116    */
2117
2118   celltext = GTK_CELL_RENDERER_TEXT (cell);
2119   priv = celltext->priv;
2120
2121   style = gtk_widget_get_style (widget);
2122
2123   gtk_cell_renderer_get_padding (cell, &xpad, NULL);
2124
2125   layout = get_layout (celltext, widget, NULL, 0);
2126
2127   /* Get the layout with the text possibly wrapping at wrap_width */
2128   pango_layout_get_pixel_extents (layout, NULL, &rect);
2129   guess_width = rect.width;
2130
2131   /* Fetch the length of the complete unwrapped text */
2132   pango_layout_set_width (layout, -1);
2133   pango_layout_get_extents (layout, NULL, &rect);
2134   text_width = rect.width;
2135
2136   /* Fetch the average size of a charachter */
2137   context = pango_layout_get_context (layout);
2138   metrics = pango_context_get_metrics (context, style->font_desc,
2139                                        pango_context_get_language (context));
2140
2141   char_width = pango_font_metrics_get_approximate_char_width (metrics);
2142   digit_width = pango_font_metrics_get_approximate_digit_width (metrics);
2143   char_pixels = MAX (char_width, digit_width);
2144
2145   pango_font_metrics_unref (metrics);
2146   g_object_unref (layout);
2147
2148   /* enforce minimum width for ellipsized labels at ~3 chars */
2149   if (priv->ellipsize_set && priv->ellipsize != PANGO_ELLIPSIZE_NONE)
2150     ellipsize_chars = 3;
2151   else
2152     ellipsize_chars = 0;
2153
2154   if ((priv->ellipsize_set && priv->ellipsize != PANGO_ELLIPSIZE_NONE) || priv->width_chars > 0)
2155     min_width =
2156       xpad * 2 + (PANGO_PIXELS (char_width) * MAX (priv->width_chars, ellipsize_chars));
2157   /* If no width-chars set, minimum for wrapping text will be the wrap-width */
2158   else if (priv->wrap_width > -1)
2159     min_width = xpad * 2 + rect.x + priv->wrap_width;
2160   else
2161     min_width = xpad * 2 + rect.x + guess_width;
2162
2163   if (priv->width_chars > 0)
2164     nat_width = xpad * 2 +
2165       MAX ((PANGO_PIXELS (char_width) * priv->width_chars), PANGO_PIXELS (text_width));
2166   else
2167     nat_width = xpad * 2 + PANGO_PIXELS (text_width);
2168
2169   nat_width = MAX (nat_width, min_width);
2170
2171   if (priv->max_width_chars > 0)
2172     {
2173       gint max_width = xpad * 2 + PANGO_PIXELS (char_width) * priv->max_width_chars;
2174
2175       min_width = MIN (min_width, max_width);
2176       nat_width = MIN (nat_width, max_width);
2177     }
2178
2179   if (minimum_size)
2180     *minimum_size = min_width;
2181
2182   if (natural_size)
2183     *natural_size = nat_width;
2184
2185 }
2186
2187 static void
2188 gtk_cell_renderer_text_get_preferred_height_for_width (GtkCellRenderer *cell,
2189                                                        GtkWidget       *widget,
2190                                                        gint             width,
2191                                                        gint            *minimum_height,
2192                                                        gint            *natural_height)
2193 {
2194   GtkCellRendererTextPrivate    *priv;
2195   GtkCellRendererText        *celltext;
2196   PangoLayout                *layout;
2197   gint                        text_height, xpad, ypad;
2198
2199
2200   celltext = GTK_CELL_RENDERER_TEXT (cell);
2201   priv = celltext->priv;
2202
2203   gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
2204
2205   layout = get_layout (celltext, widget, NULL, 0);
2206
2207   pango_layout_set_width (layout, (width - xpad * 2) * PANGO_SCALE);
2208   pango_layout_get_pixel_size (layout, NULL, &text_height);
2209
2210   if (minimum_height)
2211     *minimum_height = text_height + ypad * 2;
2212
2213   if (natural_height)
2214     *natural_height = text_height + ypad * 2;
2215
2216   g_object_unref (layout);
2217 }
2218
2219 static void
2220 gtk_cell_renderer_text_get_preferred_height (GtkCellRenderer *cell,
2221                                              GtkWidget       *widget,
2222                                              gint            *minimum_size,
2223                                              gint            *natural_size)
2224 {
2225   gint min_width;
2226
2227   /* Thankfully cell renderers dont rotate, so they only have to do
2228    * height-for-width and not the opposite. Here we have only to return
2229    * the height for the base minimum width of the renderer.
2230    *
2231    * Note this code path wont be followed by GtkTreeView which is
2232    * height-for-width specifically.
2233    */
2234   gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, NULL);
2235   gtk_cell_renderer_text_get_preferred_height_for_width (cell, widget, min_width,
2236                                                          minimum_size, natural_size);
2237 }
2238
2239 static void
2240 gtk_cell_renderer_text_get_aligned_area (GtkCellRenderer       *cell,
2241                                          GtkWidget             *widget,
2242                                          GtkCellRendererState   flags,
2243                                          const GdkRectangle    *cell_area,
2244                                          GdkRectangle          *aligned_area)
2245 {
2246   GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
2247   PangoLayout *layout;
2248   gint x_offset = 0;
2249   gint y_offset = 0;
2250
2251   layout = get_layout (celltext, widget, cell_area, flags);
2252   get_size (cell, widget, cell_area, layout, &x_offset, &y_offset,
2253             &aligned_area->width, &aligned_area->height);
2254
2255   aligned_area->x = cell_area->x + x_offset;
2256   aligned_area->y = cell_area->y + y_offset;
2257
2258   g_object_unref (layout);
2259 }