adg/adg-font-style.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009 Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-font-style
  23  * @short_description: Font style related stuff
  24  *
  25  * Contains parameters on how to draw texts such as font family, slanting,
  26  * weight, hinting and so on.
  27  */
  28
  29 /**
  30  * AdgFontStyle:
  31  *
  32  * All fields are private and should not be used directly.
  33  * Use its public methods instead.
  34  **/
  35
  36
  37 #include "adg-font-style.h"
  38 #include "adg-font-style-private.h"
  39 #include "adg-dress-builtins.h"
  40 #include "adg-util.h"
  41 #include "adg-intl.h"
  42
  43 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_font_style_parent_class)
  44
  45
  46 enum {
  47     PROP_0,
  48     PROP_COLOR_DRESS,
  49     PROP_FAMILY,
  50     PROP_SLANT,
  51     PROP_WEIGHT,
  52     PROP_SIZE,
  53     PROP_ANTIALIAS,
  54     PROP_SUBPIXEL_ORDER,
  55     PROP_HINT_STYLE,
  56     PROP_HINT_METRICS
  57 };
  58
  59
  60 static void             dispose                 (GObject        *object);
  61 static void             get_property            (GObject        *object,
  62                                                  guint           prop_id,
  63                                                  GValue         *value,
  64                                                  GParamSpec     *pspec);
  65 static void             set_property            (GObject        *object,
  66                                                  guint           prop_id,
  67                                                  const GValue   *value,
  68                                                  GParamSpec     *pspec);
  69 static void             apply                   (AdgStyle       *style,
  70                                                  AdgEntity      *entity,
  71                                                  cairo_t        *cr);
  72 static gboolean         set_family              (AdgFontStyle   *font_style,
  73                                                  const gchar    *family);
  74 static gboolean         set_slant               (AdgFontStyle   *font_style,
  75                                                  cairo_font_slant_t slant);
  76 static gboolean         set_weight              (AdgFontStyle   *font_style,
  77                                                  cairo_font_weight_t weight);
  78 static gboolean         set_size                (AdgFontStyle   *font_style,
  79                                                  gdouble         size);
  80 static gboolean         set_antialias           (AdgFontStyle   *font_style,
  81                                                  cairo_antialias_t antialias);
  82 static gboolean         set_subpixel_order      (AdgFontStyle   *font_style,
  83                                                  cairo_subpixel_order_t subpixel_order);
  84 static gboolean         set_hint_style          (AdgFontStyle   *font_style,
  85                                                  cairo_hint_style_t hint_style);
  86 static gboolean         set_hint_metrics        (AdgFontStyle   *font_style,
  87                                                  cairo_hint_metrics_t hint_metrics);
  88 static void             unset_face              (AdgFontStyle   *font_style);
  89 static void             unset_font              (AdgFontStyle   *font_style);
  90
  91
  92 G_DEFINE_TYPE(AdgFontStyle, adg_font_style, ADG_TYPE_STYLE);
  93
  94
  95 static void
  96 adg_font_style_class_init(AdgFontStyleClass *klass)
  97 {
  98     GObjectClass *gobject_class;
  99     AdgStyleClass *style_class;
 100     GParamSpec *param;
 101
 102     gobject_class = (GObjectClass *) klass;
 103     style_class = (AdgStyleClass *) klass;
 104
 105     g_type_class_add_private(klass, sizeof(AdgFontStylePrivate));
 106
 107     gobject_class->dispose = dispose;
 108     gobject_class->get_property = get_property;
 109     gobject_class->set_property = set_property;
 110
 111     style_class->apply = apply;
 112
 113     param = adg_param_spec_dress("color-dress",
 114                                  P_("Color Dress"),
 115                                  P_("The color dress to bind to this font style"),
 116                                  ADG_DRESS_COLOR,
 117                                  G_PARAM_READWRITE);
 118     g_object_class_install_property(gobject_class, PROP_COLOR_DRESS, param);
 119
 120     param = g_param_spec_string("family",
 121                                 P_("Font Family"),
 122                                 P_("The font family name, encoded in UTF-8"),
 123                                 NULL,
 124                                 G_PARAM_READWRITE);
 125     g_object_class_install_property(gobject_class, PROP_FAMILY, param);
 126
 127     param = g_param_spec_int("slant",
 128                              P_("Font Slant"),
 129                              P_("Variant of a font face based on its slant"),
 130                              G_MININT, G_MAXINT, CAIRO_FONT_SLANT_NORMAL,
 131                              G_PARAM_READWRITE);
 132     g_object_class_install_property(gobject_class, PROP_SLANT, param);
 133
 134     param = g_param_spec_int("weight",
 135                              P_("Font Weight"),
 136                              P_("Variant of a font face based on its weight"),
 137                              G_MININT, G_MAXINT, CAIRO_FONT_WEIGHT_NORMAL,
 138                              G_PARAM_READWRITE);
 139     g_object_class_install_property(gobject_class, PROP_WEIGHT, param);
 140
 141     param = g_param_spec_double("size",
 142                                 P_("Font Size"),
 143                                 P_("Font size in user space units"),
 144                                 0, G_MAXDOUBLE, 10,
 145                                 G_PARAM_READWRITE);
 146     g_object_class_install_property(gobject_class, PROP_SIZE, param);
 147
 148     param = g_param_spec_int("antialias",
 149                              P_("Font Antialiasing Mode"),
 150                              P_("Type of antialiasing to do when rendering text"),
 151                              G_MININT, G_MAXINT, CAIRO_ANTIALIAS_DEFAULT,
 152                              G_PARAM_READWRITE);
 153     g_object_class_install_property(gobject_class, PROP_ANTIALIAS, param);
 154
 155     param = g_param_spec_int("subpixel-order",
 156                              P_("Font Subpixel Order"),
 157                              P_("The order of color elements within each pixel on the display device when rendering with subpixel antialiasing mode"),
 158                              G_MININT, G_MAXINT,
 159                              CAIRO_SUBPIXEL_ORDER_DEFAULT,
 160                              G_PARAM_READWRITE);
 161     g_object_class_install_property(gobject_class, PROP_SUBPIXEL_ORDER, param);
 162
 163     param = g_param_spec_int("hint-style",
 164                              P_("Type of Hinting"),
 165                              P_("How outlines must fit to the pixel grid in order to improve the glyph appearance"),
 166                              G_MININT, G_MAXINT, CAIRO_HINT_STYLE_DEFAULT,
 167                              G_PARAM_READWRITE);
 168     g_object_class_install_property(gobject_class, PROP_HINT_STYLE, param);
 169
 170     param = g_param_spec_int("hint-metrics",
 171                              P_("Font Metric Hinting"),
 172                              P_("Whether to hint font metrics, that is align them to integer values in device space"),
 173                              G_MININT, G_MAXINT,
 174                              CAIRO_HINT_METRICS_DEFAULT,
 175                              G_PARAM_READWRITE);
 176     g_object_class_install_property(gobject_class, PROP_HINT_METRICS, param);
 177 }
 178
 179 static void
 180 adg_font_style_init(AdgFontStyle *font_style)
 181 {
 182     AdgFontStylePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(font_style,
 183                                                             ADG_TYPE_FONT_STYLE,
 184                                                             AdgFontStylePrivate);
 185
 186     data->color_dress = ADG_DRESS_COLOR;
 187     data->family = NULL;
 188     data->slant = CAIRO_FONT_SLANT_NORMAL;
 189     data->weight = CAIRO_FONT_WEIGHT_NORMAL;
 190     data->size = 10;
 191     data->antialias = CAIRO_ANTIALIAS_DEFAULT;
 192     data->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
 193     data->hint_style = CAIRO_HINT_STYLE_DEFAULT;
 194     data->hint_metrics = CAIRO_HINT_METRICS_DEFAULT;
 195     data->font = NULL;
 196
 197     font_style->data = data;
 198 }
 199
 200 static void
 201 dispose(GObject *object)
 202 {
 203     AdgFontStyle *font_style = (AdgFontStyle *) object;
 204
 205     unset_font(font_style);
 206     unset_face(font_style);
 207
 208     if (PARENT_OBJECT_CLASS->dispose)
 209         PARENT_OBJECT_CLASS->dispose(object);
 210 }
 211
 212 static void
 213 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 214 {
 215     AdgFontStylePrivate *data = ((AdgFontStyle *) object)->data;
 216
 217     switch (prop_id) {
 218     case PROP_COLOR_DRESS:
 219         g_value_set_int(value, data->color_dress);
 220         break;
 221     case PROP_FAMILY:
 222         g_value_set_string(value, data->family);
 223         break;
 224     case PROP_SLANT:
 225         g_value_set_int(value, data->slant);
 226         break;
 227     case PROP_WEIGHT:
 228         g_value_set_int(value, data->weight);
 229         break;
 230     case PROP_SIZE:
 231         g_value_set_double(value, data->size);
 232         break;
 233     case PROP_ANTIALIAS:
 234         g_value_set_int(value, data->antialias);
 235         break;
 236     case PROP_SUBPIXEL_ORDER:
 237         g_value_set_int(value, data->subpixel_order);
 238         break;
 239     case PROP_HINT_STYLE:
 240         g_value_set_int(value, data->hint_style);
 241         break;
 242     case PROP_HINT_METRICS:
 243         g_value_set_int(value, data->hint_metrics);
 244         break;
 245     default:
 246         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 247         break;
 248     }
 249 }
 250
 251 static void
 252 set_property(GObject *object,
 253              guint prop_id, const GValue *value, GParamSpec *pspec)
 254 {
 255     AdgFontStyle *font_style;
 256     AdgFontStylePrivate *data;
 257
 258     font_style = (AdgFontStyle *) object;
 259     data = font_style->data;
 260
 261     switch (prop_id) {
 262     case PROP_COLOR_DRESS:
 263         adg_dress_set(&data->color_dress, g_value_get_int(value));
 264         break;
 265     case PROP_FAMILY:
 266         set_family(font_style, g_value_get_string(value));
 267         break;
 268     case PROP_SLANT:
 269         set_slant(font_style, g_value_get_int(value));
 270         break;
 271     case PROP_WEIGHT:
 272         set_weight(font_style, g_value_get_int(value));
 273         break;
 274     case PROP_SIZE:
 275         set_size(font_style, g_value_get_double(value));
 276         break;
 277     case PROP_ANTIALIAS:
 278         set_antialias(font_style, g_value_get_int(value));
 279         break;
 280     case PROP_SUBPIXEL_ORDER:
 281         set_subpixel_order(font_style, g_value_get_int(value));
 282         break;
 283     case PROP_HINT_STYLE:
 284         set_hint_style(font_style, g_value_get_int(value));
 285         break;
 286     case PROP_HINT_METRICS:
 287         set_hint_metrics(font_style, g_value_get_int(value));
 288         break;
 289     default:
 290         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 291         break;
 292     }
 293 }
 294
 295
 296 /**
 297  * adg_font_style_new:
 298  *
 299  * Constructs a new font style initialized with default params.
 300  *
 301  * Returns: a new font style
 302  **/
 303 AdgStyle *
 304 adg_font_style_new(void)
 305 {
 306     return g_object_new(ADG_TYPE_FONT_STYLE, NULL);
 307 }
 308
 309 /**
 310  * adg_font_style_get_scaled_font:
 311  * @font_style: an #AdgFontStyle object
 312  * @ctm: the current transformation matrix
 313  *
 314  * Gets the scaled font of @font_style. The returned font is
 315  * owned by @font_style and must not be destroyed by the caller.
 316  *
 317  * Returns: the scaled font
 318  **/
 319 cairo_scaled_font_t *
 320 adg_font_style_get_scaled_font(AdgFontStyle *font_style, const AdgMatrix *ctm)
 321 {
 322     AdgFontStylePrivate *data;
 323     cairo_font_options_t *options;
 324     AdgMatrix matrix;
 325
 326     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style), NULL);
 327     g_return_val_if_fail(ctm != NULL, NULL);
 328
 329     data = font_style->data;
 330
 331     /* Check for cached font */
 332     if (data->font != NULL) {
 333         AdgMatrix font_ctm;
 334
 335         cairo_scaled_font_get_ctm(data->font, &font_ctm);
 336
 337         /* The scaled font is valid only if the two ctm match */
 338         if (ctm->xx == font_ctm.xx && ctm->yy == font_ctm.yy &&
 339             ctm->xy == font_ctm.xy && ctm->yx == font_ctm.yx)
 340             return data->font;
 341
 342         /* No valid cache found: rebuild the scaled font */
 343         unset_font(font_style);
 344     }
 345
 346     if (data->face == NULL) {
 347         const gchar *family = data->family != NULL ? data->family : "";
 348
 349         data->face = cairo_toy_font_face_create(family, data->slant,
 350                                                 data->weight);
 351     }
 352
 353     cairo_matrix_init_scale(&matrix, data->size, data->size);
 354     options = cairo_font_options_create();
 355
 356     cairo_font_options_set_antialias(options, data->antialias);
 357     cairo_font_options_set_subpixel_order(options, data->subpixel_order);
 358     cairo_font_options_set_hint_style(options, data->hint_style);
 359     cairo_font_options_set_hint_metrics(options, data->hint_metrics);
 360
 361     data->font = cairo_scaled_font_create(data->face, &matrix, ctm, options);
 362
 363     cairo_font_options_destroy(options);
 364
 365     return data->font;
 366 }
 367
 368 /**
 369  * adg_font_style_set_color_dress:
 370  * @font_style: an #AdgFontStyle
 371  * @dress: the new color dress to use
 372  *
 373  * Sets a new color dress on @font_style. The new dress
 374  * should be related to the original dress: you cannot
 375  * set a dress used for font styles to a dress managing
 376  * fonts.
 377  *
 378  * The validation of the new dress is done by calling
 379  * adg_dress_are_related() with @dress and the previous
 380  * dress as arguments: check out its documentation for
 381  * details on what is a related dress.
 382  **/
 383 void
 384 adg_font_style_set_color_dress(AdgFontStyle *font_style, AdgDress dress)
 385 {
 386     AdgFontStylePrivate *data;
 387
 388     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 389
 390     data = font_style->data;
 391
 392     if (adg_dress_set(&data->color_dress, dress))
 393         g_object_notify((GObject *) font_style, "color-dress");
 394 }
 395
 396 /**
 397  * adg_font_style_get_color_dress:
 398  * @font_style: an #AdgFontStyle
 399  *
 400  * Gets the color dress used by @font_style.
 401  *
 402  * Returns: the current color dress
 403  **/
 404 AdgDress
 405 adg_font_style_get_color_dress(AdgFontStyle *font_style)
 406 {
 407     AdgFontStylePrivate *data;
 408
 409     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style), ADG_DRESS_UNDEFINED);
 410
 411     data = font_style->data;
 412
 413     return data->color_dress;
 414 }
 415
 416 /**
 417  * adg_font_style_set_family:
 418  * @font_style: an #AdgFontStyle object
 419  * @family: the new family
 420  *
 421  * Sets a new family.
 422  **/
 423 void
 424 adg_font_style_set_family(AdgFontStyle *font_style, const gchar *family)
 425 {
 426     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 427
 428     if (set_family(font_style, family))
 429         g_object_notify((GObject *) font_style, "family");
 430 }
 431
 432 /**
 433  * adg_font_style_get_family:
 434  * @font_style: an #AdgFontStyle object
 435  *
 436  * Gets the family of @font_style. The returned pointer refers to
 437  * internally managed text that must not be modified or freed.
 438  *
 439  * Returns: the requested family
 440  **/
 441 const gchar *
 442 adg_font_style_get_family(AdgFontStyle *font_style)
 443 {
 444     AdgFontStylePrivate *data;
 445
 446     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style), NULL);
 447
 448     data = font_style->data;
 449
 450     return data->family;
 451 }
 452
 453 /**
 454  * adg_font_style_set_slant:
 455  * @font_style: an #AdgFontStyle object
 456  * @slant: the new slant
 457  *
 458  * Sets a new slant variant on @font_style.
 459  **/
 460 void
 461 adg_font_style_set_slant(AdgFontStyle *font_style,
 462                          cairo_font_slant_t slant)
 463 {
 464     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 465
 466     if (set_slant(font_style, slant))
 467         g_object_notify((GObject *) font_style, "slant");
 468 }
 469
 470 /**
 471  * adg_font_style_get_slant:
 472  * @font_style: an #AdgFontStyle object
 473  *
 474  * Gets the slant variant of @font_style.
 475  *
 476  * Returns: the slant variant
 477  **/
 478 cairo_font_slant_t
 479 adg_font_style_get_slant(AdgFontStyle *font_style)
 480 {
 481     AdgFontStylePrivate *data;
 482
 483     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 484                          CAIRO_FONT_SLANT_NORMAL);
 485
 486     data = font_style->data;
 487
 488     return data->slant;
 489 }
 490
 491 /**
 492  * adg_font_style_set_weight:
 493  * @font_style: an #AdgFontStyle object
 494  * @weight: the new weight
 495  *
 496  * Sets a new weight variant on @font_style.
 497  **/
 498 void
 499 adg_font_style_set_weight(AdgFontStyle *font_style,
 500                           cairo_font_weight_t weight)
 501 {
 502     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 503
 504     if (set_weight(font_style, weight))
 505         g_object_notify((GObject *) font_style, "weight");
 506 }
 507
 508 /**
 509  * adg_font_style_get_weight:
 510  * @font_style: an #AdgFontStyle object
 511  *
 512  * Gets the weight variant of @font_style.
 513  *
 514  * Returns: the weight variant
 515  **/
 516 cairo_font_weight_t
 517 adg_font_style_get_weight(AdgFontStyle *font_style)
 518 {
 519     AdgFontStylePrivate *data;
 520
 521     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 522                          CAIRO_FONT_WEIGHT_NORMAL);
 523
 524     data = font_style->data;
 525
 526     return data->weight;
 527 }
 528
 529 /**
 530  * adg_font_style_set_size:
 531  * @font_style: an #AdgFontStyle object
 532  * @size: the new size
 533  *
 534  * Sets a new size (in global space) on @font_style.
 535  **/
 536 void
 537 adg_font_style_set_size(AdgFontStyle *font_style, gdouble size)
 538 {
 539     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 540
 541     if (set_size(font_style, size))
 542         g_object_notify((GObject *) font_style, "size");
 543 }
 544
 545 /**
 546  * adg_font_style_get_size:
 547  * @font_style: an #AdgFontStyle object
 548  *
 549  * Gets the size (in global space) of @font_style.
 550  *
 551  * Returns: the size variant
 552  **/
 553 gdouble
 554 adg_font_style_get_size(AdgFontStyle *font_style)
 555 {
 556     AdgFontStylePrivate *data;
 557
 558     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style), 0.);
 559
 560     data = font_style->data;
 561
 562     return data->size;
 563 }
 564
 565 /**
 566  * adg_font_style_set_antialias:
 567  * @font_style: an #AdgFontStyle object
 568  * @antialias: the new antialias mode
 569  *
 570  * Sets a new antialias mode.
 571  **/
 572 void
 573 adg_font_style_set_antialias(AdgFontStyle *font_style,
 574                              cairo_antialias_t antialias)
 575 {
 576     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 577
 578     if (set_antialias(font_style, antialias))
 579         g_object_notify((GObject *) font_style, "antialias");
 580 }
 581
 582 /**
 583  * adg_font_style_get_antialias:
 584  * @font_style: an #AdgFontStyle object
 585  *
 586  * Gets the antialias mode used.
 587  *
 588  * Returns: the requested antialias mode
 589  **/
 590 cairo_antialias_t
 591 adg_font_style_get_antialias(AdgFontStyle *font_style)
 592 {
 593     AdgFontStylePrivate *data;
 594
 595     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 596                          CAIRO_ANTIALIAS_DEFAULT);
 597
 598     data = font_style->data;
 599
 600     return data->antialias;
 601 }
 602
 603 /**
 604  * adg_font_style_set_subpixel_order:
 605  * @font_style: an #AdgFontStyle object
 606  * @subpixel_order: the new subpixel order mode
 607  *
 608  * Sets a new subpixel order mode.
 609  **/
 610 void
 611 adg_font_style_set_subpixel_order(AdgFontStyle *font_style,
 612                                   cairo_subpixel_order_t subpixel_order)
 613 {
 614     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 615
 616     if (set_subpixel_order(font_style, subpixel_order))
 617         g_object_notify((GObject *) font_style, "subpixel-order");
 618 }
 619
 620 /**
 621  * adg_font_style_get_subpixel_order:
 622  * @font_style: an #AdgFontStyle object
 623  *
 624  * Gets the subpixel order mode used, that is the order of color elements
 625  * within each pixel on the display device when rendering with an
 626  * antialiasing mode of %CAIRO_ANTIALIAS_SUBPIXEL.
 627  *
 628  * Returns: the requested subpixel order mode
 629  **/
 630 cairo_subpixel_order_t
 631 adg_font_style_get_subpixel_order(AdgFontStyle *font_style)
 632 {
 633     AdgFontStylePrivate *data;
 634
 635     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 636                          CAIRO_SUBPIXEL_ORDER_DEFAULT);
 637
 638     data = font_style->data;
 639
 640     return data->subpixel_order;
 641 }
 642
 643 /**
 644  * adg_font_style_set_hint_style:
 645  * @font_style: an #AdgFontStyle object
 646  * @hint_style: the new hint style mode
 647  *
 648  * Sets a new hint style mode.
 649  **/
 650 void
 651 adg_font_style_set_hint_style(AdgFontStyle *font_style,
 652                               cairo_hint_style_t hint_style)
 653 {
 654     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 655
 656     if (set_hint_style(font_style, hint_style))
 657         g_object_notify((GObject *) font_style, "hint-style");
 658 }
 659
 660 /**
 661  * adg_font_style_get_hint_style:
 662  * @font_style: an #AdgFontStyle object
 663  *
 664  * Gets the hint style mode used, that is how to fit outlines
 665  * to the pixel grid in order to improve the appearance of the result.
 666  *
 667  * Returns: the requested hint style mode
 668  **/
 669 cairo_hint_style_t
 670 adg_font_style_get_hint_style(AdgFontStyle *font_style)
 671 {
 672     AdgFontStylePrivate *data;
 673
 674     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 675                          CAIRO_HINT_STYLE_DEFAULT);
 676
 677     data = font_style->data;
 678
 679     return data->hint_style;
 680 }
 681
 682 /**
 683  * adg_font_style_set_hint_metrics:
 684  * @font_style: an #AdgFontStyle object
 685  * @hint_metrics: the new hint metrics state
 686  *
 687  * Sets a new hint metrics state.
 688  **/
 689 void
 690 adg_font_style_set_hint_metrics(AdgFontStyle *font_style,
 691                                 cairo_hint_metrics_t hint_metrics)
 692 {
 693     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 694
 695     if (set_hint_metrics(font_style, hint_metrics))
 696         g_object_notify((GObject *) font_style, "hint-metrics");
 697 }
 698
 699 /**
 700  * adg_font_style_get_hint_metrics:
 701  * @font_style: an #AdgFontStyle object
 702  *
 703  * Gets the state on whether to hint font metrics.
 704  *
 705  * Returns: the requested hint metrics state
 706  **/
 707 cairo_hint_metrics_t
 708 adg_font_style_get_hint_metrics(AdgFontStyle *font_style)
 709 {
 710     AdgFontStylePrivate *data;
 711
 712     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 713                          CAIRO_HINT_METRICS_DEFAULT);
 714
 715     data = font_style->data;
 716
 717     return data->hint_metrics;
 718 }
 719
 720
 721 static void
 722 apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
 723 {
 724     AdgFontStyle *font_style;
 725     AdgFontStylePrivate *data;
 726     AdgMatrix ctm;
 727     cairo_scaled_font_t *font;
 728
 729     font_style = (AdgFontStyle *) style;
 730     data = font_style->data;
 731
 732     adg_entity_apply_dress(entity, data->color_dress, cr);
 733
 734     cairo_get_matrix(cr, &ctm);
 735     font = adg_font_style_get_scaled_font((AdgFontStyle *) style, &ctm);
 736
 737     cairo_set_scaled_font(cr, font);
 738 }
 739
 740 static gboolean
 741 set_family(AdgFontStyle *font_style, const gchar *family)
 742 {
 743     AdgFontStylePrivate *data = font_style->data;
 744
 745     if (adg_strcmp(family, data->family) == 0)
 746         return FALSE;
 747
 748     g_free(data->family);
 749     data->family = g_strdup(family);
 750     unset_face(font_style);
 751
 752     return TRUE;
 753 }
 754
 755 static gboolean
 756 set_slant(AdgFontStyle *font_style, cairo_font_slant_t slant)
 757 {
 758     AdgFontStylePrivate *data = font_style->data;
 759
 760     if (slant == data->slant)
 761         return FALSE;
 762
 763     data->slant = slant;
 764     unset_face(font_style);
 765
 766     return TRUE;
 767 }
 768
 769 static gboolean
 770 set_weight(AdgFontStyle *font_style, cairo_font_weight_t weight)
 771 {
 772     AdgFontStylePrivate *data = font_style->data;
 773
 774     if (weight == data->weight)
 775         return FALSE;
 776
 777     data->weight = weight;
 778     unset_face(font_style);
 779
 780     return TRUE;
 781 }
 782
 783 static gboolean
 784 set_size(AdgFontStyle *font_style, gdouble size)
 785 {
 786     AdgFontStylePrivate *data = font_style->data;
 787
 788     if (size == data->size)
 789         return FALSE;
 790
 791     data->size = size;
 792     unset_font(font_style);
 793
 794     return TRUE;
 795 }
 796
 797 static gboolean
 798 set_antialias(AdgFontStyle *font_style, cairo_antialias_t antialias)
 799 {
 800     AdgFontStylePrivate *data = font_style->data;
 801
 802     if (antialias == data->antialias)
 803         return FALSE;
 804
 805     data->antialias = antialias;
 806     unset_font(font_style);
 807
 808     return TRUE;
 809 }
 810
 811 static gboolean
 812 set_subpixel_order(AdgFontStyle *font_style,
 813                    cairo_subpixel_order_t subpixel_order)
 814 {
 815     AdgFontStylePrivate *data = font_style->data;
 816
 817     if (subpixel_order == data->subpixel_order)
 818         return FALSE;
 819
 820     data->subpixel_order = subpixel_order;
 821     unset_font(font_style);
 822
 823     return TRUE;
 824 }
 825
 826 static gboolean
 827 set_hint_style(AdgFontStyle *font_style, cairo_hint_style_t hint_style)
 828 {
 829     AdgFontStylePrivate *data = font_style->data;
 830
 831     if (hint_style == data->hint_style)
 832         return FALSE;
 833
 834     data->hint_style = hint_style;
 835     unset_font(font_style);
 836
 837     return TRUE;
 838 }
 839
 840 static gboolean
 841 set_hint_metrics(AdgFontStyle *font_style, cairo_hint_metrics_t hint_metrics)
 842 {
 843     AdgFontStylePrivate *data = font_style->data;
 844
 845     if (hint_metrics == data->hint_metrics)
 846         return FALSE;
 847
 848     data->hint_metrics = hint_metrics;
 849     unset_font(font_style);
 850
 851     return TRUE;
 852 }
 853
 854 static void
 855 unset_face(AdgFontStyle *font_style)
 856 {
 857     AdgFontStylePrivate *data = font_style->data;
 858
 859     if (data->face == NULL)
 860         return;
 861
 862     /* Changing the face invalidates the scaled font too */
 863     unset_font(font_style);
 864
 865     cairo_font_face_destroy(data->face);
 866     data->face = NULL;
 867 }
 868
 869 static void
 870 unset_font(AdgFontStyle *font_style)
 871 {
 872     AdgFontStylePrivate *data = font_style->data;
 873
 874     if (data->font == NULL)
 875         return;
 876
 877     cairo_scaled_font_destroy(data->font);
 878     data->font = NULL;
 879 }