/* gtkcellrenderertext.c

 * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <stdlib.h>

#include "gtkcellrenderertext.h"

#include "gtkeditable.h"

#include "gtkentry.h"

#include "gtkmarshalers.h"

#include "gtkintl.h"

#include "gtkprivate.h"

#include "gtktreeprivate.h"

#include "gtkalias.h"

static void gtk_cell_renderer_text_finalize   (GObject                  *object);

static void gtk_cell_renderer_text_get_property  (GObject                  *object,

						  guint                     param_id,

						  GValue                   *value,

						  GParamSpec               *pspec);

static void gtk_cell_renderer_text_set_property  (GObject                  *object,

						  guint                     param_id,

						  const GValue             *value,

						  GParamSpec               *pspec);

static void gtk_cell_renderer_text_get_size   (GtkCellRenderer          *cell,

					       GtkWidget                *widget,

					       GdkRectangle             *cell_area,

					       gint                     *x_offset,

					       gint                     *y_offset,

					       gint                     *width,

					       gint                     *height);

static void gtk_cell_renderer_text_render     (GtkCellRenderer          *cell,

					       GdkWindow                *window,

					       GtkWidget                *widget,

					       GdkRectangle             *background_area,

					       GdkRectangle             *cell_area,

					       GdkRectangle             *expose_area,

					       GtkCellRendererState      flags);

static GtkCellEditable *gtk_cell_renderer_text_start_editing (GtkCellRenderer      *cell,

							      GdkEvent             *event,

							      GtkWidget            *widget,

							      const gchar          *path,

							      GdkRectangle         *background_area,

							      GdkRectangle         *cell_area,

							      GtkCellRendererState  flags);

enum {

  EDITED,

  LAST_SIGNAL

};

enum {

  PROP_0,

  PROP_TEXT,

  PROP_MARKUP,

  PROP_ATTRIBUTES,

  PROP_SINGLE_PARAGRAPH_MODE,

  PROP_WIDTH_CHARS,

  PROP_WRAP_WIDTH,

  PROP_ALIGN,

  /* Style args */

  PROP_BACKGROUND,

  PROP_FOREGROUND,

  PROP_BACKGROUND_GDK,

  PROP_FOREGROUND_GDK,

  PROP_FONT,

  PROP_FONT_DESC,

  PROP_FAMILY,

  PROP_STYLE,

  PROP_VARIANT,

  PROP_WEIGHT,

  PROP_STRETCH,

  PROP_SIZE,

  PROP_SIZE_POINTS,

  PROP_SCALE,

  PROP_EDITABLE,

  PROP_STRIKETHROUGH,

  PROP_UNDERLINE,

  PROP_RISE,

  PROP_LANGUAGE,

  PROP_ELLIPSIZE,

  PROP_WRAP_MODE,

  /* Whether-a-style-arg-is-set args */

  PROP_BACKGROUND_SET,

  PROP_FOREGROUND_SET,

  PROP_FAMILY_SET,

  PROP_STYLE_SET,

  PROP_VARIANT_SET,

  PROP_WEIGHT_SET,

  PROP_STRETCH_SET,

  PROP_SIZE_SET,

  PROP_SCALE_SET,

  PROP_EDITABLE_SET,

  PROP_STRIKETHROUGH_SET,

  PROP_UNDERLINE_SET,

  PROP_RISE_SET,

  PROP_LANGUAGE_SET,

  PROP_ELLIPSIZE_SET,

  PROP_ALIGN_SET

};

static guint text_cell_renderer_signals [LAST_SIGNAL];

#define GTK_CELL_RENDERER_TEXT_PATH "gtk-cell-renderer-text-path"

#define GTK_CELL_RENDERER_TEXT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_CELL_RENDERER_TEXT, GtkCellRendererTextPrivate))

typedef struct _GtkCellRendererTextPrivate GtkCellRendererTextPrivate;

struct _GtkCellRendererTextPrivate

{

  guint single_paragraph : 1;

  guint language_set : 1;

  guint markup_set : 1;

  guint ellipsize_set : 1;

  guint align_set : 1;

  gulong focus_out_id;

  PangoLanguage *language;

  PangoEllipsizeMode ellipsize;

  PangoWrapMode wrap_mode;

  PangoAlignment align;

