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