LCOV - code coverage report
Current view: directory - gfx/cairo/cairo/src - cairo-font-options.c (source / functions) Found Hit Coverage
Test: app.info Lines: 128 8 6.2 %
Date: 2012-06-02 Functions: 29 1 3.4 %

       1                 : /* cairo - a vector graphics library with display and print output
       2                 :  *
       3                 :  * Copyright © 2005 Red Hat Inc.
       4                 :  *
       5                 :  * This library is free software; you can redistribute it and/or
       6                 :  * modify it either under the terms of the GNU Lesser General Public
       7                 :  * License version 2.1 as published by the Free Software Foundation
       8                 :  * (the "LGPL") or, at your option, under the terms of the Mozilla
       9                 :  * Public License Version 1.1 (the "MPL"). If you do not alter this
      10                 :  * notice, a recipient may use your version of this file under either
      11                 :  * the MPL or the LGPL.
      12                 :  *
      13                 :  * You should have received a copy of the LGPL along with this library
      14                 :  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
      15                 :  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
      16                 :  * You should have received a copy of the MPL along with this library
      17                 :  * in the file COPYING-MPL-1.1
      18                 :  *
      19                 :  * The contents of this file are subject to the Mozilla Public License
      20                 :  * Version 1.1 (the "License"); you may not use this file except in
      21                 :  * compliance with the License. You may obtain a copy of the License at
      22                 :  * http://www.mozilla.org/MPL/
      23                 :  *
      24                 :  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
      25                 :  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
      26                 :  * the specific language governing rights and limitations.
      27                 :  *
      28                 :  * The Original Code is the cairo graphics library.
      29                 :  *
      30                 :  * The Initial Developer of the Original Code is University of Southern
      31                 :  * California.
      32                 :  *
      33                 :  * Contributor(s):
      34                 :  *      Owen Taylor <otaylor@redhat.com>
      35                 :  */
      36                 : 
      37                 : #include "cairoint.h"
      38                 : #include "cairo-error-private.h"
      39                 : 
      40                 : /**
      41                 :  * SECTION:cairo-font-options
      42                 :  * @Title: cairo_font_options_t
      43                 :  * @Short_Description: How a font should be rendered
      44                 :  * @See_Also: #cairo_scaled_font_t
      45                 :  *
      46                 :  * The font options specify how fonts should be rendered.  Most of the 
      47                 :  * time the font options implied by a surface are just right and do not 
      48                 :  * need any changes, but for pixel-based targets tweaking font options 
      49                 :  * may result in superior output on a particular display.
      50                 :  */
      51                 : 
      52                 : static const cairo_font_options_t _cairo_font_options_nil = {
      53                 :     CAIRO_ANTIALIAS_DEFAULT,
      54                 :     CAIRO_SUBPIXEL_ORDER_DEFAULT,
      55                 :     CAIRO_LCD_FILTER_DEFAULT,
      56                 :     CAIRO_HINT_STYLE_DEFAULT,
      57                 :     CAIRO_HINT_METRICS_DEFAULT,
      58                 :     CAIRO_ROUND_GLYPH_POS_DEFAULT
      59                 : };
      60                 : 
      61                 : /**
      62                 :  * _cairo_font_options_init_default:
      63                 :  * @options: a #cairo_font_options_t
      64                 :  *
      65                 :  * Initializes all fields of the font options object to default values.
      66                 :  **/
      67                 : void
      68              64 : _cairo_font_options_init_default (cairo_font_options_t *options)
      69                 : {
      70              64 :     options->antialias = CAIRO_ANTIALIAS_DEFAULT;
      71              64 :     options->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
      72              64 :     options->lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
      73              64 :     options->hint_style = CAIRO_HINT_STYLE_DEFAULT;
      74              64 :     options->hint_metrics = CAIRO_HINT_METRICS_DEFAULT;
      75              64 :     options->round_glyph_positions = CAIRO_ROUND_GLYPH_POS_DEFAULT;
      76              64 : }
      77                 : 
      78                 : void
      79               0 : _cairo_font_options_init_copy (cairo_font_options_t             *options,
      80                 :                                const cairo_font_options_t       *other)
      81                 : {
      82               0 :     options->antialias = other->antialias;
      83               0 :     options->subpixel_order = other->subpixel_order;
      84               0 :     options->lcd_filter = other->lcd_filter;
      85               0 :     options->hint_style = other->hint_style;
      86               0 :     options->hint_metrics = other->hint_metrics;
      87               0 :     options->round_glyph_positions = other->round_glyph_positions;
      88               0 : }
      89                 : 
      90                 : /**
      91                 :  * cairo_font_options_create:
      92                 :  *
      93                 :  * Allocates a new font options object with all options initialized
      94                 :  *  to default values.
      95                 :  *
      96                 :  * Return value: a newly allocated #cairo_font_options_t. Free with
      97                 :  *   cairo_font_options_destroy(). This function always returns a
      98                 :  *   valid pointer; if memory cannot be allocated, then a special
      99                 :  *   error object is returned where all operations on the object do nothing.
     100                 :  *   You can check for this with cairo_font_options_status().
     101                 :  **/
     102                 : cairo_font_options_t *
     103               0 : cairo_font_options_create (void)
     104                 : {
     105                 :     cairo_font_options_t *options;
     106                 : 
     107               0 :     options = malloc (sizeof (cairo_font_options_t));
     108               0 :     if (!options) {
     109               0 :         _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
     110               0 :         return (cairo_font_options_t *) &_cairo_font_options_nil;
     111                 :     }
     112                 : 
     113               0 :     _cairo_font_options_init_default (options);
     114                 : 
     115               0 :     return options;
     116                 : }
     117                 : 
     118                 : /**
     119                 :  * cairo_font_options_copy:
     120                 :  * @original: a #cairo_font_options_t
     121                 :  *
     122                 :  * Allocates a new font options object copying the option values from
     123                 :  *  @original.
     124                 :  *
     125                 :  * Return value: a newly allocated #cairo_font_options_t. Free with
     126                 :  *   cairo_font_options_destroy(). This function always returns a
     127                 :  *   valid pointer; if memory cannot be allocated, then a special
     128                 :  *   error object is returned where all operations on the object do nothing.
     129                 :  *   You can check for this with cairo_font_options_status().
     130                 :  **/
     131                 : cairo_font_options_t *
     132               0 : cairo_font_options_copy (const cairo_font_options_t *original)
     133                 : {
     134                 :     cairo_font_options_t *options;
     135                 : 
     136               0 :     if (cairo_font_options_status ((cairo_font_options_t *) original))
     137               0 :         return (cairo_font_options_t *) &_cairo_font_options_nil;
     138                 : 
     139               0 :     options = malloc (sizeof (cairo_font_options_t));
     140               0 :     if (!options) {
     141               0 :         _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
     142               0 :         return (cairo_font_options_t *) &_cairo_font_options_nil;
     143                 :     }
     144                 : 
     145               0 :     _cairo_font_options_init_copy (options, original);
     146                 : 
     147               0 :     return options;
     148                 : }
     149                 : 
     150                 : /**
     151                 :  * cairo_font_options_destroy:
     152                 :  * @options: a #cairo_font_options_t
     153                 :  *
     154                 :  * Destroys a #cairo_font_options_t object created with
     155                 :  * cairo_font_options_create() or cairo_font_options_copy().
     156                 :  **/
     157                 : void
     158               0 : cairo_font_options_destroy (cairo_font_options_t *options)
     159                 : {
     160               0 :     if (cairo_font_options_status (options))
     161               0 :         return;
     162                 : 
     163               0 :     free (options);
     164                 : }
     165                 : 
     166                 : /**
     167                 :  * cairo_font_options_status:
     168                 :  * @options: a #cairo_font_options_t
     169                 :  *
     170                 :  * Checks whether an error has previously occurred for this
     171                 :  * font options object
     172                 :  *
     173                 :  * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY
     174                 :  **/
     175                 : cairo_status_t
     176               0 : cairo_font_options_status (cairo_font_options_t *options)
     177                 : {
     178               0 :     if (options == NULL)
     179               0 :         return CAIRO_STATUS_NULL_POINTER;
     180               0 :     else if (options == (cairo_font_options_t *) &_cairo_font_options_nil)
     181               0 :         return CAIRO_STATUS_NO_MEMORY;
     182                 :     else
     183               0 :         return CAIRO_STATUS_SUCCESS;
     184                 : }
     185                 : slim_hidden_def (cairo_font_options_status);
     186                 : 
     187                 : /**
     188                 :  * cairo_font_options_merge:
     189                 :  * @options: a #cairo_font_options_t
     190                 :  * @other: another #cairo_font_options_t
     191                 :  *
     192                 :  * Merges non-default options from @other into @options, replacing
     193                 :  * existing values. This operation can be thought of as somewhat
     194                 :  * similar to compositing @other onto @options with the operation
     195                 :  * of %CAIRO_OPERATION_OVER.
     196                 :  **/
     197                 : void
     198               0 : cairo_font_options_merge (cairo_font_options_t       *options,
     199                 :                           const cairo_font_options_t *other)
     200                 : {
     201               0 :     if (cairo_font_options_status (options))
     202               0 :         return;
     203                 : 
     204               0 :     if (cairo_font_options_status ((cairo_font_options_t *) other))
     205               0 :         return;
     206                 : 
     207               0 :     if (other->antialias != CAIRO_ANTIALIAS_DEFAULT)
     208               0 :         options->antialias = other->antialias;
     209               0 :     if (other->subpixel_order != CAIRO_SUBPIXEL_ORDER_DEFAULT)
     210               0 :         options->subpixel_order = other->subpixel_order;
     211               0 :     if (other->lcd_filter != CAIRO_LCD_FILTER_DEFAULT)
     212               0 :         options->lcd_filter = other->lcd_filter;
     213               0 :     if (other->hint_style != CAIRO_HINT_STYLE_DEFAULT)
     214               0 :         options->hint_style = other->hint_style;
     215               0 :     if (other->hint_metrics != CAIRO_HINT_METRICS_DEFAULT)
     216               0 :         options->hint_metrics = other->hint_metrics;
     217               0 :     if (other->round_glyph_positions != CAIRO_ROUND_GLYPH_POS_DEFAULT)
     218               0 :         options->round_glyph_positions = other->round_glyph_positions;
     219                 : }
     220                 : slim_hidden_def (cairo_font_options_merge);
     221                 : 
     222                 : /**
     223                 :  * cairo_font_options_equal:
     224                 :  * @options: a #cairo_font_options_t
     225                 :  * @other: another #cairo_font_options_t
     226                 :  *
     227                 :  * Compares two font options objects for equality.
     228                 :  *
     229                 :  * Return value: %TRUE if all fields of the two font options objects match.
     230                 :  *      Note that this function will return %FALSE if either object is in
     231                 :  *      error.
     232                 :  **/
     233                 : cairo_bool_t
     234               0 : cairo_font_options_equal (const cairo_font_options_t *options,
     235                 :                           const cairo_font_options_t *other)
     236                 : {
     237               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     238               0 :         return FALSE;
     239               0 :     if (cairo_font_options_status ((cairo_font_options_t *) other))
     240               0 :         return FALSE;
     241                 : 
     242               0 :     if (options == other)
     243               0 :         return TRUE;
     244                 : 
     245               0 :     return (options->antialias == other->antialias &&
     246               0 :             options->subpixel_order == other->subpixel_order &&
     247               0 :             options->lcd_filter == other->lcd_filter &&
     248               0 :             options->hint_style == other->hint_style &&
     249               0 :             options->hint_metrics == other->hint_metrics &&
     250               0 :             options->round_glyph_positions == other->round_glyph_positions);
     251                 : }
     252                 : slim_hidden_def (cairo_font_options_equal);
     253                 : 
     254                 : /**
     255                 :  * cairo_font_options_hash:
     256                 :  * @options: a #cairo_font_options_t
     257                 :  *
     258                 :  * Compute a hash for the font options object; this value will
     259                 :  * be useful when storing an object containing a #cairo_font_options_t
     260                 :  * in a hash table.
     261                 :  *
     262                 :  * Return value: the hash value for the font options object.
     263                 :  *   The return value can be cast to a 32-bit type if a
     264                 :  *   32-bit hash value is needed.
     265                 :  **/
     266                 : unsigned long
     267               0 : cairo_font_options_hash (const cairo_font_options_t *options)
     268                 : {
     269               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     270               0 :         options = &_cairo_font_options_nil; /* force default values */
     271                 : 
     272               0 :     return ((options->antialias) |
     273               0 :             (options->subpixel_order << 4) |
     274               0 :             (options->lcd_filter << 8) |
     275               0 :             (options->hint_style << 12) |
     276               0 :             (options->hint_metrics << 16));
     277                 : }
     278                 : slim_hidden_def (cairo_font_options_hash);
     279                 : 
     280                 : /**
     281                 :  * cairo_font_options_set_antialias:
     282                 :  * @options: a #cairo_font_options_t
     283                 :  * @antialias: the new antialiasing mode
     284                 :  *
     285                 :  * Sets the antialiasing mode for the font options object. This
     286                 :  * specifies the type of antialiasing to do when rendering text.
     287                 :  **/
     288                 : void
     289               0 : cairo_font_options_set_antialias (cairo_font_options_t *options,
     290                 :                                   cairo_antialias_t     antialias)
     291                 : {
     292               0 :     if (cairo_font_options_status (options))
     293               0 :         return;
     294                 : 
     295               0 :     options->antialias = antialias;
     296                 : }
     297                 : slim_hidden_def (cairo_font_options_set_antialias);
     298                 : 
     299                 : /**
     300                 :  * cairo_font_options_get_antialias:
     301                 :  * @options: a #cairo_font_options_t
     302                 :  *
     303                 :  * Gets the antialiasing mode for the font options object.
     304                 :  *
     305                 :  * Return value: the antialiasing mode
     306                 :  **/
     307                 : cairo_antialias_t
     308               0 : cairo_font_options_get_antialias (const cairo_font_options_t *options)
     309                 : {
     310               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     311               0 :         return CAIRO_ANTIALIAS_DEFAULT;
     312                 : 
     313               0 :     return options->antialias;
     314                 : }
     315                 : 
     316                 : /**
     317                 :  * cairo_font_options_set_subpixel_order:
     318                 :  * @options: a #cairo_font_options_t
     319                 :  * @subpixel_order: the new subpixel order
     320                 :  *
     321                 :  * Sets the subpixel order for the font options object. The subpixel
     322                 :  * order specifies the order of color elements within each pixel on
     323                 :  * the display device when rendering with an antialiasing mode of
     324                 :  * %CAIRO_ANTIALIAS_SUBPIXEL. See the documentation for
     325                 :  * #cairo_subpixel_order_t for full details.
     326                 :  **/
     327                 : void
     328               0 : cairo_font_options_set_subpixel_order (cairo_font_options_t   *options,
     329                 :                                        cairo_subpixel_order_t  subpixel_order)
     330                 : {
     331               0 :     if (cairo_font_options_status (options))
     332               0 :         return;
     333                 : 
     334               0 :     options->subpixel_order = subpixel_order;
     335                 : }
     336                 : slim_hidden_def (cairo_font_options_set_subpixel_order);
     337                 : 
     338                 : /**
     339                 :  * cairo_font_options_get_subpixel_order:
     340                 :  * @options: a #cairo_font_options_t
     341                 :  *
     342                 :  * Gets the subpixel order for the font options object.
     343                 :  * See the documentation for #cairo_subpixel_order_t for full details.
     344                 :  *
     345                 :  * Return value: the subpixel order for the font options object
     346                 :  **/
     347                 : cairo_subpixel_order_t
     348               0 : cairo_font_options_get_subpixel_order (const cairo_font_options_t *options)
     349                 : {
     350               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     351               0 :         return CAIRO_SUBPIXEL_ORDER_DEFAULT;
     352                 : 
     353               0 :     return options->subpixel_order;
     354                 : }
     355                 : 
     356                 : /**
     357                 :  * _cairo_font_options_set_lcd_filter:
     358                 :  * @options: a #cairo_font_options_t
     359                 :  * @lcd_filter: the new LCD filter
     360                 :  *
     361                 :  * Sets the LCD filter for the font options object. The LCD filter
     362                 :  * specifies how pixels are filtered when rendered with an antialiasing
     363                 :  * mode of %CAIRO_ANTIALIAS_SUBPIXEL. See the documentation for
     364                 :  * #cairo_lcd_filter_t for full details.
     365                 :  *
     366                 :  * Since: 1.8
     367                 :  **/
     368                 : void
     369               0 : _cairo_font_options_set_lcd_filter (cairo_font_options_t *options,
     370                 :                                     cairo_lcd_filter_t    lcd_filter)
     371                 : {
     372               0 :     if (cairo_font_options_status (options))
     373               0 :         return;
     374                 : 
     375               0 :     options->lcd_filter = lcd_filter;
     376                 : }
     377                 : 
     378                 : /**
     379                 :  * _cairo_font_options_get_lcd_filter:
     380                 :  * @options: a #cairo_font_options_t
     381                 :  *
     382                 :  * Gets the LCD filter for the font options object.
     383                 :  * See the documentation for #cairo_lcd_filter_t for full details.
     384                 :  *
     385                 :  * Return value: the LCD filter for the font options object
     386                 :  *
     387                 :  * Since: 1.8
     388                 :  **/
     389                 : cairo_lcd_filter_t
     390               0 : _cairo_font_options_get_lcd_filter (const cairo_font_options_t *options)
     391                 : {
     392               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     393               0 :         return CAIRO_LCD_FILTER_DEFAULT;
     394                 : 
     395               0 :     return options->lcd_filter;
     396                 : }
     397                 : 
     398                 : /**
     399                 :  * _cairo_font_options_set_round_glyph_positions:
     400                 :  * @options: a #cairo_font_options_t
     401                 :  * @round: the new rounding value
     402                 :  *
     403                 :  * Sets the rounding options for the font options object. If rounding is set, a
     404                 :  * glyph's position will be rounded to integer values.
     405                 :  *
     406                 :  * Since: 1.12
     407                 :  **/
     408                 : void
     409               0 : _cairo_font_options_set_round_glyph_positions (cairo_font_options_t *options,
     410                 :                                                cairo_round_glyph_positions_t  round)
     411                 : {
     412               0 :     if (cairo_font_options_status (options))
     413               0 :         return;
     414                 : 
     415               0 :     options->round_glyph_positions = round;
     416                 : }
     417                 : 
     418                 : /**
     419                 :  * _cairo_font_options_get_round_glyph_positions:
     420                 :  * @options: a #cairo_font_options_t
     421                 :  *
     422                 :  * Gets the glyph position rounding option for the font options object.
     423                 :  *
     424                 :  * Return value: The round glyph posistions flag for the font options object.
     425                 :  *
     426                 :  * Since: 1.12
     427                 :  **/
     428                 : cairo_round_glyph_positions_t
     429               0 : _cairo_font_options_get_round_glyph_positions (const cairo_font_options_t *options)
     430                 : {
     431               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     432               0 :         return CAIRO_ROUND_GLYPH_POS_DEFAULT;
     433                 : 
     434               0 :     return options->round_glyph_positions;
     435                 : }
     436                 : 
     437                 : /**
     438                 :  * cairo_font_options_set_hint_style:
     439                 :  * @options: a #cairo_font_options_t
     440                 :  * @hint_style: the new hint style
     441                 :  *
     442                 :  * Sets the hint style for font outlines for the font options object.
     443                 :  * This controls whether to fit font outlines to the pixel grid,
     444                 :  * and if so, whether to optimize for fidelity or contrast.
     445                 :  * See the documentation for #cairo_hint_style_t for full details.
     446                 :  **/
     447                 : void
     448               0 : cairo_font_options_set_hint_style (cairo_font_options_t *options,
     449                 :                                    cairo_hint_style_t    hint_style)
     450                 : {
     451               0 :     if (cairo_font_options_status (options))
     452               0 :         return;
     453                 : 
     454               0 :     options->hint_style = hint_style;
     455                 : }
     456                 : slim_hidden_def (cairo_font_options_set_hint_style);
     457                 : 
     458                 : /**
     459                 :  * cairo_font_options_get_hint_style:
     460                 :  * @options: a #cairo_font_options_t
     461                 :  *
     462                 :  * Gets the hint style for font outlines for the font options object.
     463                 :  * See the documentation for #cairo_hint_style_t for full details.
     464                 :  *
     465                 :  * Return value: the hint style for the font options object
     466                 :  **/
     467                 : cairo_hint_style_t
     468               0 : cairo_font_options_get_hint_style (const cairo_font_options_t *options)
     469                 : {
     470               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     471               0 :         return CAIRO_HINT_STYLE_DEFAULT;
     472                 : 
     473               0 :     return options->hint_style;
     474                 : }
     475                 : 
     476                 : /**
     477                 :  * cairo_font_options_set_hint_metrics:
     478                 :  * @options: a #cairo_font_options_t
     479                 :  * @hint_metrics: the new metrics hinting mode
     480                 :  *
     481                 :  * Sets the metrics hinting mode for the font options object. This
     482                 :  * controls whether metrics are quantized to integer values in
     483                 :  * device units.
     484                 :  * See the documentation for #cairo_hint_metrics_t for full details.
     485                 :  **/
     486                 : void
     487               0 : cairo_font_options_set_hint_metrics (cairo_font_options_t *options,
     488                 :                                      cairo_hint_metrics_t  hint_metrics)
     489                 : {
     490               0 :     if (cairo_font_options_status (options))
     491               0 :         return;
     492                 : 
     493               0 :     options->hint_metrics = hint_metrics;
     494                 : }
     495                 : slim_hidden_def (cairo_font_options_set_hint_metrics);
     496                 : 
     497                 : /**
     498                 :  * cairo_font_options_get_hint_metrics:
     499                 :  * @options: a #cairo_font_options_t
     500                 :  *
     501                 :  * Gets the metrics hinting mode for the font options object.
     502                 :  * See the documentation for #cairo_hint_metrics_t for full details.
     503                 :  *
     504                 :  * Return value: the metrics hinting mode for the font options object
     505                 :  **/
     506                 : cairo_hint_metrics_t
     507               0 : cairo_font_options_get_hint_metrics (const cairo_font_options_t *options)
     508                 : {
     509               0 :     if (cairo_font_options_status ((cairo_font_options_t *) options))
     510               0 :         return CAIRO_HINT_METRICS_DEFAULT;
     511                 : 
     512               0 :     return options->hint_metrics;
     513                 : }

Generated by: LCOV version 1.7