/* gtktexttag.c - text tag object

 *

 * Copyright (c) 1992-1994 The Regents of the University of California.

 * Copyright (c) 1994-1997 Sun Microsystems, Inc.

 * Copyright (c) 2000      Red Hat, Inc.

 * Tk -> Gtk port by Havoc Pennington <hp@redhat.com>

 *

 * This software is copyrighted by the Regents of the University of

 * California, Sun Microsystems, Inc., and other parties.  The

 * following terms apply to all files associated with the software

 * unless explicitly disclaimed in individual files.

 *

 * The authors hereby grant permission to use, copy, modify,

 * distribute, and license this software and its documentation for any

 * purpose, provided that existing copyright notices are retained in

 * all copies and that this notice is included verbatim in any

 * distributions. No written agreement, license, or royalty fee is

 * required for any of the authorized uses.  Modifications to this

 * software may be copyrighted by their authors and need not follow

 * the licensing terms described here, provided that the new terms are

 * clearly indicated on the first page of each file where they apply.

 *

 * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY

 * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

 * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,

 * OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED

 * OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND

 * NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,

 * AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE

 * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 *

 * GOVERNMENT USE: If you are acquiring this software on behalf of the

 * U.S. government, the Government shall have only "Restricted Rights"

 * in the software and related documentation as defined in the Federal

 * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you

 * are acquiring the software on behalf of the Department of Defense,

 * the software shall be classified as "Commercial Computer Software"

 * and the Government shall have only "Restricted Rights" as defined

 * in Clause 252.227-7013 (c) (1) of DFARs.  Notwithstanding the

 * foregoing, the authors grant the U.S. Government and others acting

 * in its behalf permission to use and distribute the software in

 * accordance with the terms specified in this license.

 *

 */

#include "config.h"

#include "gtkmain.h"

#include "gtktexttag.h"

#include "gtktexttypes.h"

#include "gtktexttagtable.h"

#include "gtkintl.h"

#include "gtkmarshalers.h"

#include "gtkprivate.h"

#include "gtkalias.h"

#include <stdlib.h>

#include <string.h>

enum {

  EVENT,

  LAST_SIGNAL

};

enum {

  PROP_0,

  /* Construct args */

  PROP_NAME,

  /* Style args */

  PROP_BACKGROUND,

  PROP_FOREGROUND,

  PROP_BACKGROUND_GDK,

  PROP_FOREGROUND_GDK,

  PROP_BACKGROUND_STIPPLE,

  PROP_FOREGROUND_STIPPLE,

  PROP_FONT,

  PROP_FONT_DESC,

  PROP_FAMILY,

  PROP_STYLE,

  PROP_VARIANT,

  PROP_WEIGHT,

  PROP_STRETCH,

  PROP_SIZE,

  PROP_SIZE_POINTS,

  PROP_SCALE,

  PROP_PIXELS_ABOVE_LINES,

  PROP_PIXELS_BELOW_LINES,

  PROP_PIXELS_INSIDE_WRAP,

  PROP_EDITABLE,

  PROP_WRAP_MODE,

  PROP_JUSTIFICATION,

  PROP_DIRECTION,

  PROP_LEFT_MARGIN,

  PROP_INDENT,

  PROP_STRIKETHROUGH,

  PROP_RIGHT_MARGIN,

  PROP_UNDERLINE,

  PROP_RISE,

  PROP_BACKGROUND_FULL_HEIGHT,

  PROP_LANGUAGE,

  PROP_TABS,

  PROP_INVISIBLE,

  PROP_PARAGRAPH_BACKGROUND,

  PROP_PARAGRAPH_BACKGROUND_GDK,

  /* Behavior args */

  PROP_ACCUMULATIVE_MARGIN,

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

  PROP_BACKGROUND_SET,

  PROP_FOREGROUND_SET,

  PROP_BACKGROUND_STIPPLE_SET,

  PROP_FOREGROUND_STIPPLE_SET,

  PROP_FAMILY_SET,

  PROP_STYLE_SET,

  PROP_VARIANT_SET,

  PROP_WEIGHT_SET,

  PROP_STRETCH_SET,

