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 /**
  38  * ADG_SLOT_FONT_STYLE:
  39  *
  40  * Gets the slot id for this style class.
  41  *
  42  * Return value: the requested slot id
  43  **/
  44
  45
  46 #include "adg-font-style.h"
  47 #include "adg-font-style-private.h"
  48 #include "adg-context.h"
  49 #include "adg-intl.h"
  50 #include "adg-util.h"
  51
  52
  53 enum {
  54     PROP_0,
  55     PROP_FAMILY,
  56     PROP_SLANT,
  57     PROP_WEIGHT,
  58     PROP_SIZE,
  59     PROP_ANTIALIAS,
  60     PROP_SUBPIXEL_ORDER,
  61     PROP_HINT_STYLE,
  62     PROP_HINT_METRICS
  63 };
  64
  65
  66 static void             get_property    (GObject        *object,
  67                                          guint           prop_id,
  68                                          GValue         *value,
  69                                          GParamSpec     *pspec);
  70 static void             set_property    (GObject        *object,
  71                                          guint           prop_id,
  72                                          const GValue   *value,
  73                                          GParamSpec     *pspec);
  74 static GPtrArray *      get_pool        (void);
  75 static void             apply           (AdgStyle       *style,
  76                                          cairo_t        *cr);
  77 static void             set_family      (AdgFontStyle   *font_style,
  78                                          const gchar    *family);
  79
  80
  81 G_DEFINE_TYPE(AdgFontStyle, adg_font_style, ADG_TYPE_STYLE)
  82
  83
  84 static void
  85 adg_font_style_class_init(AdgFontStyleClass *klass)
  86 {
  87     GObjectClass *gobject_class;
  88     AdgStyleClass *style_class;
  89     GParamSpec *param;
  90
  91     gobject_class = (GObjectClass *) klass;
  92     style_class = (AdgStyleClass *) klass;
  93
  94     g_type_class_add_private(klass, sizeof(AdgFontStylePrivate));
  95
  96     gobject_class->get_property = get_property;
  97     gobject_class->set_property = set_property;
  98
  99     style_class->get_pool = get_pool;
 100     style_class->apply = apply;
 101
 102     param = g_param_spec_string("family",
 103                                 P_("Font Family"),
 104                                 P_
 105                                 ("The font family name, encoded in UTF-8"),
 106                                 NULL, G_PARAM_READWRITE);
 107     g_object_class_install_property(gobject_class, PROP_FAMILY, param);
 108
 109     param = g_param_spec_int("slant",
 110                              P_("Font Slant"),
 111                              P_
 112                              ("Variant of a font face based on its slant"),
 113                              G_MININT, G_MAXINT, CAIRO_FONT_SLANT_NORMAL,
 114                              G_PARAM_READWRITE);
 115     g_object_class_install_property(gobject_class, PROP_SLANT, param);
 116
 117     param = g_param_spec_int("weight",
 118                              P_("Font Weight"),
 119                              P_
 120                              ("Variant of a font face based on its weight"),
 121                              G_MININT, G_MAXINT, CAIRO_FONT_WEIGHT_NORMAL,
 122                              G_PARAM_READWRITE);
 123     g_object_class_install_property(gobject_class, PROP_WEIGHT, param);
 124
 125     param = g_param_spec_double("size",
 126                                 P_("Font Size"),
 127                                 P_("Font size in user space units"),
 128                                 0., G_MAXDOUBLE, 10., G_PARAM_READWRITE);
 129     g_object_class_install_property(gobject_class, PROP_SIZE, param);
 130
 131     param = g_param_spec_int("antialias",
 132                              P_("Font Antialiasing Mode"),
 133                              P_
 134                              ("Type of antialiasing to do when rendering text"),
 135                              G_MININT, G_MAXINT, CAIRO_ANTIALIAS_DEFAULT,
 136                              G_PARAM_READWRITE);
 137     g_object_class_install_property(gobject_class, PROP_ANTIALIAS, param);
 138
 139     param = g_param_spec_int("subpixel-order",
 140                              P_("Font Subpixel Order"),
 141                              P_
 142                              ("The order of color elements within each pixel on the display device when rendering with subpixel antialiasing mode"),
 143                              G_MININT, G_MAXINT,
 144                              CAIRO_SUBPIXEL_ORDER_DEFAULT,
 145                              G_PARAM_READWRITE);
 146     g_object_class_install_property(gobject_class, PROP_SUBPIXEL_ORDER,
 147                                     param);
 148
 149     param = g_param_spec_int("hint-style",
 150                              P_("Type of Hinting"),
 151                              P_
 152                              ("How outlines must fit to the pixel grid in order to improve the glyph appearance"),
 153                              G_MININT, G_MAXINT, CAIRO_HINT_STYLE_DEFAULT,
 154                              G_PARAM_READWRITE);
 155     g_object_class_install_property(gobject_class, PROP_HINT_STYLE, param);
 156
 157     param = g_param_spec_int("hint-metrics",
 158                              P_("Font Metric Hinting"),
 159                              P_
 160                              ("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,
 165                                     param);
 166 }
 167
 168 static void
 169 adg_font_style_init(AdgFontStyle *font_style)
 170 {
 171     AdgFontStylePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(font_style,
 172                                                             ADG_TYPE_FONT_STYLE,
 173                                                             AdgFontStylePrivate);
 174
 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
 184     font_style->data = data;
 185 }
 186
 187 static void
 188 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 189 {
 190     AdgFontStylePrivate *data = ((AdgFontStyle *) object)->data;
 191
 192     switch (prop_id) {
 193     case PROP_FAMILY:
 194         g_value_set_string(value, data->family);
 195         break;
 196     case PROP_SLANT:
 197         g_value_set_int(value, data->slant);
 198         break;
 199     case PROP_WEIGHT:
 200         g_value_set_int(value, data->weight);
 201         break;
 202     case PROP_SIZE:
 203         g_value_set_double(value, data->size);
 204         break;
 205     case PROP_ANTIALIAS:
 206         g_value_set_int(value, data->antialias);
 207         break;
 208     case PROP_SUBPIXEL_ORDER:
 209         g_value_set_int(value, data->subpixel_order);
 210         break;
 211     case PROP_HINT_STYLE:
 212         g_value_set_int(value, data->hint_style);
 213         break;
 214     case PROP_HINT_METRICS:
 215         g_value_set_int(value, data->hint_metrics);
 216         break;
 217     default:
 218         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 219         break;
 220     }
 221 }
 222
 223 static void
 224 set_property(GObject *object,
 225              guint prop_id, const GValue *value, GParamSpec *pspec)
 226 {
 227     AdgFontStyle *font_style;
 228     AdgFontStylePrivate *data;
 229
 230     font_style = (AdgFontStyle *) object;
 231     data = font_style->data;
 232
 233     switch (prop_id) {
 234     case PROP_FAMILY:
 235         set_family(font_style, g_value_get_string(value));
 236         break;
 237     case PROP_SLANT:
 238         data->slant = g_value_get_int(value);
 239         break;
 240     case PROP_WEIGHT:
 241         data->weight = g_value_get_int(value);
 242         break;
 243     case PROP_SIZE:
 244         data->size = g_value_get_double(value);
 245         break;
 246     case PROP_ANTIALIAS:
 247         data->antialias = g_value_get_int(value);
 248         break;
 249     case PROP_SUBPIXEL_ORDER:
 250         data->subpixel_order = g_value_get_int(value);
 251         break;
 252     case PROP_HINT_STYLE:
 253         data->hint_style = g_value_get_int(value);
 254         break;
 255     case PROP_HINT_METRICS:
 256         data->hint_metrics = g_value_get_int(value);
 257         break;
 258     default:
 259         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 260         break;
 261     }
 262 }
 263
 264
 265 AdgStyleSlot
 266 _adg_font_style_get_slot(void)
 267 {
 268     static AdgStyleSlot slot = -1;
 269
 270     if (G_UNLIKELY(slot < 0))
 271         slot = adg_context_get_slot(ADG_TYPE_FONT_STYLE);
 272
 273     return slot;
 274 }
 275
 276 /**
 277  * adg_font_style_new:
 278  *
 279  * Constructs a new font style initialized with default params.
 280  *
 281  * Return value: a new font style
 282  **/
 283 AdgStyle *
 284 adg_font_style_new(void)
 285 {
 286     return g_object_new(ADG_TYPE_FONT_STYLE, NULL);
 287 }
 288
 289 /**
 290  * adg_font_style_get_family:
 291  * @font_style: an #AdgFontStyle object
 292  *
 293  * Gets the family of @font_style. The returned pointer refers to
 294  * internally managed text that must not be modified or freed.
 295  *
 296  * Return value: the requested family
 297  **/
 298 const gchar *
 299 adg_font_style_get_family(AdgFontStyle *font_style)
 300 {
 301     AdgFontStylePrivate *data;
 302
 303     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style), NULL);
 304
 305     data = font_style->data;
 306
 307     return data->family;
 308 }
 309
 310 /**
 311  * adg_font_style_set_family:
 312  * @font_style: an #AdgFontStyle object
 313  * @family: the new family
 314  *
 315  * Sets a new family.
 316  **/
 317 void
 318 adg_font_style_set_family(AdgFontStyle *font_style, const gchar *family)
 319 {
 320     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 321
 322     set_family(font_style, family);
 323     g_object_notify((GObject *) font_style, "family");
 324 }
 325
 326 /**
 327  * adg_font_style_get_slant:
 328  * @font_style: an #AdgFontStyle object
 329  *
 330  * Gets the slant variant of @font_style.
 331  *
 332  * Return value: the slant variant
 333  **/
 334 cairo_font_slant_t
 335 adg_font_style_get_slant(AdgFontStyle *font_style)
 336 {
 337     AdgFontStylePrivate *data;
 338
 339     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 340                          CAIRO_FONT_SLANT_NORMAL);
 341
 342     data = font_style->data;
 343
 344     return data->slant;
 345 }
 346
 347 /**
 348  * adg_font_style_set_slant:
 349  * @font_style: an #AdgFontStyle object
 350  * @slant: the new slant
 351  *
 352  * Sets a new slant variant on @font_style.
 353  **/
 354 void
 355 adg_font_style_set_slant(AdgFontStyle *font_style,
 356                          cairo_font_slant_t slant)
 357 {
 358     AdgFontStylePrivate *data;
 359
 360     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 361
 362     data = font_style->data;
 363     data->slant = slant;
 364
 365     g_object_notify((GObject *) font_style, "slant");
 366 }
 367
 368 /**
 369  * adg_font_style_get_weight:
 370  * @font_style: an #AdgFontStyle object
 371  *
 372  * Gets the weight variant of @font_style.
 373  *
 374  * Return value: the weight variant
 375  **/
 376 cairo_font_weight_t
 377 adg_font_style_get_weight(AdgFontStyle *font_style)
 378 {
 379     AdgFontStylePrivate *data;
 380
 381     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 382                          CAIRO_FONT_WEIGHT_NORMAL);
 383
 384     data = font_style->data;
 385
 386     return data->weight;
 387 }
 388
 389 /**
 390  * adg_font_style_set_weight:
 391  * @font_style: an #AdgFontStyle object
 392  * @weight: the new weight
 393  *
 394  * Sets a new weight variant on @font_style.
 395  **/
 396 void
 397 adg_font_style_set_weight(AdgFontStyle *font_style,
 398                           cairo_font_weight_t weight)
 399 {
 400     AdgFontStylePrivate *data;
 401
 402     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 403
 404     data = font_style->data;
 405     data->weight = weight;
 406
 407     g_object_notify((GObject *) font_style, "weight");
 408 }
 409
 410 /**
 411  * adg_font_style_get_size:
 412  * @font_style: an #AdgFontStyle object
 413  *
 414  * Gets the size (in paper units) of @font_style.
 415  *
 416  * Return value: the size variant
 417  **/
 418 gdouble
 419 adg_font_style_get_size(AdgFontStyle *font_style)
 420 {
 421     AdgFontStylePrivate *data;
 422
 423     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style), 0.);
 424
 425     data = font_style->data;
 426
 427     return data->size;
 428 }
 429
 430 /**
 431  * adg_font_style_set_size:
 432  * @font_style: an #AdgFontStyle object
 433  * @size: the new size
 434  *
 435  * Sets a new size (in paper units) on @font_style.
 436  **/
 437 void
 438 adg_font_style_set_size(AdgFontStyle *font_style, gdouble size)
 439 {
 440     AdgFontStylePrivate *data;
 441
 442     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 443
 444     data = font_style->data;
 445     data->size = size;
 446
 447     g_object_notify((GObject *) font_style, "size");
 448 }
 449
 450 /**
 451  * adg_font_style_get_antialias:
 452  * @font_style: an #AdgFontStyle object
 453  *
 454  * Gets the antialias mode used.
 455  *
 456  * Return value: the requested antialias mode
 457  **/
 458 cairo_antialias_t
 459 adg_font_style_get_antialias(AdgFontStyle *font_style)
 460 {
 461     AdgFontStylePrivate *data;
 462
 463     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 464                          CAIRO_ANTIALIAS_DEFAULT);
 465
 466     data = font_style->data;
 467
 468     return data->antialias;
 469 }
 470
 471 /**
 472  * adg_font_style_set_antialias:
 473  * @font_style: an #AdgFontStyle object
 474  * @antialias: the new antialias mode
 475  *
 476  * Sets a new antialias mode.
 477  **/
 478 void
 479 adg_font_style_set_antialias(AdgFontStyle *font_style,
 480                              cairo_antialias_t antialias)
 481 {
 482     AdgFontStylePrivate *data;
 483
 484     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 485
 486     data = font_style->data;
 487     data->antialias = antialias;
 488
 489     g_object_notify((GObject *) font_style, "antialias");
 490 }
 491
 492 /**
 493  * adg_font_style_get_subpixel_order:
 494  * @font_style: an #AdgFontStyle object
 495  *
 496  * Gets the subpixel order mode used, that is the order of color elements
 497  * within each pixel on the display device when rendering with an
 498  * antialiasing mode of %CAIRO_ANTIALIAS_SUBPIXEL.
 499  *
 500  * Return value: the requested subpixel order mode
 501  **/
 502 cairo_subpixel_order_t
 503 adg_font_style_get_subpixel_order(AdgFontStyle *font_style)
 504 {
 505     AdgFontStylePrivate *data;
 506
 507     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 508                          CAIRO_SUBPIXEL_ORDER_DEFAULT);
 509
 510     data = font_style->data;
 511
 512     return data->subpixel_order;
 513 }
 514
 515 /**
 516  * adg_font_style_set_subpixel_order:
 517  * @font_style: an #AdgFontStyle object
 518  * @subpixel_order: the new subpixel order mode
 519  *
 520  * Sets a new subpixel order mode.
 521  **/
 522 void
 523 adg_font_style_set_subpixel_order(AdgFontStyle *font_style,
 524                                   cairo_subpixel_order_t subpixel_order)
 525 {
 526     AdgFontStylePrivate *data;
 527
 528     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 529
 530     data = font_style->data;
 531     data->subpixel_order = subpixel_order;
 532
 533     g_object_notify((GObject *) font_style, "subpixel-order");
 534 }
 535
 536 /**
 537  * adg_font_style_get_hint_style:
 538  * @font_style: an #AdgFontStyle object
 539  *
 540  * Gets the hint style mode used, that is how to fit outlines
 541  * to the pixel grid in order to improve the appearance of the result.
 542  *
 543  * Return value: the requested hint style mode
 544  **/
 545 cairo_hint_style_t
 546 adg_font_style_get_hint_style(AdgFontStyle *font_style)
 547 {
 548     AdgFontStylePrivate *data;
 549
 550     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 551                          CAIRO_HINT_STYLE_DEFAULT);
 552
 553     data = font_style->data;
 554
 555     return data->hint_style;
 556 }
 557
 558 /**
 559  * adg_font_style_set_hint_style:
 560  * @font_style: an #AdgFontStyle object
 561  * @hint_style: the new hint style mode
 562  *
 563  * Sets a new hint style mode.
 564  **/
 565 void
 566 adg_font_style_set_hint_style(AdgFontStyle *font_style,
 567                               cairo_hint_style_t hint_style)
 568 {
 569     AdgFontStylePrivate *data;
 570
 571     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 572
 573     data = font_style->data;
 574     data->hint_style = hint_style;
 575
 576     g_object_notify((GObject *) font_style, "hint-style");
 577 }
 578
 579 /**
 580  * adg_font_style_get_hint_metrics:
 581  * @font_style: an #AdgFontStyle object
 582  *
 583  * Gets the state on whether to hint font metrics.
 584  *
 585  * Return value: the requested hint metrics state
 586  **/
 587 cairo_hint_metrics_t
 588 adg_font_style_get_hint_metrics(AdgFontStyle *font_style)
 589 {
 590     AdgFontStylePrivate *data;
 591
 592     g_return_val_if_fail(ADG_IS_FONT_STYLE(font_style),
 593                          CAIRO_HINT_METRICS_DEFAULT);
 594
 595     data = font_style->data;
 596
 597     return data->hint_metrics;
 598 }
 599
 600 /**
 601  * adg_font_style_set_hint_metrics:
 602  * @font_style: an #AdgFontStyle object
 603  * @hint_metrics: the new hint metrics state
 604  *
 605  * Sets a new hint metrics state.
 606  **/
 607 void
 608 adg_font_style_set_hint_metrics(AdgFontStyle *font_style,
 609                                 cairo_hint_metrics_t hint_metrics)
 610 {
 611     AdgFontStylePrivate *data;
 612
 613     g_return_if_fail(ADG_IS_FONT_STYLE(font_style));
 614
 615     data = font_style->data;
 616     data->hint_metrics = hint_metrics;
 617
 618     g_object_notify((GObject *) font_style, "hint-metrics");
 619 }
 620
 621
 622 static GPtrArray *
 623 get_pool(void)
 624 {
 625     static GPtrArray *pool = NULL;
 626
 627     if (G_UNLIKELY(pool == NULL)) {
 628         pool = g_ptr_array_sized_new(ADG_FONT_STYLE_LAST);
 629
 630         pool->pdata[ADG_FONT_STYLE_TEXT] =
 631             g_object_new(ADG_TYPE_FONT_STYLE, "family", "Serif", "size",
 632                          14., NULL);
 633         pool->pdata[ADG_FONT_STYLE_QUOTE] =
 634             g_object_new(ADG_TYPE_FONT_STYLE, "family", "Sans", "size",
 635                          12., "weight", CAIRO_FONT_WEIGHT_BOLD, NULL);
 636         pool->pdata[ADG_FONT_STYLE_TOLERANCE] =
 637             g_object_new(ADG_TYPE_FONT_STYLE, "family", "Sans", "size", 8.,
 638                          NULL);
 639         pool->pdata[ADG_FONT_STYLE_NOTE] =
 640             g_object_new(ADG_TYPE_FONT_STYLE, "family", "Sans", "size",
 641                          12., NULL);
 642
 643         pool->len = ADG_FONT_STYLE_LAST;
 644         }
 645
 646     return pool;
 647 }
 648
 649 static void
 650 apply(AdgStyle *style, cairo_t *cr)
 651 {
 652     AdgFontStyle *font_style;
 653     AdgFontStylePrivate *data;
 654     AdgStyleClass *style_class;
 655     double size;
 656     cairo_font_options_t *options;
 657     cairo_matrix_t matrix;
 658     cairo_matrix_t font_matrix;
 659
 660     font_style = (AdgFontStyle *) style;
 661     data = font_style->data;
 662     style_class = (AdgStyleClass *) adg_font_style_parent_class;
 663     cairo_get_matrix(cr, &matrix);
 664     size = data->size;
 665
 666     if (style_class->apply != NULL)
 667         style_class->apply(style, cr);
 668
 669     if (data->family)
 670         cairo_select_font_face(cr, data->family,
 671                                data->slant, data->weight);
 672
 673     cairo_matrix_init_scale(&font_matrix,
 674                             size / (matrix.xx - matrix.yx),
 675                             size / (matrix.yy + matrix.xy));
 676     cairo_set_font_matrix(cr, &font_matrix);
 677
 678     options = cairo_font_options_create();
 679
 680     cairo_font_options_set_antialias(options, data->antialias);
 681     cairo_font_options_set_subpixel_order(options, data->subpixel_order);
 682     cairo_font_options_set_hint_style(options, data->hint_style);
 683     cairo_font_options_set_hint_metrics(options, data->hint_metrics);
 684
 685     cairo_set_font_options(cr, options);
 686     cairo_font_options_destroy(options);
 687 }
 688
 689 static void
 690 set_family(AdgFontStyle *font_style, const gchar *family)
 691 {
 692     AdgFontStylePrivate *data = font_style->data;
 693
 694     g_free(data->family);
 695     data->family = g_strdup(family);
 696 }