  gulong populate_popup_id;

  gulong entry_menu_popdown_timeout;

  gboolean in_entry_menu;

  gint width_chars;

  gint wrap_width;

  GtkWidget *entry;

};

G_DEFINE_TYPE (GtkCellRendererText, gtk_cell_renderer_text, GTK_TYPE_CELL_RENDERER)

static void

gtk_cell_renderer_text_init (GtkCellRendererText *celltext)

{

  GtkCellRendererTextPrivate *priv;

  priv = GTK_CELL_RENDERER_TEXT_GET_PRIVATE (celltext);

  GTK_CELL_RENDERER (celltext)->xalign = 0.0;

  GTK_CELL_RENDERER (celltext)->yalign = 0.5;

  GTK_CELL_RENDERER (celltext)->xpad = 2;

  GTK_CELL_RENDERER (celltext)->ypad = 2;

  celltext->font_scale = 1.0;

  celltext->fixed_height_rows = -1;

  celltext->font = pango_font_description_new ();

  priv->width_chars = -1;

  priv->wrap_width = -1;

  priv->wrap_mode = PANGO_WRAP_CHAR;

  priv->align = PANGO_ALIGN_LEFT;

  priv->align_set = FALSE;

}

static void

gtk_cell_renderer_text_class_init (GtkCellRendererTextClass *class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (class);

  GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);

  object_class->finalize = gtk_cell_renderer_text_finalize;

  object_class->get_property = gtk_cell_renderer_text_get_property;

  object_class->set_property = gtk_cell_renderer_text_set_property;

  cell_class->get_size = gtk_cell_renderer_text_get_size;

  cell_class->render = gtk_cell_renderer_text_render;

  cell_class->start_editing = gtk_cell_renderer_text_start_editing;

  g_object_class_install_property (object_class,

                                   PROP_TEXT,

                                   g_param_spec_string ("text",

                                                        P_("Text"),

                                                        P_("Text to render"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_MARKUP,

                                   g_param_spec_string ("markup",

                                                        P_("Markup"),

                                                        P_("Marked up text to render"),

                                                        NULL,

                                                        GTK_PARAM_WRITABLE));

  g_object_class_install_property (object_class,

				   PROP_ATTRIBUTES,

				   g_param_spec_boxed ("attributes",

						       P_("Attributes"),

						       P_("A list of style attributes to apply to the text of the renderer"),

						       PANGO_TYPE_ATTR_LIST,

						       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SINGLE_PARAGRAPH_MODE,

                                   g_param_spec_boolean ("single-paragraph-mode",

                                                         P_("Single Paragraph Mode"),

                                                         P_("Whether or not to keep all text in a single paragraph"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_BACKGROUND,

                                   g_param_spec_string ("background",

                                                        P_("Background color name"),

                                                        P_("Background color as a string"),

                                                        NULL,

                                                        GTK_PARAM_WRITABLE));

  g_object_class_install_property (object_class,

                                   PROP_BACKGROUND_GDK,

                                   g_param_spec_boxed ("background-gdk",

                                                       P_("Background color"),

                                                       P_("Background color as a GdkColor"),

                                                       GDK_TYPE_COLOR,

                                                       GTK_PARAM_READWRITE));  

  g_object_class_install_property (object_class,

                                   PROP_FOREGROUND,

                                   g_param_spec_string ("foreground",

                                                        P_("Foreground color name"),

                                                        P_("Foreground color as a string"),

                                                        NULL,

                                                        GTK_PARAM_WRITABLE));

  g_object_class_install_property (object_class,

                                   PROP_FOREGROUND_GDK,

                                   g_param_spec_boxed ("foreground-gdk",

                                                       P_("Foreground color"),

                                                       P_("Foreground color as a GdkColor"),

                                                       GDK_TYPE_COLOR,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_EDITABLE,

                                   g_param_spec_boolean ("editable",

                                                         P_("Editable"),

                                                         P_("Whether the text can be modified by the user"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_FONT,

                                   g_param_spec_string ("font",

                                                        P_("Font"),

                                                        P_("Font description as a string, e.g. \"Sans Italic 12\""),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_FONT_DESC,

                                   g_param_spec_boxed ("font-desc",

                                                       P_("Font"),

                                                       P_("Font description as a PangoFontDescription struct"),

                                                       PANGO_TYPE_FONT_DESCRIPTION,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_FAMILY,

                                   g_param_spec_string ("family",

                                                        P_("Font family"),

                                                        P_("Name of the font family, e.g. Sans, Helvetica, Times, Monospace"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_STYLE,

                                   g_param_spec_enum ("style",

                                                      P_("Font style"),

                                                      P_("Font style"),

                                                      PANGO_TYPE_STYLE,

                                                      PANGO_STYLE_NORMAL,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_VARIANT,

                                   g_param_spec_enum ("variant",

                                                     P_("Font variant"),

                                                     P_("Font variant"),

                                                      PANGO_TYPE_VARIANT,

                                                      PANGO_VARIANT_NORMAL,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_WEIGHT,

                                   g_param_spec_int ("weight",

                                                     P_("Font weight"),

                                                     P_("Font weight"),

                                                     0,

                                                     G_MAXINT,

                                                     PANGO_WEIGHT_NORMAL,

                                                     GTK_PARAM_READWRITE));

   g_object_class_install_property (object_class,

                                   PROP_STRETCH,

                                   g_param_spec_enum ("stretch",

                                                      P_("Font stretch"),

                                                      P_("Font stretch"),

                                                      PANGO_TYPE_STRETCH,

                                                      PANGO_STRETCH_NORMAL,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SIZE,

                                   g_param_spec_int ("size",

                                                     P_("Font size"),

                                                     P_("Font size"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SIZE_POINTS,

                                   g_param_spec_double ("size-points",

                                                        P_("Font points"),

                                                        P_("Font size in points"),

                                                        0.0,

                                                        G_MAXDOUBLE,

                                                        0.0,

                                                        GTK_PARAM_READWRITE));  

  g_object_class_install_property (object_class,

                                   PROP_SCALE,

                                   g_param_spec_double ("scale",

                                                        P_("Font scale"),

                                                        P_("Font scaling factor"),

                                                        0.0,

                                                        G_MAXDOUBLE,

                                                        1.0,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_RISE,

                                   g_param_spec_int ("rise",

                                                     P_("Rise"),

                                                     P_("Offset of text above the baseline "

							"(below the baseline if rise is negative)"),

                                                     -G_MAXINT,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_STRIKETHROUGH,

                                   g_param_spec_boolean ("strikethrough",

                                                         P_("Strikethrough"),

                                                         P_("Whether to strike through the text"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_UNDERLINE,

                                   g_param_spec_enum ("underline",

                                                      P_("Underline"),

                                                      P_("Style of underline for this text"),

                                                      PANGO_TYPE_UNDERLINE,

                                                      PANGO_UNDERLINE_NONE,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_LANGUAGE,

                                   g_param_spec_string ("language",

                                                        P_("Language"),

                                                        P_("The language this text is in, as an ISO code. "

							   "Pango can use this as a hint when rendering the text. "

							   "If you don't understand this parameter, you probably don't need it"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkCellRendererText:ellipsize:

   *

   * Specifies the preferred place to ellipsize the string, if the cell renderer 

   * does not have enough room to display the entire string. Setting it to 

   * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property

   * for another way of making the text fit into a given width.

   *

   * Since: 2.6

   */

  g_object_class_install_property (object_class,

                                   PROP_ELLIPSIZE,

                                   g_param_spec_enum ("ellipsize",

						      P_("Ellipsize"),

						      P_("The preferred place to ellipsize the string, "

							 "if the cell renderer does not have enough room "

							 "to display the entire string"),

						      PANGO_TYPE_ELLIPSIZE_MODE,

						      PANGO_ELLIPSIZE_NONE,

						      GTK_PARAM_READWRITE));

  /**

   * GtkCellRendererText:width-chars:

   * 

   * The desired width of the cell, in characters. If this property is set to

   * -1, the width will be calculated automatically, otherwise the cell will

   * request either 3 characters or the property value, whichever is greater.

   * 

   * Since: 2.6

   **/

  g_object_class_install_property (object_class,

                                   PROP_WIDTH_CHARS,

                                   g_param_spec_int ("width-chars",

                                                     P_("Width In Characters"),

                                                     P_("The desired width of the label, in characters"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  /**

   * GtkCellRendererText:wrap-mode:

   *

   * Specifies how to break the string into multiple lines, if the cell 

   * renderer does not have enough room to display the entire string. 

   * This property has no effect unless the wrap-width property is set.

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

                                   PROP_WRAP_MODE,

                                   g_param_spec_enum ("wrap-mode",

						      P_("Wrap mode"),

						      P_("How to break the string into multiple lines, "

							 "if the cell renderer does not have enough room "

							 "to display the entire string"),

						      PANGO_TYPE_WRAP_MODE,

						      PANGO_WRAP_CHAR,

						      GTK_PARAM_READWRITE));

  /**

   * GtkCellRendererText:wrap-width:

   *

   * Specifies the width at which the text is wrapped. The wrap-mode property can 

   * be used to influence at what character positions the line breaks can be placed.

   * Setting wrap-width to -1 turns wrapping off.

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

				   PROP_WRAP_WIDTH,

				   g_param_spec_int ("wrap-width",

						     P_("Wrap width"),

						     P_("The width at which the text is wrapped"),

						     -1,

						     G_MAXINT,

						     -1,

						     GTK_PARAM_READWRITE));

  /**

   * GtkCellRendererText:alignment:

   *

   * Specifies how to align the lines of text with respect to each other. 

   *

   * Note that this property describes how to align the lines of text in 

   * case there are several of them. The "xalign" property of #GtkCellRenderer, 

   * on the other hand, sets the horizontal alignment of the whole text.

   *

   * Since: 2.10

   */

  g_object_class_install_property (object_class,

                                   PROP_ALIGN,

                                   g_param_spec_enum ("alignment",

						      P_("Alignment"),

						      P_("How to align the lines"),

						      PANGO_TYPE_ALIGNMENT,

						      PANGO_ALIGN_LEFT,

						      GTK_PARAM_READWRITE));

  /* Style props are set or not */

#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))

  ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,

                P_("Background set"),

                P_("Whether this tag affects the background color"));

  ADD_SET_PROP ("foreground-set", PROP_FOREGROUND_SET,

                P_("Foreground set"),

                P_("Whether this tag affects the foreground color"));

  ADD_SET_PROP ("editable-set", PROP_EDITABLE_SET,

                P_("Editability set"),

                P_("Whether this tag affects text editability"));

  ADD_SET_PROP ("family-set", PROP_FAMILY_SET,

                P_("Font family set"),

                P_("Whether this tag affects the font family"));  

  ADD_SET_PROP ("style-set", PROP_STYLE_SET,

                P_("Font style set"),

                P_("Whether this tag affects the font style"));

  ADD_SET_PROP ("variant-set", PROP_VARIANT_SET,

                P_("Font variant set"),

                P_("Whether this tag affects the font variant"));

  ADD_SET_PROP ("weight-set", PROP_WEIGHT_SET,

                P_("Font weight set"),

                P_("Whether this tag affects the font weight"));

  ADD_SET_PROP ("stretch-set", PROP_STRETCH_SET,

                P_("Font stretch set"),

                P_("Whether this tag affects the font stretch"));

  ADD_SET_PROP ("size-set", PROP_SIZE_SET,

                P_("Font size set"),

                P_("Whether this tag affects the font size"));

  ADD_SET_PROP ("scale-set", PROP_SCALE_SET,

                P_("Font scale set"),

                P_("Whether this tag scales the font size by a factor"));

  ADD_SET_PROP ("rise-set", PROP_RISE_SET,

                P_("Rise set"),

                P_("Whether this tag affects the rise"));

  ADD_SET_PROP ("strikethrough-set", PROP_STRIKETHROUGH_SET,

                P_("Strikethrough set"),

                P_("Whether this tag affects strikethrough"));

  ADD_SET_PROP ("underline-set", PROP_UNDERLINE_SET,

                P_("Underline set"),

                P_("Whether this tag affects underlining"));

  ADD_SET_PROP ("language-set", PROP_LANGUAGE_SET,

                P_("Language set"),

                P_("Whether this tag affects the language the text is rendered as"));

  ADD_SET_PROP ("ellipsize-set", PROP_ELLIPSIZE_SET,

                P_("Ellipsize set"),

                P_("Whether this tag affects the ellipsize mode"));

  ADD_SET_PROP ("align-set", PROP_ALIGN_SET,

                P_("Align set"),

                P_("Whether this tag affects the alignment mode"));

  /**

   * GtkCellRendererText::edited

   * @renderer: the object which received the signal

   * @path: the path identifying the edited cell

   * @new_text: the new text

   *

   * This signal is emitted after @renderer has been edited.

   *

   * It is the responsibility of the application to update the model

   * and store @new_text at the position indicated by @path.

   */

  text_cell_renderer_signals [EDITED] =

    g_signal_new (I_("edited"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkCellRendererTextClass, edited),

		  NULL, NULL,

		  _gtk_marshal_VOID__STRING_STRING,

		  G_TYPE_NONE, 2,

		  G_TYPE_STRING,

		  G_TYPE_STRING);

  g_type_class_add_private (object_class, sizeof (GtkCellRendererTextPrivate));

}

static void

gtk_cell_renderer_text_finalize (GObject *object)

{

  GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);

  GtkCellRendererTextPrivate *priv;

  priv = GTK_CELL_RENDERER_TEXT_GET_PRIVATE (object);

  pango_font_description_free (celltext->font);

  g_free (celltext->text);

  if (celltext->extra_attrs)

    pango_attr_list_unref (celltext->extra_attrs);

  if (priv->language)

    g_object_unref (priv->language);

  G_OBJECT_CLASS (gtk_cell_renderer_text_parent_class)->finalize (object);

}

static PangoFontMask

get_property_font_set_mask (guint prop_id)

{

  switch (prop_id)

    {

    case PROP_FAMILY_SET:

      return PANGO_FONT_MASK_FAMILY;

    case PROP_STYLE_SET:

      return PANGO_FONT_MASK_STYLE;

    case PROP_VARIANT_SET:

      return PANGO_FONT_MASK_VARIANT;

    case PROP_WEIGHT_SET:

      return PANGO_FONT_MASK_WEIGHT;

    case PROP_STRETCH_SET:

      return PANGO_FONT_MASK_STRETCH;

    case PROP_SIZE_SET:

      return PANGO_FONT_MASK_SIZE;

    }

  return 0;

}

static void

gtk_cell_renderer_text_get_property (GObject        *object,

				     guint           param_id,

				     GValue         *value,

				     GParamSpec     *pspec)

{

  GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);

  GtkCellRendererTextPrivate *priv;

  priv = GTK_CELL_RENDERER_TEXT_GET_PRIVATE (object);

  switch (param_id)

    {

    case PROP_TEXT:

      g_value_set_string (value, celltext->text);

      break;

    case PROP_ATTRIBUTES:

      g_value_set_boxed (value, celltext->extra_attrs);

      break;

    case PROP_SINGLE_PARAGRAPH_MODE:

      g_value_set_boolean (value, priv->single_paragraph);

      break;

    case PROP_BACKGROUND_GDK:

      {

        GdkColor color;

        color.red = celltext->background.red;

        color.green = celltext->background.green;

        color.blue = celltext->background.blue;

        g_value_set_boxed (value, &color;;

      }

      break;

    case PROP_FOREGROUND_GDK:

      {

        GdkColor color;

        color.red = celltext->foreground.red;

        color.green = celltext->foreground.green;

        color.blue = celltext->foreground.blue;

        g_value_set_boxed (value, &color;;

      }

      break;

    case PROP_FONT:

        g_value_take_string (value, pango_font_description_to_string (celltext->font));

      break;

    case PROP_FONT_DESC:

      g_value_set_boxed (value, celltext->font);

      break;

    case PROP_FAMILY:

      g_value_set_string (value, pango_font_description_get_family (celltext->font));

      break;

    case PROP_STYLE:

      g_value_set_enum (value, pango_font_description_get_style (celltext->font));

      break;

    case PROP_VARIANT:

      g_value_set_enum (value, pango_font_description_get_variant (celltext->font));

      break;

    case PROP_WEIGHT:

      g_value_set_int (value, pango_font_description_get_weight (celltext->font));

      break;

    case PROP_STRETCH:

      g_value_set_enum (value, pango_font_description_get_stretch (celltext->font));

      break;

    case PROP_SIZE:

      g_value_set_int (value, pango_font_description_get_size (celltext->font));

      break;

    case PROP_SIZE_POINTS:

      g_value_set_double (value, ((double)pango_font_description_get_size (celltext->font)) / (double)PANGO_SCALE);

      break;

    case PROP_SCALE:

      g_value_set_double (value, celltext->font_scale);

      break;

    case PROP_EDITABLE:

      g_value_set_boolean (value, celltext->editable);

      break;

    case PROP_STRIKETHROUGH:

      g_value_set_boolean (value, celltext->strikethrough);

      break;

    case PROP_UNDERLINE:

      g_value_set_enum (value, celltext->underline_style);

      break;

    case PROP_RISE:

      g_value_set_int (value, celltext->rise);

      break;  

    case PROP_LANGUAGE:

      g_value_set_static_string (value, pango_language_to_string (priv->language));

      break;

    case PROP_ELLIPSIZE:

      g_value_set_enum (value, priv->ellipsize);

      break;

    case PROP_WRAP_MODE:

      g_value_set_enum (value, priv->wrap_mode);

      break;

    case PROP_WRAP_WIDTH:

      g_value_set_int (value, priv->wrap_width);

      break;

    case PROP_ALIGN:

      g_value_set_enum (value, priv->align);

      break;

    case PROP_BACKGROUND_SET:

      g_value_set_boolean (value, celltext->background_set);

      break;

    case PROP_FOREGROUND_SET:

      g_value_set_boolean (value, celltext->foreground_set);

      break;

    case PROP_FAMILY_SET:

    case PROP_STYLE_SET:

    case PROP_VARIANT_SET:

    case PROP_WEIGHT_SET:

    case PROP_STRETCH_SET:

    case PROP_SIZE_SET:

      {

	PangoFontMask mask = get_property_font_set_mask (param_id);

	g_value_set_boolean (value, (pango_font_description_get_set_fields (celltext->font) & mask) != 0);

	break;

      }

    case PROP_SCALE_SET:

      g_value_set_boolean (value, celltext->scale_set);

      break;

    case PROP_EDITABLE_SET:

      g_value_set_boolean (value, celltext->editable_set);

      break;

    case PROP_STRIKETHROUGH_SET:

      g_value_set_boolean (value, celltext->strikethrough_set);

      break;

    case PROP_UNDERLINE_SET:

      g_value_set_boolean (value, celltext->underline_set);

      break;

    case  PROP_RISE_SET:

      g_value_set_boolean (value, celltext->rise_set);

      break;

    case PROP_LANGUAGE_SET:

      g_value_set_boolean (value, priv->language_set);

      break;

    case PROP_ELLIPSIZE_SET:

      g_value_set_boolean (value, priv->ellipsize_set);

      break;

    case PROP_ALIGN_SET:

      g_value_set_boolean (value, priv->align_set);

      break;

    case PROP_WIDTH_CHARS:

      g_value_set_int (value, priv->width_chars);

      break;  

    case PROP_BACKGROUND:

    case PROP_FOREGROUND:

    case PROP_MARKUP:

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);

      break;

    }

}

static void

set_bg_color (GtkCellRendererText *celltext,

              GdkColor            *color)

{

  if (color)

    {

      if (!celltext->background_set)

        {

          celltext->background_set = TRUE;

          g_object_notify (G_OBJECT (celltext), "background-set");

        }

      celltext->background.red = color->red;

      celltext->background.green = color->green;

      celltext->background.blue = color->blue;

    }

  else

    {

      if (celltext->background_set)

        {

          celltext->background_set = FALSE;

          g_object_notify (G_OBJECT (celltext), "background-set");

        }

    }

}

static void

set_fg_color (GtkCellRendererText *celltext,

              GdkColor            *color)

{

  if (color)

    {

      if (!celltext->foreground_set)

        {

          celltext->foreground_set = TRUE;

          g_object_notify (G_OBJECT (celltext), "foreground-set");

        }

      celltext->foreground.red = color->red;

      celltext->foreground.green = color->green;

      celltext->foreground.blue = color->blue;

    }

  else

    {

      if (celltext->foreground_set)

        {

          celltext->foreground_set = FALSE;

          g_object_notify (G_OBJECT (celltext), "foreground-set");

        }

    }

}

static PangoFontMask

set_font_desc_fields (PangoFontDescription *desc,

		      PangoFontMask         to_set)