  PROP_SIZE_SET,

  PROP_SCALE_SET,

  PROP_PIXELS_ABOVE_LINES_SET,

  PROP_PIXELS_BELOW_LINES_SET,

  PROP_PIXELS_INSIDE_WRAP_SET,

  PROP_EDITABLE_SET,

  PROP_WRAP_MODE_SET,

  PROP_JUSTIFICATION_SET,

  PROP_LEFT_MARGIN_SET,

  PROP_INDENT_SET,

  PROP_STRIKETHROUGH_SET,

  PROP_RIGHT_MARGIN_SET,

  PROP_UNDERLINE_SET,

  PROP_RISE_SET,

  PROP_BACKGROUND_FULL_HEIGHT_SET,

  PROP_LANGUAGE_SET,

  PROP_TABS_SET,

  PROP_INVISIBLE_SET,

  PROP_PARAGRAPH_BACKGROUND_SET,

  LAST_ARG

};

static void gtk_text_tag_finalize     (GObject         *object);

static void gtk_text_tag_set_property (GObject         *object,

                                       guint            prop_id,

                                       const GValue    *value,

                                       GParamSpec      *pspec);

static void gtk_text_tag_get_property (GObject         *object,

                                       guint            prop_id,

                                       GValue          *value,

                                       GParamSpec      *pspec);

static guint signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE (GtkTextTag, gtk_text_tag, G_TYPE_OBJECT)

static void

