src/adg/adg-font-style.c

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