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

   1 /* gtktexttag.c - text tag object
   2  *
   3  * Copyright (c) 1992-1994 The Regents of the University of California.
   4  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
   5  * Copyright (c) 2000      Red Hat, Inc.
   6  * Tk -> Gtk port by Havoc Pennington <hp@redhat.com>
   7  *
   8  * This software is copyrighted by the Regents of the University of
   9  * California, Sun Microsystems, Inc., and other parties.  The
  10  * following terms apply to all files associated with the software
  11  * unless explicitly disclaimed in individual files.
  12  *
  13  * The authors hereby grant permission to use, copy, modify,
  14  * distribute, and license this software and its documentation for any
  15  * purpose, provided that existing copyright notices are retained in
  16  * all copies and that this notice is included verbatim in any
  17  * distributions. No written agreement, license, or royalty fee is
  18  * required for any of the authorized uses.  Modifications to this
  19  * software may be copyrighted by their authors and need not follow
  20  * the licensing terms described here, provided that the new terms are
  21  * clearly indicated on the first page of each file where they apply.
  22  *
  23  * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY
  24  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
  25  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,
  26  * OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED
  27  * OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
  30  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  31  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
  32  * NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
  33  * AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
  34  * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  35  *
  36  * GOVERNMENT USE: If you are acquiring this software on behalf of the
  37  * U.S. government, the Government shall have only "Restricted Rights"
  38  * in the software and related documentation as defined in the Federal
  39  * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
  40  * are acquiring the software on behalf of the Department of Defense,
  41  * the software shall be classified as "Commercial Computer Software"
  42  * and the Government shall have only "Restricted Rights" as defined
  43  * in Clause 252.227-7013 (c) (1) of DFARs.  Notwithstanding the
  44  * foregoing, the authors grant the U.S. Government and others acting
  45  * in its behalf permission to use and distribute the software in
  46  * accordance with the terms specified in this license.
  47  *
  48  */
  49
  50 #include "gtkmain.h"
  51 #include "gtktexttag.h"
  52 #include "gtktexttypes.h"
  53 #include "gtktexttagtable.h"
  54 #include "gtksignal.h"
  55 #include "gtkmain.h"
  56 #include "gtkintl.h"
  57 #include "gtkmarshalers.h"
  58 #include "gtktypebuiltins.h"
  59
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 enum {
  64   EVENT,
  65   LAST_SIGNAL
  66 };
  67
  68 enum {
  69   PROP_0,
  70   /* Construct args */
  71   PROP_NAME,
  72
  73   /* Style args */
  74   PROP_BACKGROUND,
  75   PROP_FOREGROUND,
  76   PROP_BACKGROUND_GDK,
  77   PROP_FOREGROUND_GDK,
  78   PROP_BACKGROUND_STIPPLE,
  79   PROP_FOREGROUND_STIPPLE,
  80   PROP_FONT,
  81   PROP_FONT_DESC,
  82   PROP_FAMILY,
  83   PROP_STYLE,
  84   PROP_VARIANT,
  85   PROP_WEIGHT,
  86   PROP_STRETCH,
  87   PROP_SIZE,
  88   PROP_SIZE_POINTS,
  89   PROP_SCALE,
  90   PROP_PIXELS_ABOVE_LINES,
  91   PROP_PIXELS_BELOW_LINES,
  92   PROP_PIXELS_INSIDE_WRAP,
  93   PROP_EDITABLE,
  94   PROP_WRAP_MODE,
  95   PROP_JUSTIFICATION,
  96   PROP_DIRECTION,
  97   PROP_LEFT_MARGIN,
  98   PROP_INDENT,
  99   PROP_STRIKETHROUGH,
 100   PROP_RIGHT_MARGIN,
 101   PROP_UNDERLINE,
 102   PROP_RISE,
 103   PROP_BG_FULL_HEIGHT,
 104   PROP_LANGUAGE,
 105   PROP_TABS,
 106   PROP_INVISIBLE,
 107
 108   /* Whether-a-style-arg-is-set args */
 109   PROP_BACKGROUND_SET,
 110   PROP_FOREGROUND_SET,
 111   PROP_BACKGROUND_STIPPLE_SET,
 112   PROP_FOREGROUND_STIPPLE_SET,
 113   PROP_FAMILY_SET,
 114   PROP_STYLE_SET,
 115   PROP_VARIANT_SET,
 116   PROP_WEIGHT_SET,
 117   PROP_STRETCH_SET,
 118   PROP_SIZE_SET,
 119   PROP_SCALE_SET,
 120   PROP_PIXELS_ABOVE_LINES_SET,
 121   PROP_PIXELS_BELOW_LINES_SET,
 122   PROP_PIXELS_INSIDE_WRAP_SET,
 123   PROP_EDITABLE_SET,
 124   PROP_WRAP_MODE_SET,
 125   PROP_JUSTIFICATION_SET,
 126   PROP_LEFT_MARGIN_SET,
 127   PROP_INDENT_SET,
 128   PROP_STRIKETHROUGH_SET,
 129   PROP_RIGHT_MARGIN_SET,
 130   PROP_UNDERLINE_SET,
 131   PROP_RISE_SET,
 132   PROP_BG_FULL_HEIGHT_SET,
 133   PROP_LANGUAGE_SET,
 134   PROP_TABS_SET,
 135   PROP_INVISIBLE_SET,
 136
 137   LAST_ARG
 138 };
 139 static void gtk_text_tag_init         (GtkTextTag      *text_tag);
 140 static void gtk_text_tag_class_init   (GtkTextTagClass *klass);
 141 static void gtk_text_tag_finalize     (GObject         *object);
 142 static void gtk_text_tag_set_property (GObject         *object,
 143                                        guint            prop_id,
 144                                        const GValue    *value,
 145                                        GParamSpec      *pspec);
 146 static void gtk_text_tag_get_property (GObject         *object,
 147                                        guint            prop_id,
 148                                        GValue          *value,
 149                                        GParamSpec      *pspec);
 150
 151 static GObjectClass *parent_class = NULL;
 152 static guint signals[LAST_SIGNAL] = { 0 };
 153
 154 GType
 155 gtk_text_tag_get_type (void)
 156 {
 157   static GType our_type = 0;
 158
 159   if (our_type == 0)
 160     {
 161       static const GTypeInfo our_info =
 162       {
 163         sizeof (GtkTextTagClass),
 164         (GBaseInitFunc) NULL,
 165         (GBaseFinalizeFunc) NULL,
 166         (GClassInitFunc) gtk_text_tag_class_init,
 167         NULL,           /* class_finalize */
 168         NULL,           /* class_data */
 169         sizeof (GtkTextTag),
 170         0,              /* n_preallocs */
 171         (GInstanceInitFunc) gtk_text_tag_init
 172       };
 173
 174       our_type = g_type_register_static (G_TYPE_OBJECT,
 175                                          "GtkTextTag",
 176                                          &our_info,
 177                                          0);
 178     }
 179
 180   return our_type;
 181 }
 182
 183 static void
 184 gtk_text_tag_class_init (GtkTextTagClass *klass)
 185 {
 186   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 187
 188   parent_class = g_type_class_peek_parent (klass);
 189
 190   object_class->set_property = gtk_text_tag_set_property;
 191   object_class->get_property = gtk_text_tag_get_property;
 192
 193   object_class->finalize = gtk_text_tag_finalize;
 194
 195   /* Construct */
 196   g_object_class_install_property (object_class,
 197                                    PROP_NAME,
 198                                    g_param_spec_string ("name",
 199                                                         _("Tag name"),
 200                                                         _("Name used to refer to the text tag"),
 201                                                         NULL,
 202                                                         G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 203
 204   /* Style args */
 205
 206   g_object_class_install_property (object_class,
 207                                    PROP_BACKGROUND,
 208                                    g_param_spec_string ("background",
 209                                                         _("Background color name"),
 210                                                         _("Background color as a string"),
 211                                                         NULL,
 212                                                         G_PARAM_WRITABLE));
 213
 214   g_object_class_install_property (object_class,
 215                                    PROP_BACKGROUND_GDK,
 216                                    g_param_spec_boxed ("background_gdk",
 217                                                        _("Background color"),
 218                                                        _("Background color as a GdkColor"),
 219                                                        GDK_TYPE_COLOR,
 220                                                        G_PARAM_READABLE | G_PARAM_WRITABLE));
 221
 222   g_object_class_install_property (object_class,
 223                                    PROP_BG_FULL_HEIGHT,
 224                                    g_param_spec_boolean ("background_full_height",
 225                                                          _("Background full height"),
 226                                                          _("Whether the background color fills the entire line height or only the height of the tagged characters"),
 227                                                          FALSE,
 228                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 229
 230
 231   g_object_class_install_property (object_class,
 232                                    PROP_BACKGROUND_STIPPLE,
 233                                    g_param_spec_object ("background_stipple",
 234                                                         _("Background stipple mask"),
 235                                                         _("Bitmap to use as a mask when drawing the text background"),
 236                                                         GDK_TYPE_PIXMAP,
 237                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 238
 239
 240   g_object_class_install_property (object_class,
 241                                    PROP_FOREGROUND,
 242                                    g_param_spec_string ("foreground",
 243                                                         _("Foreground color name"),
 244                                                         _("Foreground color as a string"),
 245                                                         NULL,
 246                                                         G_PARAM_WRITABLE));
 247
 248   g_object_class_install_property (object_class,
 249                                    PROP_FOREGROUND_GDK,
 250                                    g_param_spec_boxed ("foreground_gdk",
 251                                                        _("Foreground color"),
 252                                                        _("Foreground color as a GdkColor"),
 253                                                        GDK_TYPE_COLOR,
 254                                                        G_PARAM_READABLE | G_PARAM_WRITABLE));
 255
 256
 257   g_object_class_install_property (object_class,
 258                                    PROP_FOREGROUND_STIPPLE,
 259                                    g_param_spec_object ("foreground_stipple",
 260                                                         _("Foreground stipple mask"),
 261                                                         _("Bitmap to use as a mask when drawing the text foreground"),
 262                                                         GDK_TYPE_PIXMAP,
 263                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 264
 265   g_object_class_install_property (object_class,
 266                                    PROP_DIRECTION,
 267                                    g_param_spec_enum ("direction",
 268                                                       _("Text direction"),
 269                                                       _("Text direction, e.g. right-to-left or left-to-right"),
 270                                                       GTK_TYPE_TEXT_DIRECTION,
 271                                                       GTK_TEXT_DIR_LTR,
 272                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 273
 274   g_object_class_install_property (object_class,
 275                                    PROP_EDITABLE,
 276                                    g_param_spec_boolean ("editable",
 277                                                          _("Editable"),
 278                                                          _("Whether the text can be modified by the user"),
 279                                                          TRUE,
 280                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 281
 282   g_object_class_install_property (object_class,
 283                                    PROP_FONT,
 284                                    g_param_spec_string ("font",
 285                                                         _("Font"),
 286                                                         _("Font description as a string"),
 287                                                         NULL,
 288                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 289
 290   g_object_class_install_property (object_class,
 291                                    PROP_FONT_DESC,
 292                                    g_param_spec_boxed ("font_desc",
 293                                                        _("Font"),
 294                                                        _("Font description as a PangoFontDescription struct"),
 295                                                        PANGO_TYPE_FONT_DESCRIPTION,
 296                                                        G_PARAM_READABLE | G_PARAM_WRITABLE));
 297
 298
 299   g_object_class_install_property (object_class,
 300                                    PROP_FAMILY,
 301                                    g_param_spec_string ("family",
 302                                                         _("Font family"),
 303                                                         _("Name of the font family, e.g. Sans, Helvetica, Times, Monospace"),
 304                                                         NULL,
 305                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 306
 307   g_object_class_install_property (object_class,
 308                                    PROP_STYLE,
 309                                    g_param_spec_enum ("style",
 310                                                       _("Font style"),
 311                                                       _("Font style"),
 312                                                       PANGO_TYPE_STYLE,
 313                                                       PANGO_STYLE_NORMAL,
 314                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 315
 316   g_object_class_install_property (object_class,
 317                                    PROP_VARIANT,
 318                                    g_param_spec_enum ("variant",
 319                                                      _("Font variant"),
 320                                                      _("Font variant"),
 321                                                       PANGO_TYPE_VARIANT,
 322                                                       PANGO_VARIANT_NORMAL,
 323                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 324
 325   g_object_class_install_property (object_class,
 326                                    PROP_WEIGHT,
 327                                    g_param_spec_int ("weight",
 328                                                      _("Font weight"),
 329                                                      _("Font weight"),
 330                                                      0,
 331                                                      G_MAXINT,
 332                                                      PANGO_WEIGHT_NORMAL,
 333                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 334
 335
 336   g_object_class_install_property (object_class,
 337                                    PROP_STRETCH,
 338                                    g_param_spec_enum ("stretch",
 339                                                       _("Font stretch"),
 340                                                       _("Font stretch"),
 341                                                       PANGO_TYPE_STRETCH,
 342                                                       PANGO_STRETCH_NORMAL,
 343                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 344
 345   g_object_class_install_property (object_class,
 346                                    PROP_SIZE,
 347                                    g_param_spec_int ("size",
 348                                                      _("Font size"),
 349                                                      _("Font size"),
 350                                                      0,
 351                                                      G_MAXINT,
 352                                                      0,
 353                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 354
 355   g_object_class_install_property (object_class,
 356                                    PROP_SCALE,
 357                                    g_param_spec_double ("scale",
 358                                                         _("Font scale"),
 359                                                         _("Font scale"),
 360                                                         0.0,
 361                                                         G_MAXDOUBLE,
 362                                                         1.0,
 363                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 364
 365   g_object_class_install_property (object_class,
 366                                    PROP_SIZE_POINTS,
 367                                    g_param_spec_double ("size_points",
 368                                                         _("Font points"),
 369                                                         _("Font size in points"),
 370                                                         0.0,
 371                                                         G_MAXDOUBLE,
 372                                                         0.0,
 373                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 374
 375   g_object_class_install_property (object_class,
 376                                    PROP_JUSTIFICATION,
 377                                    g_param_spec_enum ("justification",
 378                                                       _("Justification"),
 379                                                       _("Left, right, or center justification"),
 380                                                       GTK_TYPE_JUSTIFICATION,
 381                                                       GTK_JUSTIFY_LEFT,
 382                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 383
 384   g_object_class_install_property (object_class,
 385                                    PROP_LANGUAGE,
 386                                    g_param_spec_string ("language",
 387                                                         _("Language"),
 388                                                         _("Language engine code to use for rendering the text"),
 389                                                         NULL,
 390                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 391
 392   g_object_class_install_property (object_class,
 393                                    PROP_LEFT_MARGIN,
 394                                    g_param_spec_int ("left_margin",
 395                                                      _("Left margin"),
 396                                                      _("Width of the left margin in pixels"),
 397                                                      0,
 398                                                      G_MAXINT,
 399                                                      0,
 400                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 401
 402   g_object_class_install_property (object_class,
 403                                    PROP_RIGHT_MARGIN,
 404                                    g_param_spec_int ("right_margin",
 405                                                      _("Right margin"),
 406                                                      _("Width of the right margin in pixels"),
 407                                                      0,
 408                                                      G_MAXINT,
 409                                                      0,
 410                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 411
 412
 413   g_object_class_install_property (object_class,
 414                                    PROP_INDENT,
 415                                    g_param_spec_int ("indent",
 416                                                      _("Indent"),
 417                                                      _("Amount to indent the paragraph, in pixels"),
 418                                                      G_MININT,
 419                                                      G_MAXINT,
 420                                                      0,
 421                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 422
 423
 424   g_object_class_install_property (object_class,
 425                                    PROP_RISE,
 426                                    g_param_spec_int ("rise",
 427                                                      _("Rise"),
 428                                                      _("Offset of text above the baseline (below the baseline if rise is negative)"),
 429                                                      G_MININT,
 430                                                      G_MAXINT,
 431                                                      0,
 432                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 433
 434   g_object_class_install_property (object_class,
 435                                    PROP_PIXELS_ABOVE_LINES,
 436                                    g_param_spec_int ("pixels_above_lines",
 437                                                      _("Pixels above lines"),
 438                                                      _("Pixels of blank space above paragraphs"),
 439                                                      0,
 440                                                      G_MAXINT,
 441                                                      0,
 442                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 443
 444   g_object_class_install_property (object_class,
 445                                    PROP_PIXELS_BELOW_LINES,
 446                                    g_param_spec_int ("pixels_below_lines",
 447                                                      _("Pixels below lines"),
 448                                                      _("Pixels of blank space below paragraphs"),
 449                                                      0,
 450                                                      G_MAXINT,
 451                                                      0,
 452                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 453
 454   g_object_class_install_property (object_class,
 455                                    PROP_PIXELS_INSIDE_WRAP,
 456                                    g_param_spec_int ("pixels_inside_wrap",
 457                                                      _("Pixels inside wrap"),
 458                                                      _("Pixels of blank space between wrapped lines in a paragraph"),
 459                                                      0,
 460                                                      G_MAXINT,
 461                                                      0,
 462                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
 463
 464   g_object_class_install_property (object_class,
 465                                    PROP_STRIKETHROUGH,
 466                                    g_param_spec_boolean ("strikethrough",
 467                                                          _("Strikethrough"),
 468                                                          _("Whether to strike through the text"),
 469                                                          FALSE,
 470                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 471
 472   g_object_class_install_property (object_class,
 473                                    PROP_UNDERLINE,
 474                                    g_param_spec_enum ("underline",
 475                                                       _("Underline"),
 476                                                       _("Style of underline for this text"),
 477                                                       PANGO_TYPE_UNDERLINE,
 478                                                       PANGO_UNDERLINE_NONE,
 479                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 480
 481   g_object_class_install_property (object_class,
 482                                    PROP_WRAP_MODE,
 483                                    g_param_spec_enum ("wrap_mode",
 484                                                      _("Wrap mode"),
 485                                                      _("Whether to wrap lines never, at word boundaries, or at character boundaries"),
 486                                                       GTK_TYPE_WRAP_MODE,
 487                                                       GTK_WRAP_NONE,
 488                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 489
 490
 491   g_object_class_install_property (object_class,
 492                                    PROP_TABS,
 493                                    g_param_spec_boxed ("tabs",
 494                                                        _("Tabs"),
 495                                                        _("Custom tabs for this text"),
 496                                                        PANGO_TYPE_TAB_ARRAY,
 497                                                        G_PARAM_READABLE | G_PARAM_WRITABLE));
 498
 499   g_object_class_install_property (object_class,
 500                                    PROP_INVISIBLE,
 501                                    g_param_spec_boolean ("invisible",
 502                                                          _("Invisible"),
 503                                                          _("Whether this text is hidden"),
 504                                                          FALSE,
 505                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 506
 507   /* Style props are set or not */
 508
 509 #define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE))
 510
 511   ADD_SET_PROP ("background_set", PROP_BACKGROUND_SET,
 512                 _("Background set"),
 513                 _("Whether this tag affects the background color"));
 514
 515   ADD_SET_PROP ("background_full_height_set", PROP_BG_FULL_HEIGHT_SET,
 516                 _("Background full height set"),
 517                 _("Whether this tag affects background height"));
 518
 519   ADD_SET_PROP ("background_stipple_set", PROP_BACKGROUND_STIPPLE_SET,
 520                 _("Background stipple set"),
 521                 _("Whether this tag affects the background stipple"));
 522
 523   ADD_SET_PROP ("foreground_set", PROP_FOREGROUND_SET,
 524                 _("Foreground set"),
 525                 _("Whether this tag affects the foreground color"));
 526
 527   ADD_SET_PROP ("foreground_stipple_set", PROP_FOREGROUND_STIPPLE_SET,
 528                 _("Foreground stipple set"),
 529                 _("Whether this tag affects the foreground stipple"));
 530
 531   ADD_SET_PROP ("editable_set", PROP_EDITABLE_SET,
 532                 _("Editability set"),
 533                 _("Whether this tag affects text editability"));
 534
 535   ADD_SET_PROP ("family_set", PROP_FAMILY_SET,
 536                 _("Font family set"),
 537                 _("Whether this tag affects the font family"));
 538
 539   ADD_SET_PROP ("style_set", PROP_STYLE_SET,
 540                 _("Font style set"),
 541                 _("Whether this tag affects the font style"));
 542
 543   ADD_SET_PROP ("variant_set", PROP_VARIANT_SET,
 544                 _("Font variant set"),
 545                 _("Whether this tag affects the font variant"));
 546
 547   ADD_SET_PROP ("weight_set", PROP_WEIGHT_SET,
 548                 _("Font weight set"),
 549                 _("Whether this tag affects the font weight"));
 550
 551   ADD_SET_PROP ("stretch_set", PROP_STRETCH_SET,
 552                 _("Font stretch set"),
 553                 _("Whether this tag affects the font stretch"));
 554
 555   ADD_SET_PROP ("size_set", PROP_SIZE_SET,
 556                 _("Font size set"),
 557                 _("Whether this tag affects the font size"));
 558
 559   ADD_SET_PROP ("scale_set", PROP_SCALE_SET,
 560                 _("Font scale set"),
 561                 _("Whether this tag scales the font size by a factor"));
 562
 563   ADD_SET_PROP ("justification_set", PROP_JUSTIFICATION_SET,
 564                 _("Justification set"),
 565                 _("Whether this tag affects paragraph justification"));
 566
 567   ADD_SET_PROP ("language_set", PROP_LANGUAGE_SET,
 568                 _("Language set"),
 569                 _("Whether this tag affects the language the text is rendered as"));
 570
 571   ADD_SET_PROP ("left_margin_set", PROP_LEFT_MARGIN_SET,
 572                 _("Left margin set"),
 573                 _("Whether this tag affects the left margin"));
 574
 575   ADD_SET_PROP ("indent_set", PROP_INDENT_SET,
 576                 _("Indent set"),
 577                 _("Whether this tag affects indentation"));
 578
 579   ADD_SET_PROP ("rise_set", PROP_RISE_SET,
 580                 _("Rise set"),
 581                 _("Whether this tag affects the rise"));
 582
 583   ADD_SET_PROP ("pixels_above_lines_set", PROP_PIXELS_ABOVE_LINES_SET,
 584                 _("Pixels above lines set"),
 585                 _("Whether this tag affects the number of pixels above lines"));
 586
 587   ADD_SET_PROP ("pixels_below_lines_set", PROP_PIXELS_BELOW_LINES_SET,
 588                 _("Pixels below lines set"),
 589                 _("Whether this tag affects the number of pixels above lines"));
 590
 591   ADD_SET_PROP ("pixels_inside_wrap_set", PROP_PIXELS_INSIDE_WRAP_SET,
 592                 _("Pixels inside wrap set"),
 593                 _("Whether this tag affects the number of pixels between wrapped lines"));
 594
 595   ADD_SET_PROP ("strikethrough_set", PROP_STRIKETHROUGH_SET,
 596                 _("Strikethrough set"),
 597                 _("Whether this tag affects strikethrough"));
 598
 599   ADD_SET_PROP ("right_margin_set", PROP_RIGHT_MARGIN_SET,
 600                 _("Right margin set"),
 601                 _("Whether this tag affects the right margin"));
 602
 603   ADD_SET_PROP ("underline_set", PROP_UNDERLINE_SET,
 604                 _("Underline set"),
 605                 _("Whether this tag affects underlining"));
 606
 607   ADD_SET_PROP ("wrap_mode_set", PROP_WRAP_MODE_SET,
 608                 _("Wrap mode set"),
 609                 _("Whether this tag affects line wrap mode"));
 610
 611   ADD_SET_PROP ("tabs_set", PROP_TABS_SET,
 612                 _("Tabs set"),
 613                 _("Whether this tag affects tabs"));
 614
 615   ADD_SET_PROP ("invisible_set", PROP_INVISIBLE_SET,
 616                 _("Invisible set"),
 617                 _("Whether this tag affects text visibility"));
 618
 619   signals[EVENT] =
 620     g_signal_new ("event",
 621                   G_OBJECT_CLASS_TYPE (object_class),
 622                   G_SIGNAL_RUN_LAST,
 623                   GTK_SIGNAL_OFFSET (GtkTextTagClass, event),
 624                   _gtk_boolean_handled_accumulator, NULL,
 625                   _gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXED,
 626                   G_TYPE_BOOLEAN,
 627                   3,
 628                   G_TYPE_OBJECT,
 629                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
 630                   GTK_TYPE_TEXT_ITER);
 631 }
 632
 633 static void
 634 gtk_text_tag_init (GtkTextTag *text_tag)
 635 {
 636   /* 0 is basically a fine way to initialize everything in the
 637      entire struct */
 638
 639   text_tag->values = gtk_text_attributes_new ();
 640 }
 641
 642 /**
 643  * gtk_text_tag_new:
 644  * @name: tag name, or %NULL
 645  *
 646  * Creates a #GtkTextTag. Configure the tag using object arguments,
 647  * i.e. using g_object_set().
 648  *
 649  * Return value: a new #GtkTextTag
 650  **/
 651 GtkTextTag*
 652 gtk_text_tag_new (const gchar *name)
 653 {
 654   GtkTextTag *tag;
 655
 656   tag = GTK_TEXT_TAG (g_object_new (gtk_text_tag_get_type (),
 657                                     "name", name,
 658                                     NULL));
 659
 660   return tag;
 661 }
 662
 663 static void
 664 gtk_text_tag_finalize (GObject *object)
 665 {
 666   GtkTextTag *text_tag;
 667
 668   text_tag = GTK_TEXT_TAG (object);
 669
 670   g_assert (!text_tag->values->realized);
 671
 672   if (text_tag->table)
 673     gtk_text_tag_table_remove (text_tag->table, text_tag);
 674
 675   g_assert (text_tag->table == NULL);
 676
 677   gtk_text_attributes_unref (text_tag->values);
 678   text_tag->values = NULL;
 679
 680   g_free (text_tag->name);
 681   text_tag->name = NULL;
 682
 683   (* G_OBJECT_CLASS (parent_class)->finalize) (object);
 684 }
 685
 686 static void
 687 set_bg_color (GtkTextTag *tag, GdkColor *color)
 688 {
 689   if (color)
 690     {
 691       if (!tag->bg_color_set)
 692         {
 693           tag->bg_color_set = TRUE;
 694           g_object_notify (G_OBJECT (tag), "background_set");
 695         }
 696
 697       tag->values->appearance.bg_color = *color;
 698     }
 699   else
 700     {
 701       if (tag->bg_color_set)
 702         {
 703           tag->bg_color_set = FALSE;
 704           g_object_notify (G_OBJECT (tag), "background_set");
 705         }
 706     }
 707 }
 708
 709 static void
 710 set_fg_color (GtkTextTag *tag, GdkColor *color)
 711 {
 712   if (color)
 713     {
 714       if (!tag->fg_color_set)
 715         {
 716           tag->fg_color_set = TRUE;
 717           g_object_notify (G_OBJECT (tag), "foreground_set");
 718         }
 719       tag->values->appearance.fg_color = *color;
 720     }
 721   else
 722     {
 723       if (tag->fg_color_set)
 724         {
 725           tag->fg_color_set = FALSE;
 726           g_object_notify (G_OBJECT (tag), "foreground_set");
 727         }
 728     }
 729 }
 730
 731 static PangoFontMask
 732 get_property_font_set_mask (guint prop_id)
 733 {
 734   switch (prop_id)
 735     {
 736     case PROP_FAMILY_SET:
 737       return PANGO_FONT_MASK_FAMILY;
 738     case PROP_STYLE_SET:
 739       return PANGO_FONT_MASK_STYLE;
 740     case PROP_VARIANT_SET:
 741       return PANGO_FONT_MASK_VARIANT;
 742     case PROP_WEIGHT_SET:
 743       return PANGO_FONT_MASK_WEIGHT;
 744     case PROP_STRETCH_SET:
 745       return PANGO_FONT_MASK_STRETCH;
 746     case PROP_SIZE_SET:
 747       return PANGO_FONT_MASK_SIZE;
 748     }
 749
 750   return 0;
 751 }
 752
 753 static PangoFontMask
 754 set_font_desc_fields (PangoFontDescription *desc,
 755                       PangoFontMask         to_set)
 756 {
 757   PangoFontMask changed_mask = 0;
 758
 759   if (to_set & PANGO_FONT_MASK_FAMILY)
 760     {
 761       const char *family = pango_font_description_get_family (desc);
 762       if (!family)
 763         {
 764           family = "sans";
 765           changed_mask |= PANGO_FONT_MASK_FAMILY;
 766         }
 767
 768       pango_font_description_set_family (desc, family);
 769     }
 770   if (to_set & PANGO_FONT_MASK_STYLE)
 771     pango_font_description_set_style (desc, pango_font_description_get_style (desc));
 772   if (to_set & PANGO_FONT_MASK_VARIANT)
 773     pango_font_description_set_variant (desc, pango_font_description_get_variant (desc));
 774   if (to_set & PANGO_FONT_MASK_WEIGHT)
 775     pango_font_description_set_weight (desc, pango_font_description_get_weight (desc));
 776   if (to_set & PANGO_FONT_MASK_STRETCH)
 777     pango_font_description_set_stretch (desc, pango_font_description_get_stretch (desc));
 778   if (to_set & PANGO_FONT_MASK_SIZE)
 779     {
 780       gint size = pango_font_description_get_size (desc);
 781       if (size <= 0)
 782         {
 783           size = 10 * PANGO_SCALE;
 784           changed_mask |= PANGO_FONT_MASK_SIZE;
 785         }
 786
 787       pango_font_description_set_size (desc, size);
 788     }
 789
 790   return changed_mask;
 791 }
 792
 793 static void
 794 notify_set_changed (GObject       *object,
 795                     PangoFontMask  changed_mask)
 796 {
 797   if (changed_mask & PANGO_FONT_MASK_FAMILY)
 798     g_object_notify (object, "family_set");
 799   if (changed_mask & PANGO_FONT_MASK_STYLE)
 800     g_object_notify (object, "style_set");
 801   if (changed_mask & PANGO_FONT_MASK_VARIANT)
 802     g_object_notify (object, "variant_set");
 803   if (changed_mask & PANGO_FONT_MASK_WEIGHT)
 804     g_object_notify (object, "weight_set");
 805   if (changed_mask & PANGO_FONT_MASK_STRETCH)
 806     g_object_notify (object, "stretch_set");
 807   if (changed_mask & PANGO_FONT_MASK_SIZE)
 808     g_object_notify (object, "size_set");
 809 }
 810
 811 static void
 812 notify_fields_changed (GObject       *object,
 813                        PangoFontMask  changed_mask)
 814 {
 815   if (changed_mask & PANGO_FONT_MASK_FAMILY)
 816     g_object_notify (object, "family");
 817   if (changed_mask & PANGO_FONT_MASK_STYLE)
 818     g_object_notify (object, "style");
 819   if (changed_mask & PANGO_FONT_MASK_VARIANT)
 820     g_object_notify (object, "variant");
 821   if (changed_mask & PANGO_FONT_MASK_WEIGHT)
 822     g_object_notify (object, "weight");
 823   if (changed_mask & PANGO_FONT_MASK_STRETCH)
 824     g_object_notify (object, "stretch");
 825   if (changed_mask & PANGO_FONT_MASK_SIZE)
 826     g_object_notify (object, "size");
 827 }
 828
 829 static void
 830 set_font_description (GtkTextTag           *text_tag,
 831                       PangoFontDescription *font_desc)
 832 {
 833   GObject *object = G_OBJECT (text_tag);
 834   PangoFontDescription *new_font_desc;
 835   PangoFontMask old_mask, new_mask, changed_mask, set_changed_mask;
 836
 837   if (font_desc)
 838     new_font_desc = pango_font_description_copy (font_desc);
 839   else
 840     new_font_desc = pango_font_description_new ();
 841
 842   if (text_tag->values->font)
 843     old_mask = pango_font_description_get_set_fields (text_tag->values->font);
 844   else
 845     old_mask = 0;
 846
 847   new_mask = pango_font_description_get_set_fields (new_font_desc);
 848
 849   changed_mask = old_mask | new_mask;
 850   set_changed_mask = old_mask ^ new_mask;
 851
 852   if (text_tag->values->font)
 853     pango_font_description_free (text_tag->values->font);
 854   text_tag->values->font = new_font_desc;
 855
 856   g_object_freeze_notify (object);
 857
 858   g_object_notify (object, "font_desc");
 859   g_object_notify (object, "font");
 860
 861   if (changed_mask & PANGO_FONT_MASK_FAMILY)
 862     g_object_notify (object, "family");
 863   if (changed_mask & PANGO_FONT_MASK_STYLE)
 864     g_object_notify (object, "style");
 865   if (changed_mask & PANGO_FONT_MASK_VARIANT)
 866     g_object_notify (object, "variant");
 867   if (changed_mask & PANGO_FONT_MASK_WEIGHT)
 868     g_object_notify (object, "weight");
 869   if (changed_mask & PANGO_FONT_MASK_STRETCH)
 870     g_object_notify (object, "stretch");
 871   if (changed_mask & PANGO_FONT_MASK_SIZE)
 872     {
 873       g_object_notify (object, "size");
 874       g_object_notify (object, "size_points");
 875     }
 876
 877   notify_set_changed (object, set_changed_mask);
 878
 879   g_object_thaw_notify (object);
 880 }
 881
 882 static void
 883 gtk_text_tag_ensure_font (GtkTextTag *text_tag)
 884 {
 885   if (!text_tag->values->font)
 886     text_tag->values->font = pango_font_description_new ();
 887 }
 888
 889 static void
 890 gtk_text_tag_set_property (GObject      *object,
 891                            guint         prop_id,
 892                            const GValue *value,
 893                            GParamSpec   *pspec)
 894 {
 895   GtkTextTag *text_tag;
 896   gboolean size_changed = FALSE;
 897
 898   text_tag = GTK_TEXT_TAG (object);
 899
 900   g_return_if_fail (!text_tag->values->realized);
 901
 902   switch (prop_id)
 903     {
 904     case PROP_NAME:
 905       g_return_if_fail (text_tag->name == NULL);
 906       text_tag->name = g_strdup (g_value_get_string (value));
 907       break;
 908
 909     case PROP_BACKGROUND:
 910       {
 911         GdkColor color;
 912
 913         if (gdk_color_parse (g_value_get_string (value), &color))
 914           set_bg_color (text_tag, &color);
 915         else
 916           g_warning ("Don't know color `%s'", g_value_get_string (value));
 917
 918         g_object_notify (object, "background_gdk");
 919       }
 920       break;
 921
 922     case PROP_FOREGROUND:
 923       {
 924         GdkColor color;
 925
 926         if (gdk_color_parse (g_value_get_string (value), &color))
 927           set_fg_color (text_tag, &color);
 928         else
 929           g_warning ("Don't know color `%s'", g_value_get_string (value));
 930
 931         g_object_notify (object, "foreground_gdk");
 932       }
 933       break;
 934
 935     case PROP_BACKGROUND_GDK:
 936       {
 937         GdkColor *color = g_value_get_boxed (value);
 938
 939         set_bg_color (text_tag, color);
 940       }
 941       break;
 942
 943     case PROP_FOREGROUND_GDK:
 944       {
 945         GdkColor *color = g_value_get_boxed (value);
 946
 947         set_fg_color (text_tag, color);
 948       }
 949       break;
 950
 951     case PROP_BACKGROUND_STIPPLE:
 952       {
 953         GdkBitmap *bitmap = g_value_get_object (value);
 954
 955         text_tag->bg_stipple_set = TRUE;
 956         g_object_notify (object, "background_stipple_set");
 957
 958         if (text_tag->values->appearance.bg_stipple != bitmap)
 959           {
 960             if (bitmap != NULL)
 961               gdk_bitmap_ref (bitmap);
 962
 963             if (text_tag->values->appearance.bg_stipple)
 964               gdk_bitmap_unref (text_tag->values->appearance.bg_stipple);
 965
 966             text_tag->values->appearance.bg_stipple = bitmap;
 967           }
 968       }
 969       break;
 970
 971     case PROP_FOREGROUND_STIPPLE:
 972       {
 973         GdkBitmap *bitmap = g_value_get_object (value);
 974
 975         text_tag->fg_stipple_set = TRUE;
 976         g_object_notify (object, "foreground_stipple_set");
 977
 978         if (text_tag->values->appearance.fg_stipple != bitmap)
 979           {
 980             if (bitmap != NULL)
 981               gdk_bitmap_ref (bitmap);
 982
 983             if (text_tag->values->appearance.fg_stipple)
 984               gdk_bitmap_unref (text_tag->values->appearance.fg_stipple);
 985
 986             text_tag->values->appearance.fg_stipple = bitmap;
 987           }
 988       }
 989       break;
 990
 991     case PROP_FONT:
 992       {
 993         PangoFontDescription *font_desc = NULL;
 994         const gchar *name;
 995
 996         name = g_value_get_string (value);
 997
 998         if (name)
 999           font_desc = pango_font_description_from_string (name);
1000
1001         set_font_description (text_tag, font_desc);
1002         if (font_desc)
1003           pango_font_description_free (font_desc);
1004
1005         size_changed = TRUE;
1006       }
1007       break;
1008
1009     case PROP_FONT_DESC:
1010       {
1011         PangoFontDescription *font_desc;
1012
1013         font_desc = g_value_get_boxed (value);
1014
1015         set_font_description (text_tag, font_desc);
1016
1017         size_changed = TRUE;
1018       }
1019       break;
1020
1021     case PROP_FAMILY:
1022     case PROP_STYLE:
1023     case PROP_VARIANT:
1024     case PROP_WEIGHT:
1025     case PROP_STRETCH:
1026     case PROP_SIZE:
1027     case PROP_SIZE_POINTS:
1028       {
1029         PangoFontMask old_set_mask;
1030
1031         gtk_text_tag_ensure_font (text_tag);
1032         old_set_mask = pango_font_description_get_set_fields (text_tag->values->font);
1033
1034         switch (prop_id)
1035           {
1036           case PROP_FAMILY:
1037             pango_font_description_set_family (text_tag->values->font,
1038                                                g_value_get_string (value));
1039             break;
1040           case PROP_STYLE:
1041             pango_font_description_set_style (text_tag->values->font,
1042                                               g_value_get_enum (value));
1043             break;
1044           case PROP_VARIANT:
1045             pango_font_description_set_variant (text_tag->values->font,
1046                                                 g_value_get_enum (value));
1047             break;
1048           case PROP_WEIGHT:
1049             pango_font_description_set_weight (text_tag->values->font,
1050                                                g_value_get_int (value));
1051             break;
1052           case PROP_STRETCH:
1053             pango_font_description_set_stretch (text_tag->values->font,
1054                                                 g_value_get_enum (value));
1055             break;
1056           case PROP_SIZE:
1057             pango_font_description_set_size (text_tag->values->font,
1058                                              g_value_get_int (value));
1059             g_object_notify (object, "size_points");
1060             break;
1061           case PROP_SIZE_POINTS:
1062             pango_font_description_set_size (text_tag->values->font,
1063                                              g_value_get_double (value) * PANGO_SCALE);
1064             g_object_notify (object, "size");
1065             break;
1066           }
1067
1068         size_changed = TRUE;
1069         notify_set_changed (object, old_set_mask & pango_font_description_get_set_fields (text_tag->values->font));
1070         g_object_notify (object, "font_desc");
1071         g_object_notify (object, "font");
1072
1073         break;
1074       }
1075
1076     case PROP_SCALE:
1077       text_tag->values->font_scale = g_value_get_double (value);
1078       text_tag->scale_set = TRUE;
1079       g_object_notify (object, "scale_set");
1080       size_changed = TRUE;
1081       break;
1082
1083     case PROP_PIXELS_ABOVE_LINES:
1084       text_tag->pixels_above_lines_set = TRUE;
1085       text_tag->values->pixels_above_lines = g_value_get_int (value);
1086       g_object_notify (object, "pixels_above_lines_set");
1087       size_changed = TRUE;
1088       break;
1089
1090     case PROP_PIXELS_BELOW_LINES:
1091       text_tag->pixels_below_lines_set = TRUE;
1092       text_tag->values->pixels_below_lines = g_value_get_int (value);
1093       g_object_notify (object, "pixels_below_lines_set");
1094       size_changed = TRUE;
1095       break;
1096
1097     case PROP_PIXELS_INSIDE_WRAP:
1098       text_tag->pixels_inside_wrap_set = TRUE;
1099       text_tag->values->pixels_inside_wrap = g_value_get_int (value);
1100       g_object_notify (object, "pixels_inside_wrap_set");
1101       size_changed = TRUE;
1102       break;
1103
1104     case PROP_EDITABLE:
1105       text_tag->editable_set = TRUE;
1106       text_tag->values->editable = g_value_get_boolean (value);
1107       g_object_notify (object, "editable_set");
1108       break;
1109
1110     case PROP_WRAP_MODE:
1111       text_tag->wrap_mode_set = TRUE;
1112       text_tag->values->wrap_mode = g_value_get_enum (value);
1113       g_object_notify (object, "wrap_mode_set");
1114       size_changed = TRUE;
1115       break;
1116
1117     case PROP_JUSTIFICATION:
1118       text_tag->justification_set = TRUE;
1119       text_tag->values->justification = g_value_get_enum (value);
1120       g_object_notify (object, "justification_set");
1121       size_changed = TRUE;
1122       break;
1123
1124     case PROP_DIRECTION:
1125       text_tag->values->direction = g_value_get_enum (value);
1126       break;
1127
1128     case PROP_LEFT_MARGIN:
1129       text_tag->left_margin_set = TRUE;
1130       text_tag->values->left_margin = g_value_get_int (value);
1131       g_object_notify (object, "left_margin_set");
1132       size_changed = TRUE;
1133       break;
1134
1135     case PROP_INDENT:
1136       text_tag->indent_set = TRUE;
1137       text_tag->values->indent = g_value_get_int (value);
1138       g_object_notify (object, "indent_set");
1139       size_changed = TRUE;
1140       break;
1141
1142     case PROP_STRIKETHROUGH:
1143       text_tag->strikethrough_set = TRUE;
1144       text_tag->values->appearance.strikethrough = g_value_get_boolean (value);
1145       g_object_notify (object, "strikethrough_set");
1146       break;
1147
1148     case PROP_RIGHT_MARGIN:
1149       text_tag->right_margin_set = TRUE;
1150       text_tag->values->right_margin = g_value_get_int (value);
1151       g_object_notify (object, "right_margin_set");
1152       size_changed = TRUE;
1153       break;
1154
1155     case PROP_UNDERLINE:
1156       text_tag->underline_set = TRUE;
1157       text_tag->values->appearance.underline = g_value_get_enum (value);
1158       g_object_notify (object, "underline_set");
1159       break;
1160
1161     case PROP_RISE:
1162       text_tag->rise_set = TRUE;
1163       text_tag->values->appearance.rise = g_value_get_int (value);
1164       g_object_notify (object, "rise_set");
1165       size_changed = TRUE;
1166       break;
1167
1168     case PROP_BG_FULL_HEIGHT:
1169       text_tag->bg_full_height_set = TRUE;
1170       text_tag->values->bg_full_height = g_value_get_boolean (value);
1171       g_object_notify (object, "bg_full_height_set");
1172       break;
1173
1174     case PROP_LANGUAGE:
1175       text_tag->language_set = TRUE;
1176       text_tag->values->language = pango_language_from_string (g_value_get_string (value));
1177       g_object_notify (object, "language_set");
1178       break;
1179
1180     case PROP_TABS:
1181       text_tag->tabs_set = TRUE;
1182
1183       if (text_tag->values->tabs)
1184         pango_tab_array_free (text_tag->values->tabs);
1185
1186       /* FIXME I'm not sure if this is a memleak or not */
1187       text_tag->values->tabs =
1188         pango_tab_array_copy (g_value_get_boxed (value));
1189
1190       g_object_notify (object, "tabs_set");
1191
1192       size_changed = TRUE;
1193       break;
1194
1195     case PROP_INVISIBLE:
1196       g_warning ("The \"invisible\" property on GtkTextTag is not supported for GTK 2.0, it will be added in a future release. see http://bugzilla.gnome.org bug #66194 for status.");
1197       text_tag->invisible_set = TRUE;
1198       text_tag->values->invisible = g_value_get_boolean (value);
1199       g_object_notify (object, "invisible_set");
1200       size_changed = TRUE;
1201       break;
1202
1203       /* Whether the value should be used... */
1204
1205     case PROP_BACKGROUND_SET:
1206       text_tag->bg_color_set = g_value_get_boolean (value);
1207       break;
1208
1209     case PROP_FOREGROUND_SET:
1210       text_tag->fg_color_set = g_value_get_boolean (value);
1211       break;
1212
1213     case PROP_BACKGROUND_STIPPLE_SET:
1214       text_tag->bg_stipple_set = g_value_get_boolean (value);
1215       if (!text_tag->bg_stipple_set &&
1216           text_tag->values->appearance.bg_stipple)
1217         {
1218           g_object_unref (G_OBJECT (text_tag->values->appearance.bg_stipple));
1219           text_tag->values->appearance.bg_stipple = NULL;
1220         }
1221       break;
1222
1223     case PROP_FOREGROUND_STIPPLE_SET:
1224       text_tag->fg_stipple_set = g_value_get_boolean (value);
1225       if (!text_tag->fg_stipple_set &&
1226           text_tag->values->appearance.fg_stipple)
1227         {
1228           g_object_unref (G_OBJECT (text_tag->values->appearance.fg_stipple));
1229           text_tag->values->appearance.fg_stipple = NULL;
1230         }
1231       break;
1232
1233     case PROP_FAMILY_SET:
1234     case PROP_STYLE_SET:
1235     case PROP_VARIANT_SET:
1236     case PROP_WEIGHT_SET:
1237     case PROP_STRETCH_SET:
1238     case PROP_SIZE_SET:
1239       if (!g_value_get_boolean (value))
1240         {
1241           if (text_tag->values->font)
1242             pango_font_description_unset_fields (text_tag->values->font,
1243                                                  get_property_font_set_mask (prop_id));
1244         }
1245       else
1246         {
1247           PangoFontMask changed_mask;
1248
1249           gtk_text_tag_ensure_font (text_tag);
1250           changed_mask = set_font_desc_fields (text_tag->values->font,
1251                                                get_property_font_set_mask (prop_id));
1252           notify_fields_changed (G_OBJECT (text_tag), changed_mask);
1253         }
1254       break;
1255
1256     case PROP_SCALE_SET:
1257       text_tag->scale_set = g_value_get_boolean (value);
1258       size_changed = TRUE;
1259       break;
1260
1261     case PROP_PIXELS_ABOVE_LINES_SET:
1262       text_tag->pixels_above_lines_set = g_value_get_boolean (value);
1263       size_changed = TRUE;
1264       break;
1265
1266     case PROP_PIXELS_BELOW_LINES_SET:
1267       text_tag->pixels_below_lines_set = g_value_get_boolean (value);
1268       size_changed = TRUE;
1269       break;
1270
1271     case PROP_PIXELS_INSIDE_WRAP_SET:
1272       text_tag->pixels_inside_wrap_set = g_value_get_boolean (value);
1273       size_changed = TRUE;
1274       break;
1275
1276     case PROP_EDITABLE_SET:
1277       text_tag->editable_set = g_value_get_boolean (value);
1278       break;
1279
1280     case PROP_WRAP_MODE_SET:
1281       text_tag->wrap_mode_set = g_value_get_boolean (value);
1282       size_changed = TRUE;
1283       break;
1284
1285     case PROP_JUSTIFICATION_SET:
1286       text_tag->justification_set = g_value_get_boolean (value);
1287       size_changed = TRUE;
1288       break;
1289
1290     case PROP_LEFT_MARGIN_SET:
1291       text_tag->left_margin_set = g_value_get_boolean (value);
1292       size_changed = TRUE;
1293       break;
1294
1295     case PROP_INDENT_SET:
1296       text_tag->indent_set = g_value_get_boolean (value);
1297       size_changed = TRUE;
1298       break;
1299
1300     case PROP_STRIKETHROUGH_SET:
1301       text_tag->strikethrough_set = g_value_get_boolean (value);
1302       break;
1303
1304     case PROP_RIGHT_MARGIN_SET:
1305       text_tag->right_margin_set = g_value_get_boolean (value);
1306       size_changed = TRUE;
1307       break;
1308
1309     case PROP_UNDERLINE_SET:
1310       text_tag->underline_set = g_value_get_boolean (value);
1311       break;
1312
1313     case PROP_RISE_SET:
1314       text_tag->rise_set = g_value_get_boolean (value);
1315       size_changed = TRUE;
1316       break;
1317
1318     case PROP_BG_FULL_HEIGHT_SET:
1319       text_tag->bg_full_height_set = g_value_get_boolean (value);
1320       break;
1321
1322     case PROP_LANGUAGE_SET:
1323       text_tag->language_set = g_value_get_boolean (value);
1324       size_changed = TRUE;
1325       break;
1326
1327     case PROP_TABS_SET:
1328       text_tag->tabs_set = g_value_get_boolean (value);
1329       size_changed = TRUE;
1330       break;
1331
1332     case PROP_INVISIBLE_SET:
1333       text_tag->invisible_set = g_value_get_boolean (value);
1334       size_changed = TRUE;
1335       break;
1336
1337     default:
1338       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1339       break;
1340     }
1341
1342   /* FIXME I would like to do this after all set_property in a single
1343    * g_object_set () have been called. But an idle function won't
1344    * work; we need to emit when the tag is changed, not when we get
1345    * around to the event loop. So blah, we eat some inefficiency.
1346    */
1347
1348   /* This is also somewhat weird since we emit another object's
1349    * signal here, but the two objects are already tightly bound.
1350    */
1351
1352   if (text_tag->table)
1353     g_signal_emit_by_name (G_OBJECT (text_tag->table),
1354                            "tag_changed",
1355                            text_tag, size_changed);
1356 }
1357
1358 static void
1359 get_color_arg (GValue *value, GdkColor *orig)
1360 {
1361   GdkColor *color;
1362
1363   color = g_new (GdkColor, 1);
1364   *color = *orig;
1365   g_value_init (value, GDK_TYPE_COLOR);
1366   g_value_set_boxed (value, color);
1367 }
1368
1369 static void
1370 gtk_text_tag_get_property (GObject      *object,
1371                            guint         prop_id,
1372                            GValue       *value,
1373                            GParamSpec   *pspec)
1374 {
1375   GtkTextTag *tag;
1376
1377   tag = GTK_TEXT_TAG (object);
1378
1379   switch (prop_id)
1380     {
1381     case PROP_NAME:
1382       g_value_set_string (value, tag->name);
1383       break;
1384
1385     case PROP_BACKGROUND_GDK:
1386       get_color_arg (value, &tag->values->appearance.bg_color);
1387       break;
1388
1389     case PROP_FOREGROUND_GDK:
1390       get_color_arg (value, &tag->values->appearance.fg_color);
1391       break;
1392
1393     case PROP_BACKGROUND_STIPPLE:
1394       if (tag->bg_stipple_set)
1395         g_value_set_boxed (value, tag->values->appearance.bg_stipple);
1396       break;
1397
1398     case PROP_FOREGROUND_STIPPLE:
1399       if (tag->fg_stipple_set)
1400         g_value_set_boxed (value, tag->values->appearance.fg_stipple);
1401       break;
1402
1403     case PROP_FONT:
1404         {
1405           /* FIXME GValue imposes a totally gratuitous string copy
1406            * here, we could just hand off string ownership
1407            */
1408           gchar *str;
1409
1410           gtk_text_tag_ensure_font (tag);
1411
1412           str = pango_font_description_to_string (tag->values->font);
1413           g_value_set_string (value, str);
1414           g_free (str);
1415         }
1416       break;
1417
1418     case PROP_FONT_DESC:
1419       gtk_text_tag_ensure_font (tag);
1420       g_value_set_boxed (value, tag->values->font);
1421       break;
1422
1423     case PROP_FAMILY:
1424     case PROP_STYLE:
1425     case PROP_VARIANT:
1426     case PROP_WEIGHT:
1427     case PROP_STRETCH:
1428     case PROP_SIZE:
1429     case PROP_SIZE_POINTS:
1430       gtk_text_tag_ensure_font (tag);
1431       switch (prop_id)
1432         {
1433         case PROP_FAMILY:
1434           g_value_set_string (value, pango_font_description_get_family (tag->values->font));
1435           break;
1436
1437         case PROP_STYLE:
1438           g_value_set_enum (value, pango_font_description_get_style (tag->values->font));
1439           break;
1440
1441         case PROP_VARIANT:
1442           g_value_set_enum (value, pango_font_description_get_variant (tag->values->font));
1443           break;
1444
1445         case PROP_WEIGHT:
1446           g_value_set_int (value, pango_font_description_get_weight (tag->values->font));
1447           break;
1448
1449         case PROP_STRETCH:
1450           g_value_set_enum (value, pango_font_description_get_stretch (tag->values->font));
1451           break;
1452
1453         case PROP_SIZE:
1454           g_value_set_int (value, pango_font_description_get_size (tag->values->font));
1455           break;
1456
1457         case PROP_SIZE_POINTS:
1458           g_value_set_double (value, ((double)pango_font_description_get_size (tag->values->font)) / (double)PANGO_SCALE);
1459           break;
1460         }
1461       break;
1462
1463     case PROP_SCALE:
1464       g_value_set_double (value, tag->values->font_scale);
1465       break;
1466
1467     case PROP_PIXELS_ABOVE_LINES:
1468       g_value_set_int (value,  tag->values->pixels_above_lines);
1469       break;
1470
1471     case PROP_PIXELS_BELOW_LINES:
1472       g_value_set_int (value,  tag->values->pixels_below_lines);
1473       break;
1474
1475     case PROP_PIXELS_INSIDE_WRAP:
1476       g_value_set_int (value,  tag->values->pixels_inside_wrap);
1477       break;
1478
1479     case PROP_EDITABLE:
1480       g_value_set_boolean (value, tag->values->editable);
1481       break;
1482
1483     case PROP_WRAP_MODE:
1484       g_value_set_enum (value, tag->values->wrap_mode);
1485       break;
1486
1487     case PROP_JUSTIFICATION:
1488       g_value_set_enum (value, tag->values->justification);
1489       break;
1490
1491     case PROP_DIRECTION:
1492       g_value_set_enum (value, tag->values->direction);
1493       break;
1494
1495     case PROP_LEFT_MARGIN:
1496       g_value_set_int (value,  tag->values->left_margin);
1497       break;
1498
1499     case PROP_INDENT:
1500       g_value_set_int (value,  tag->values->indent);
1501       break;
1502
1503     case PROP_STRIKETHROUGH:
1504       g_value_set_boolean (value, tag->values->appearance.strikethrough);
1505       break;
1506
1507     case PROP_RIGHT_MARGIN:
1508       g_value_set_int (value, tag->values->right_margin);
1509       break;
1510
1511     case PROP_UNDERLINE:
1512       g_value_set_enum (value, tag->values->appearance.underline);
1513       break;
1514
1515     case PROP_RISE:
1516       g_value_set_int (value, tag->values->appearance.rise);
1517       break;
1518
1519     case PROP_BG_FULL_HEIGHT:
1520       g_value_set_boolean (value, tag->values->bg_full_height);
1521       break;
1522
1523     case PROP_LANGUAGE:
1524       g_value_set_string (value, pango_language_to_string (tag->values->language));
1525       break;
1526
1527     case PROP_TABS:
1528       if (tag->values->tabs)
1529         g_value_set_boxed (value, tag->values->tabs);
1530       break;
1531
1532     case PROP_INVISIBLE:
1533       g_value_set_boolean (value, tag->values->invisible);
1534       break;
1535
1536     case PROP_BACKGROUND_SET:
1537       g_value_set_boolean (value, tag->bg_color_set);
1538       break;
1539
1540     case PROP_FOREGROUND_SET:
1541       g_value_set_boolean (value, tag->fg_color_set);
1542       break;
1543
1544     case PROP_BACKGROUND_STIPPLE_SET:
1545       g_value_set_boolean (value, tag->bg_stipple_set);
1546       break;
1547
1548     case PROP_FOREGROUND_STIPPLE_SET:
1549       g_value_set_boolean (value, tag->fg_stipple_set);
1550       break;
1551
1552     case PROP_FAMILY_SET:
1553     case PROP_STYLE_SET:
1554     case PROP_VARIANT_SET:
1555     case PROP_WEIGHT_SET:
1556     case PROP_STRETCH_SET:
1557     case PROP_SIZE_SET:
1558       {
1559         PangoFontMask set_mask = tag->values->font ? pango_font_description_get_set_fields (tag->values->font) : 0;
1560         PangoFontMask test_mask = get_property_font_set_mask (prop_id);
1561         g_value_set_boolean (value, (set_mask & test_mask) != 0);
1562
1563         break;
1564       }
1565
1566     case PROP_SCALE_SET:
1567       g_value_set_boolean (value, tag->scale_set);
1568       break;
1569
1570     case PROP_PIXELS_ABOVE_LINES_SET:
1571       g_value_set_boolean (value, tag->pixels_above_lines_set);
1572       break;
1573
1574     case PROP_PIXELS_BELOW_LINES_SET:
1575       g_value_set_boolean (value, tag->pixels_below_lines_set);
1576       break;
1577
1578     case PROP_PIXELS_INSIDE_WRAP_SET:
1579       g_value_set_boolean (value, tag->pixels_inside_wrap_set);
1580       break;
1581
1582     case PROP_EDITABLE_SET:
1583       g_value_set_boolean (value, tag->editable_set);
1584       break;
1585
1586     case PROP_WRAP_MODE_SET:
1587       g_value_set_boolean (value, tag->wrap_mode_set);
1588       break;
1589
1590     case PROP_JUSTIFICATION_SET:
1591       g_value_set_boolean (value, tag->justification_set);
1592       break;
1593
1594     case PROP_LEFT_MARGIN_SET:
1595       g_value_set_boolean (value, tag->left_margin_set);
1596       break;
1597
1598     case PROP_INDENT_SET:
1599       g_value_set_boolean (value, tag->indent_set);
1600       break;
1601
1602     case PROP_STRIKETHROUGH_SET:
1603       g_value_set_boolean (value, tag->strikethrough_set);
1604       break;
1605
1606     case PROP_RIGHT_MARGIN_SET:
1607       g_value_set_boolean (value, tag->right_margin_set);
1608       break;
1609
1610     case PROP_UNDERLINE_SET:
1611       g_value_set_boolean (value, tag->underline_set);
1612       break;
1613
1614     case PROP_RISE_SET:
1615       g_value_set_boolean (value, tag->rise_set);
1616       break;
1617
1618     case PROP_BG_FULL_HEIGHT_SET:
1619       g_value_set_boolean (value, tag->bg_full_height_set);
1620       break;
1621
1622     case PROP_LANGUAGE_SET:
1623       g_value_set_boolean (value, tag->language_set);
1624       break;
1625
1626     case PROP_TABS_SET:
1627       g_value_set_boolean (value, tag->tabs_set);
1628       break;
1629
1630     case PROP_INVISIBLE_SET:
1631       g_value_set_boolean (value, tag->invisible_set);
1632       break;
1633
1634     case PROP_BACKGROUND:
1635     case PROP_FOREGROUND:
1636       g_warning ("'foreground' and 'background' properties are not readable, use 'foreground_gdk' and 'background_gdk'");
1637     default:
1638       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1639       break;
1640     }
1641 }
1642
1643 /*
1644  * Tag operations
1645  */
1646
1647 typedef struct {
1648   gint high;
1649   gint low;
1650   gint delta;
1651 } DeltaData;
1652
1653 static void
1654 delta_priority_foreach (GtkTextTag *tag, gpointer user_data)
1655 {
1656   DeltaData *dd = user_data;
1657
1658   if (tag->priority >= dd->low && tag->priority <= dd->high)
1659     tag->priority += dd->delta;
1660 }
1661
1662 /**
1663  * gtk_text_tag_get_priority:
1664  * @tag: a #GtkTextTag
1665  *
1666  * Get the tag priority.
1667  *
1668  * Return value: The tag's priority.
1669  **/
1670 gint
1671 gtk_text_tag_get_priority (GtkTextTag *tag)
1672 {
1673   g_return_val_if_fail (GTK_IS_TEXT_TAG (tag), 0);
1674
1675   return tag->priority;
1676 }
1677
1678 /**
1679  * gtk_text_tag_set_priority:
1680  * @tag: a #GtkTextTag
1681  * @priority: the new priority
1682  *
1683  * Sets the priority of a #GtkTextTag. Valid priorities are
1684  * start at 0 and go to one less than gtk_text_tag_table_get_size().
1685  * Each tag in a table has a unique priority; setting the priority
1686  * of one tag shifts the priorities of all the other tags in the
1687  * table to maintain a unique priority for each tag. Higher priority
1688  * tags "win" if two tags both set the same text attribute. When adding
1689  * a tag to a tag table, it will be assigned the highest priority in
1690  * the table by default; so normally the precedence of a set of tags
1691  * is the order in which they were added to the table, or created with
1692  * gtk_text_buffer_create_tag(), which adds the tag to the buffer's table
1693  * automatically.
1694  **/
1695 void
1696 gtk_text_tag_set_priority (GtkTextTag *tag,
1697                            gint        priority)
1698 {
1699   DeltaData dd;
1700
1701   g_return_if_fail (GTK_IS_TEXT_TAG (tag));
1702   g_return_if_fail (tag->table != NULL);
1703   g_return_if_fail (priority >= 0);
1704   g_return_if_fail (priority < gtk_text_tag_table_get_size (tag->table));
1705
1706   if (priority == tag->priority)
1707     return;
1708
1709   if (priority < tag->priority)
1710     {
1711       dd.low = priority;
1712       dd.high = tag->priority - 1;
1713       dd.delta = 1;
1714     }
1715   else
1716     {
1717       dd.low = tag->priority + 1;
1718       dd.high = priority;
1719       dd.delta = -1;
1720     }
1721
1722   gtk_text_tag_table_foreach (tag->table,
1723                               delta_priority_foreach,
1724                               &dd);
1725
1726   tag->priority = priority;
1727 }
1728
1729 /**
1730  * gtk_text_tag_event:
1731  * @tag: a #GtkTextTag
1732  * @event_object: object that received the event, such as a widget
1733  * @event: the event
1734  * @iter: location where the event was received
1735  *
1736  * Emits the "event" signal on the #GtkTextTag.
1737  *
1738  * Return value: result of signal emission (whether the event was handled)
1739  **/
1740 gboolean
1741 gtk_text_tag_event (GtkTextTag        *tag,
1742                     GObject           *event_object,
1743                     GdkEvent          *event,
1744                     const GtkTextIter *iter)
1745 {
1746   gboolean retval = FALSE;
1747
1748   g_return_val_if_fail (GTK_IS_TEXT_TAG (tag), FALSE);
1749   g_return_val_if_fail (G_IS_OBJECT (event_object), FALSE);
1750   g_return_val_if_fail (event != NULL, FALSE);
1751
1752   g_signal_emit (G_OBJECT (tag),
1753                  signals[EVENT],
1754                  0,
1755                  event_object,
1756                  event,
1757                  iter,
1758                  &retval);
1759
1760   return retval;
1761 }
1762
1763 static int
1764 tag_sort_func (gconstpointer first, gconstpointer second)
1765 {
1766   GtkTextTag *tag1, *tag2;
1767
1768   tag1 = * (GtkTextTag **) first;
1769   tag2 = * (GtkTextTag **) second;
1770   return tag1->priority - tag2->priority;
1771 }
1772
1773 void
1774 _gtk_text_tag_array_sort (GtkTextTag** tag_array_p,
1775                           guint len)
1776 {
1777   int i, j, prio;
1778   GtkTextTag **tag;
1779   GtkTextTag **maxPtrPtr, *tmp;
1780
1781   g_return_if_fail (tag_array_p != NULL);
1782   g_return_if_fail (len > 0);
1783
1784   if (len < 2) {
1785     return;
1786   }
1787   if (len < 20) {
1788     GtkTextTag **iter = tag_array_p;
1789
1790     for (i = len-1; i > 0; i--, iter++) {
1791       maxPtrPtr = tag = iter;
1792       prio = tag[0]->priority;
1793       for (j = i, tag++; j > 0; j--, tag++) {
1794         if (tag[0]->priority < prio) {
1795           prio = tag[0]->priority;
1796           maxPtrPtr = tag;
1797         }
1798       }
1799       tmp = *maxPtrPtr;
1800       *maxPtrPtr = *iter;
1801       *iter = tmp;
1802     }
1803   } else {
1804     qsort ((void *) tag_array_p, (unsigned) len, sizeof (GtkTextTag *),
1805            tag_sort_func);
1806   }
1807
1808 #if 0
1809   {
1810     printf ("Sorted tag array: \n");
1811     i = 0;
1812     while (i < len)
1813       {
1814         GtkTextTag *t = tag_array_p[i];
1815         printf ("  %s priority %d\n", t->name, t->priority);
1816
1817         ++i;
1818       }
1819   }
1820 #endif
1821 }
1822
1823 /*
1824  * Attributes
1825  */
1826
1827 /**
1828  * gtk_text_attributes_new:
1829  *
1830  * Creates a #GtkTextAttributes, which describes
1831  * a set of properties on some text.
1832  *
1833  * Return value: a new #GtkTextAttributes
1834  **/
1835 GtkTextAttributes*
1836 gtk_text_attributes_new (void)
1837 {
1838   GtkTextAttributes *values;
1839
1840   values = g_new0 (GtkTextAttributes, 1);
1841
1842   /* 0 is a valid value for most of the struct */
1843
1844   values->refcount = 1;
1845
1846   values->language = gtk_get_default_language ();
1847
1848   values->font_scale = 1.0;
1849
1850   return values;
1851 }
1852
1853 /**
1854  * gtk_text_attributes_copy:
1855  * @src: a #GtkTextAttributes to be copied
1856  *
1857  * Copies @src and returns a new #GtkTextAttributes.
1858  *
1859  * Return value: a copy of @src
1860  **/
1861 GtkTextAttributes*
1862 gtk_text_attributes_copy (GtkTextAttributes *src)
1863 {
1864   GtkTextAttributes *dest;
1865
1866   dest = gtk_text_attributes_new ();
1867   gtk_text_attributes_copy_values (src, dest);
1868
1869   return dest;
1870 }
1871
1872 /**
1873  * gtk_text_attributes_copy_values:
1874  * @src: a #GtkTextAttributes
1875  * @dest: another #GtkTextAttributes
1876  *
1877  * Copies the values from @src to @dest so that @dest has the same values
1878  * as @src. Frees existing values in @dest.
1879  **/
1880 void
1881 gtk_text_attributes_copy_values (GtkTextAttributes *src,
1882                                  GtkTextAttributes *dest)
1883 {
1884   guint orig_refcount;
1885
1886   g_return_if_fail (!dest->realized);
1887
1888   if (src == dest)
1889     return;
1890
1891   /* Add refs */
1892
1893   if (src->appearance.bg_stipple)
1894     gdk_bitmap_ref (src->appearance.bg_stipple);
1895
1896   if (src->appearance.fg_stipple)
1897     gdk_bitmap_ref (src->appearance.fg_stipple);
1898
1899   /* Remove refs */
1900
1901   if (dest->appearance.bg_stipple)
1902     gdk_bitmap_unref (dest->appearance.bg_stipple);
1903
1904   if (dest->appearance.fg_stipple)
1905     gdk_bitmap_unref (dest->appearance.fg_stipple);
1906
1907   if (dest->font)
1908     pango_font_description_free (dest->font);
1909
1910   /* Copy */
1911   orig_refcount = dest->refcount;
1912
1913   *dest = *src;
1914
1915   if (src->tabs)
1916     dest->tabs = pango_tab_array_copy (src->tabs);
1917
1918   dest->language = src->language;
1919
1920   if (dest->font)
1921     dest->font = pango_font_description_copy (src->font);
1922
1923   dest->refcount = orig_refcount;
1924   dest->realized = FALSE;
1925 }
1926
1927 /**
1928  * gtk_text_attributes_ref:
1929  * @values: a #GtkTextAttributes
1930  *
1931  * Increments the reference count on @values.
1932  **/
1933 void
1934 gtk_text_attributes_ref (GtkTextAttributes *values)
1935 {
1936   g_return_if_fail (values != NULL);
1937
1938   values->refcount += 1;
1939 }
1940
1941 /**
1942  * gtk_text_attributes_unref:
1943  * @values: a #GtkTextAttributes
1944  *
1945  * Decrements the reference count on @values, freeing the structure
1946  * if the reference count reaches 0.
1947  **/
1948 void
1949 gtk_text_attributes_unref (GtkTextAttributes *values)
1950 {
1951   g_return_if_fail (values != NULL);
1952   g_return_if_fail (values->refcount > 0);
1953
1954   values->refcount -= 1;
1955
1956   if (values->refcount == 0)
1957     {
1958       g_assert (!values->realized);
1959
1960       if (values->appearance.bg_stipple)
1961         gdk_bitmap_unref (values->appearance.bg_stipple);
1962
1963       if (values->appearance.fg_stipple)
1964         gdk_bitmap_unref (values->appearance.fg_stipple);
1965
1966       if (values->tabs)
1967         pango_tab_array_free (values->tabs);
1968
1969       if (values->font)
1970         pango_font_description_free (values->font);
1971
1972       g_free (values);
1973     }
1974 }
1975
1976 void
1977 _gtk_text_attributes_realize (GtkTextAttributes *values,
1978                               GdkColormap *cmap,
1979                               GdkVisual *visual)
1980 {
1981   g_return_if_fail (values != NULL);
1982   g_return_if_fail (values->refcount > 0);
1983   g_return_if_fail (!values->realized);
1984
1985   /* It is wrong to use this colormap, FIXME */
1986   gdk_colormap_alloc_color (cmap,
1987                             &values->appearance.fg_color,
1988                             FALSE, TRUE);
1989
1990   gdk_colormap_alloc_color (cmap,
1991                             &values->appearance.bg_color,
1992                             FALSE, TRUE);
1993
1994   values->realized = TRUE;
1995 }
1996
1997 void
1998 _gtk_text_attributes_unrealize (GtkTextAttributes *values,
1999                                 GdkColormap *cmap,
2000                                 GdkVisual *visual)
2001 {
2002   g_return_if_fail (values != NULL);
2003   g_return_if_fail (values->refcount > 0);
2004   g_return_if_fail (values->realized);
2005
2006   gdk_colormap_free_colors (cmap,
2007                             &values->appearance.fg_color, 1);
2008
2009
2010   gdk_colormap_free_colors (cmap,
2011                             &values->appearance.bg_color, 1);
2012
2013   values->appearance.fg_color.pixel = 0;
2014   values->appearance.bg_color.pixel = 0;
2015
2016   values->realized = FALSE;
2017 }
2018
2019 void
2020 _gtk_text_attributes_fill_from_tags (GtkTextAttributes *dest,
2021                                      GtkTextTag**       tags,
2022                                      guint              n_tags)
2023 {
2024   guint n = 0;
2025
2026   g_return_if_fail (!dest->realized);
2027
2028   while (n < n_tags)
2029     {
2030       GtkTextTag *tag = tags[n];
2031       GtkTextAttributes *vals = tag->values;
2032
2033       g_assert (tag->table != NULL);
2034       if (n > 0)
2035         g_assert (tags[n]->priority > tags[n-1]->priority);
2036
2037       if (tag->bg_color_set)
2038         {
2039           dest->appearance.bg_color = vals->appearance.bg_color;
2040
2041           dest->appearance.draw_bg = TRUE;
2042         }
2043       if (tag->fg_color_set)
2044         dest->appearance.fg_color = vals->appearance.fg_color;
2045
2046       if (tag->bg_stipple_set)
2047         {
2048           gdk_bitmap_ref (vals->appearance.bg_stipple);
2049           if (dest->appearance.bg_stipple)
2050             gdk_bitmap_unref (dest->appearance.bg_stipple);
2051           dest->appearance.bg_stipple = vals->appearance.bg_stipple;
2052
2053           dest->appearance.draw_bg = TRUE;
2054         }
2055
2056       if (tag->fg_stipple_set)
2057         {
2058           gdk_bitmap_ref (vals->appearance.fg_stipple);
2059           if (dest->appearance.fg_stipple)
2060             gdk_bitmap_unref (dest->appearance.fg_stipple);
2061           dest->appearance.fg_stipple = vals->appearance.fg_stipple;
2062         }
2063
2064       if (vals->font)
2065         {
2066           if (dest->font)
2067             pango_font_description_merge (dest->font, vals->font, TRUE);
2068           else
2069             dest->font = pango_font_description_copy (vals->font);
2070         }
2071
2072       /* multiply all the scales together to get a composite */
2073       if (tag->scale_set)
2074         dest->font_scale *= vals->font_scale;
2075
2076       if (tag->justification_set)
2077         dest->justification = vals->justification;
2078
2079       if (vals->direction != GTK_TEXT_DIR_NONE)
2080         dest->direction = vals->direction;
2081
2082       if (tag->left_margin_set)
2083         dest->left_margin = vals->left_margin;
2084
2085       if (tag->indent_set)
2086         dest->indent = vals->indent;
2087
2088       if (tag->rise_set)
2089         dest->appearance.rise = vals->appearance.rise;
2090
2091       if (tag->right_margin_set)
2092         dest->right_margin = vals->right_margin;
2093
2094       if (tag->pixels_above_lines_set)
2095         dest->pixels_above_lines = vals->pixels_above_lines;
2096
2097       if (tag->pixels_below_lines_set)
2098         dest->pixels_below_lines = vals->pixels_below_lines;
2099
2100       if (tag->pixels_inside_wrap_set)
2101         dest->pixels_inside_wrap = vals->pixels_inside_wrap;
2102
2103       if (tag->tabs_set)
2104         {
2105           if (dest->tabs)
2106             pango_tab_array_free (dest->tabs);
2107           dest->tabs = pango_tab_array_copy (vals->tabs);
2108         }
2109
2110       if (tag->wrap_mode_set)
2111         dest->wrap_mode = vals->wrap_mode;
2112
2113       if (tag->underline_set)
2114         dest->appearance.underline = vals->appearance.underline;
2115
2116       if (tag->strikethrough_set)
2117         dest->appearance.strikethrough = vals->appearance.strikethrough;
2118
2119       if (tag->invisible_set)
2120         dest->invisible = vals->invisible;
2121
2122       if (tag->editable_set)
2123         dest->editable = vals->editable;
2124
2125       if (tag->bg_full_height_set)
2126         dest->bg_full_height = vals->bg_full_height;
2127
2128       if (tag->language_set)
2129         dest->language = vals->language;
2130
2131       ++n;
2132     }
2133 }
2134
2135 gboolean
2136 _gtk_text_tag_affects_size (GtkTextTag *tag)
2137 {
2138   g_return_val_if_fail (GTK_IS_TEXT_TAG (tag), FALSE);
2139
2140   return
2141     (tag->values->font && pango_font_description_get_set_fields (tag->values->font) != 0) ||
2142     tag->scale_set ||
2143     tag->justification_set ||
2144     tag->left_margin_set ||
2145     tag->indent_set ||
2146     tag->rise_set ||
2147     tag->right_margin_set ||
2148     tag->pixels_above_lines_set ||
2149     tag->pixels_below_lines_set ||
2150     tag->pixels_inside_wrap_set ||
2151     tag->tabs_set ||
2152     tag->underline_set ||
2153     tag->wrap_mode_set ||
2154     tag->invisible_set;
2155 }
2156
2157 gboolean
2158 _gtk_text_tag_affects_nonsize_appearance (GtkTextTag *tag)
2159 {
2160   g_return_val_if_fail (GTK_IS_TEXT_TAG (tag), FALSE);
2161
2162   return
2163     tag->bg_color_set ||
2164     tag->bg_stipple_set ||
2165     tag->fg_color_set ||
2166     tag->fg_stipple_set ||
2167     tag->strikethrough_set ||
2168     tag->bg_full_height_set;
2169 }