gtk_text_tag_class_init (GtkTextTagClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->set_property = gtk_text_tag_set_property;

  object_class->get_property = gtk_text_tag_get_property;

  object_class->finalize = gtk_text_tag_finalize;

  /* Construct */

  g_object_class_install_property (object_class,

                                   PROP_NAME,

                                   g_param_spec_string ("name",

                                                        P_("Tag name"),

                                                        P_("Name used to refer to the text tag. NULL for anonymous tags"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

  /* Style args */

  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 (possibly unallocated) GdkColor"),

                                                       GDK_TYPE_COLOR,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_BACKGROUND_FULL_HEIGHT,

                                   g_param_spec_boolean ("background-full-height",

                                                         P_("Background full height"),

                                                         P_("Whether the background color fills the entire line height or only the height of the tagged characters"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_BACKGROUND_STIPPLE,

                                   g_param_spec_object ("background-stipple",

                                                        P_("Background stipple mask"),

                                                        P_("Bitmap to use as a mask when drawing the text background"),

                                                        GDK_TYPE_PIXMAP,

                                                        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 (possibly unallocated) GdkColor"),

                                                       GDK_TYPE_COLOR,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_FOREGROUND_STIPPLE,

                                   g_param_spec_object ("foreground-stipple",

                                                        P_("Foreground stipple mask"),

                                                        P_("Bitmap to use as a mask when drawing the text foreground"),

                                                        GDK_TYPE_PIXMAP,

                                                        GTK_PARAM_READWRITE));  

  g_object_class_install_property (object_class,

                                   PROP_DIRECTION,

                                   g_param_spec_enum ("direction",

                                                      P_("Text direction"),

                                                      P_("Text direction, e.g. right-to-left or left-to-right"),

                                                      GTK_TYPE_TEXT_DIRECTION,

                                                      GTK_TEXT_DIR_NONE,

                                                      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"),

                                                         TRUE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkTextTag:font:

   *

   * Font description as string, e.g. \"Sans Italic 12\". 

   *

   * Note that the initial value of this property depends on

   * the internals of #PangoFontDescription.

   */

  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 as a PangoStyle, e.g. PANGO_STYLE_ITALIC"),

                                                      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 as a PangoVariant, e.g. PANGO_VARIANT_SMALL_CAPS"),

                                                      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 as an integer, see predefined values in PangoWeight; for example, PANGO_WEIGHT_BOLD"),

                                                     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 as a PangoStretch, e.g. PANGO_STRETCH_CONDENSED"),

                                                      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 in Pango units"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SCALE,

                                   g_param_spec_double ("scale",

                                                        P_("Font scale"),

                                                        P_("Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE"),

                                                        0.0,

                                                        G_MAXDOUBLE,

                                                        1.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_JUSTIFICATION,

                                   g_param_spec_enum ("justification",

                                                      P_("Justification"),

                                                      P_("Left, right, or center justification"),

                                                      GTK_TYPE_JUSTIFICATION,

                                                      GTK_JUSTIFY_LEFT,

                                                      GTK_PARAM_READWRITE));

  /**

   * GtkTextTag:language:

   *

   * The language this text is in, as an ISO code. Pango can use this as a 

   * hint when rendering the text. If not set, an appropriate default will be 

   * used.

   *

   * Note that the initial value of this property depends on the current

   * locale, see also gtk_get_default_language().

   */

  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 not set, an appropriate default will be used."),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));  

  g_object_class_install_property (object_class,

                                   PROP_LEFT_MARGIN,

                                   g_param_spec_int ("left-margin",

                                                     P_("Left margin"),

                                                     P_("Width of the left margin in pixels"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_RIGHT_MARGIN,

                                   g_param_spec_int ("right-margin",

                                                     P_("Right margin"),

                                                     P_("Width of the right margin in pixels"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_INDENT,

                                   g_param_spec_int ("indent",

                                                     P_("Indent"),

                                                     P_("Amount to indent the paragraph, in pixels"),

                                                     G_MININT,

                                                     G_MAXINT,

                                                     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) in Pango units"),

						     G_MININT,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_PIXELS_ABOVE_LINES,

                                   g_param_spec_int ("pixels-above-lines",

                                                     P_("Pixels above lines"),

                                                     P_("Pixels of blank space above paragraphs"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_PIXELS_BELOW_LINES,

                                   g_param_spec_int ("pixels-below-lines",

                                                     P_("Pixels below lines"),

                                                     P_("Pixels of blank space below paragraphs"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_PIXELS_INSIDE_WRAP,

                                   g_param_spec_int ("pixels-inside-wrap",

                                                     P_("Pixels inside wrap"),

                                                     P_("Pixels of blank space between wrapped lines in a paragraph"),

                                                     0,

                                                     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_WRAP_MODE,

                                   g_param_spec_enum ("wrap-mode",

                                                     P_("Wrap mode"),

                                                     P_("Whether to wrap lines never, at word boundaries, or at character boundaries"),

                                                      GTK_TYPE_WRAP_MODE,

                                                      GTK_WRAP_NONE,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_TABS,

                                   g_param_spec_boxed ("tabs",

                                                       P_("Tabs"),

                                                       P_("Custom tabs for this text"),

                                                       PANGO_TYPE_TAB_ARRAY,

                                                       GTK_PARAM_READWRITE));

  /**

   * GtkTextTag:invisible:

   *

   * Whether this text is hidden.

   *

   * Note that there may still be problems with the support for invisible 

   * text, in particular when navigating programmatically inside a buffer

   * containing invisible segments. 

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

                                   PROP_INVISIBLE,

                                   g_param_spec_boolean ("invisible",

                                                         P_("Invisible"),

                                                         P_("Whether this text is hidden."),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkTextTag:paragraph-background:

   *

   * The paragraph background color as a string.

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

                                   PROP_PARAGRAPH_BACKGROUND,

                                   g_param_spec_string ("paragraph-background",

                                                        P_("Paragraph background color name"),

                                                        P_("Paragraph background color as a string"),

                                                        NULL,

                                                        GTK_PARAM_WRITABLE));

  /**

   * GtkTextTag:paragraph-background-gdk:

   *

   * The paragraph background color as a as a (possibly unallocated) 

   * #GdkColor.

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

                                   PROP_PARAGRAPH_BACKGROUND_GDK,

                                   g_param_spec_boxed ("paragraph-background-gdk",

                                                       P_("Paragraph background color"),

                                                       P_("Paragraph background color as a (possibly unallocated) GdkColor"),

                                                       GDK_TYPE_COLOR,

                                                       GTK_PARAM_READWRITE));

  /**

   * GtkTextTag:accumulative-margin:

   *

   * Whether the margins accumulate or override each other.

   *

   * When set to %TRUE the margins of this tag are added to the margins 

   * of any other non-accumulative margins present. When set to %FALSE 

   * the margins override one another (the default).

   *

   * Since: 2.12

   */

  g_object_class_install_property (object_class,

                                   PROP_ACCUMULATIVE_MARGIN,

                                   g_param_spec_boolean ("accumulative-margin",

                                                         P_("Margin Accumulates"),

                                                         P_("Whether left and right margins accumulate."),

                                                         FALSE,

                                                         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 ("background-full-height-set", PROP_BACKGROUND_FULL_HEIGHT_SET,

                P_("Background full height set"),

                P_("Whether this tag affects background height"));

  ADD_SET_PROP ("background-stipple-set", PROP_BACKGROUND_STIPPLE_SET,

                P_("Background stipple set"),

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

  ADD_SET_PROP ("foreground-set", PROP_FOREGROUND_SET,

                P_("Foreground set"),

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

  ADD_SET_PROP ("foreground-stipple-set", PROP_FOREGROUND_STIPPLE_SET,

                P_("Foreground stipple set"),

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

  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 ("justification-set", PROP_JUSTIFICATION_SET,

                P_("Justification set"),

                P_("Whether this tag affects paragraph justification"));

  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 ("left-margin-set", PROP_LEFT_MARGIN_SET,

                P_("Left margin set"),

                P_("Whether this tag affects the left margin"));

  ADD_SET_PROP ("indent-set", PROP_INDENT_SET,

                P_("Indent set"),

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

  ADD_SET_PROP ("rise-set", PROP_RISE_SET,

                P_("Rise set"),

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

  ADD_SET_PROP ("pixels-above-lines-set", PROP_PIXELS_ABOVE_LINES_SET,

                P_("Pixels above lines set"),

                P_("Whether this tag affects the number of pixels above lines"));

  ADD_SET_PROP ("pixels-below-lines-set", PROP_PIXELS_BELOW_LINES_SET,

                P_("Pixels below lines set"),

                P_("Whether this tag affects the number of pixels above lines"));

  ADD_SET_PROP ("pixels-inside-wrap-set", PROP_PIXELS_INSIDE_WRAP_SET,

                P_("Pixels inside wrap set"),

                P_("Whether this tag affects the number of pixels between wrapped lines"));

  ADD_SET_PROP ("strikethrough-set", PROP_STRIKETHROUGH_SET,

                P_("Strikethrough set"),

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

  ADD_SET_PROP ("right-margin-set", PROP_RIGHT_MARGIN_SET,

                P_("Right margin set"),

                P_("Whether this tag affects the right margin"));

  ADD_SET_PROP ("underline-set", PROP_UNDERLINE_SET,

                P_("Underline set"),

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

  ADD_SET_PROP ("wrap-mode-set", PROP_WRAP_MODE_SET,

                P_("Wrap mode set"),

                P_("Whether this tag affects line wrap mode"));

  ADD_SET_PROP ("tabs-set", PROP_TABS_SET,

                P_("Tabs set"),

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

  ADD_SET_PROP ("invisible-set", PROP_INVISIBLE_SET,

                P_("Invisible set"),

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

  ADD_SET_PROP ("paragraph-background-set", PROP_PARAGRAPH_BACKGROUND_SET,

                P_("Paragraph background set"),

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

  /**

   * GtkTextTag::event:

   * @tag: the #GtkTextTag on which the signal is emitted

   * @object: the object the event was fired from (typically a #GtkTextView)

   * @event: the event which triggered the signal

   * @iter: a #GtkTextIter pointing at the location the event occured

   *

   * The ::event signal is emitted when an event occurs on a region of the

   * buffer marked with this tag.

   *

   * Returns: %TRUE to stop other handlers from being invoked for the

   * event. %FALSE to propagate the event further.

   */

  signals[EVENT] =

    g_signal_new (I_("event"),

                  G_OBJECT_CLASS_TYPE (object_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkTextTagClass, event),

                  _gtk_boolean_handled_accumulator, NULL,

                  _gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXED,

                  G_TYPE_BOOLEAN,

                  3,

                  G_TYPE_OBJECT,

                  GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,

                  GTK_TYPE_TEXT_ITER);

}

static void

gtk_text_tag_init (GtkTextTag *text_tag)

{

  text_tag->values = gtk_text_attributes_new ();

}

/**

 * gtk_text_tag_new:

 * @name: (allow-none): tag name, or %NULL

 * 

 * Creates a #GtkTextTag. Configure the tag using object arguments,

 * i.e. using g_object_set().

 * 

 * Return value: a new #GtkTextTag

 **/

GtkTextTag*

gtk_text_tag_new (const gchar *name)

{

  GtkTextTag *tag;

  tag = g_object_new (GTK_TYPE_TEXT_TAG, "name", name, NULL);

  return tag;

}

static void

gtk_text_tag_finalize (GObject *object)

{

  GtkTextTag *text_tag;

  text_tag = GTK_TEXT_TAG (object);

  g_assert (!text_tag->values->realized);

  if (text_tag->table)

    gtk_text_tag_table_remove (text_tag->table, text_tag);

  g_assert (text_tag->table == NULL);

  gtk_text_attributes_unref (text_tag->values);

  text_tag->values = NULL;

  g_free (text_tag->name);

  text_tag->name = NULL;

  G_OBJECT_CLASS (gtk_text_tag_parent_class)->finalize (object);

}

static void

set_bg_color (GtkTextTag *tag, GdkColor *color)

{

  if (color)

    {

      if (!tag->bg_color_set)

        {

          tag->bg_color_set = TRUE;

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

        }

      tag->values->appearance.bg_color = *color;

    }

  else

    {

      if (tag->bg_color_set)

        {

          tag->bg_color_set = FALSE;

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

        }

    }

}

static void

set_fg_color (GtkTextTag *tag, GdkColor *color)

{

  if (color)

    {

      if (!tag->fg_color_set)

        {

          tag->fg_color_set = TRUE;

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

        }

      tag->values->appearance.fg_color = *color;

    }

  else

    {

      if (tag->fg_color_set)

        {

          tag->fg_color_set = FALSE;

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

        }

    }

}

static void

set_pg_bg_color (GtkTextTag *tag, GdkColor *color)

{

  if (color)

    {

      if (!tag->pg_bg_color_set)

        {

          tag->pg_bg_color_set = TRUE;

          g_object_notify (G_OBJECT (tag), "paragraph-background-set");

        }

      else

	gdk_color_free (tag->values->pg_bg_color);

      tag->values->pg_bg_color = gdk_color_copy (color);

    }

  else

    {

      if (tag->pg_bg_color_set)

        {

          tag->pg_bg_color_set = FALSE;

          g_object_notify (G_OBJECT (tag), "paragraph-background-set");

	  gdk_color_free (tag->values->pg_bg_color);

        }

      tag->values->pg_bg_color = NULL;

    }

}

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 PangoFontMask

set_font_desc_fields (PangoFontDescription *desc,

		      PangoFontMask         to_set)

{

  PangoFontMask changed_mask = 0;

  if (to_set & PANGO_FONT_MASK_FAMILY)

    {

      const char *family = pango_font_description_get_family (desc);

      if (!family)

	{

	  family = "sans";

	  changed_mask |= PANGO_FONT_MASK_FAMILY;

	}

      pango_font_description_set_family (desc, family);

    }

  if (to_set & PANGO_FONT_MASK_STYLE)

    pango_font_description_set_style (desc, pango_font_description_get_style (desc));

  if (to_set & PANGO_FONT_MASK_VARIANT)

    pango_font_description_set_variant (desc, pango_font_description_get_variant (desc));

  if (to_set & PANGO_FONT_MASK_WEIGHT)

    pango_font_description_set_weight (desc, pango_font_description_get_weight (desc));

  if (to_set & PANGO_FONT_MASK_STRETCH)

    pango_font_description_set_stretch (desc, pango_font_description_get_stretch (desc));

  if (to_set & PANGO_FONT_MASK_SIZE)

    {

      gint size = pango_font_description_get_size (desc);

      if (size <= 0)

	{

	  size = 10 * PANGO_SCALE;

	  changed_mask |= PANGO_FONT_MASK_SIZE;

	}

      pango_font_description_set_size (desc, size);

    }