lib/tatypes.h

   1 /* tatypes.h */
   2
   3 /*
   4  * Copyright (C) 2011-2013 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 /* originally file `aftypes.h' (2011-Mar-30) from FreeType */
  17
  18 /* heavily modified 2011 by Werner Lemberg <wl@gnu.org> */
  19
  20 #ifndef __TATYPES_H__
  21 #define __TATYPES_H__
  22
  23 #include <ft2build.h>
  24
  25 #include FT_FREETYPE_H
  26 #include FT_OUTLINE_H
  27
  28 #include "tablue.h"
  29
  30
  31 /* enable one of the following three definitions for debugging */
  32 /* #define TA_DEBUG */
  33 /* #define TA_DEBUG_HORZ */
  34 #define TA_DEBUG_VERT
  35
  36 #if defined TA_DEBUG_HORZ
  37 #  define TA_DEBUG_STARTDIM TA_DIMENSION_HORZ
  38 #  define TA_DEBUG_ENDDIM TA_DIMENSION_HORZ
  39 #  define TA_DEBUG
  40 #elif defined TA_DEBUG_VERT
  41 #  define TA_DEBUG_STARTDIM TA_DIMENSION_VERT
  42 #  define TA_DEBUG_ENDDIM TA_DIMENSION_VERT
  43 #  define TA_DEBUG
  44 #elif defined TA_DEBUG
  45 #  define TA_DEBUG_STARTDIM TA_DIMENSION_VERT
  46 #  define TA_DEBUG_ENDDIM TA_DIMENSION_HORZ
  47 #endif
  48
  49 #ifdef TA_DEBUG
  50
  51 #define TA_LOG(x) \
  52   do \
  53   { \
  54     if (_ta_debug) \
  55       _ta_message x; \
  56   } while (0)
  57
  58 #define TA_LOG_GLOBAL(x) \
  59   do \
  60   { \
  61     if (_ta_debug_global) \
  62       _ta_message x; \
  63   } while (0)
  64
  65 void
  66 _ta_message(const char* format,
  67             ...);
  68
  69 extern int _ta_debug;
  70 extern int _ta_debug_global;
  71 extern int _ta_debug_disable_horz_hints;
  72 extern int _ta_debug_disable_vert_hints;
  73 extern int _ta_debug_disable_blue_hints;
  74 extern void* _ta_debug_hints;
  75
  76 #else /* !TA_DEBUG */
  77
  78 #define TA_LOG(x) \
  79   do { } while (0) /* nothing */
  80
  81 #define TA_LOG_GLOBAL(x) \
  82   do { } while (0) /* nothing */
  83
  84 #endif /* !TA_DEBUG */
  85
  86
  87 #define TA_ABS(a) ((a) < 0 ? -(a) : (a))
  88
  89 /* from file `ftobjs.h' from FreeType */
  90 #define TA_PAD_FLOOR(x, n) ((x) & ~((n) - 1))
  91 #define TA_PAD_ROUND(x, n) TA_PAD_FLOOR((x) + ((n) / 2), n)
  92 #define TA_PAD_CEIL(x, n) TA_PAD_FLOOR((x) + ((n) - 1), n)
  93
  94 #define TA_PIX_FLOOR(x) ((x) & ~63)
  95 #define TA_PIX_ROUND(x) TA_PIX_FLOOR((x) + 32)
  96 #define TA_PIX_CEIL(x) TA_PIX_FLOOR((x) + 63)
  97
  98
  99 typedef struct TA_WidthRec_
 100 {
 101   FT_Pos org; /* original position/width in font units */
 102   FT_Pos cur; /* current/scaled position/width in device sub-pixels */
 103   FT_Pos fit; /* current/fitted position/width in device sub-pixels */
 104 } TA_WidthRec, *TA_Width;
 105
 106
 107 /* the auto-hinter doesn't need a very high angular accuracy */
 108 typedef FT_Int TA_Angle;
 109
 110 #define TA_ANGLE_PI 256
 111 #define TA_ANGLE_2PI (TA_ANGLE_PI * 2)
 112 #define TA_ANGLE_PI2 (TA_ANGLE_PI / 2)
 113 #define TA_ANGLE_PI4 (TA_ANGLE_PI / 4)
 114
 115 #define TA_ANGLE_DIFF(result, angle1, angle2) \
 116           do \
 117           { \
 118             TA_Angle _delta = (angle2) - (angle1); \
 119 \
 120 \
 121             _delta %= TA_ANGLE_2PI; \
 122             if (_delta < 0) \
 123               _delta += TA_ANGLE_2PI; \
 124 \
 125             if (_delta > TA_ANGLE_PI) \
 126               _delta -= TA_ANGLE_2PI; \
 127 \
 128             result = _delta; \
 129           } while (0)
 130
 131
 132 /* opaque handle to glyph-specific hints -- */
 133 /* see `tahints.h' for more details */
 134 typedef struct TA_GlyphHintsRec_* TA_GlyphHints;
 135
 136
 137 /* a scaler models the target pixel device that will receive */
 138 /* the auto-hinted glyph image */
 139 #define TA_SCALER_FLAG_NO_HORIZONTAL 0x01 /* disable horizontal hinting */
 140 #define TA_SCALER_FLAG_NO_VERTICAL 0x02 /* disable vertical hinting */
 141 #define TA_SCALER_FLAG_NO_ADVANCE 0x04 /* disable advance hinting */
 142
 143 typedef struct TA_ScalerRec_
 144 {
 145   FT_Face face; /* source font face */
 146   FT_Fixed x_scale; /* from font units to 1/64th device pixels */
 147   FT_Fixed y_scale; /* from font units to 1/64th device pixels */
 148   FT_Pos x_delta; /* in 1/64th device pixels */
 149   FT_Pos y_delta; /* in 1/64th device pixels */
 150   FT_Render_Mode render_mode; /* monochrome, anti-aliased, LCD, etc.*/
 151   FT_UInt32 flags; /* additional control flags, see above */
 152 } TA_ScalerRec, *TA_Scaler;
 153
 154 #define TA_SCALER_EQUAL_SCALES(a, b) \
 155           ((a)->x_scale == (b)->x_scale \
 156            && (a)->y_scale == (b)->y_scale \
 157            && (a)->x_delta == (b)->x_delta \
 158            && (a)->y_delta == (b)->y_delta)
 159
 160
 161 /* This is the main structure which combines writing systems and script */
 162 /* data (for a given face object, see below). */
 163
 164 typedef struct TA_WritingSystemClassRec_ const* TA_WritingSystemClass;
 165 typedef struct TA_ScriptClassRec_ const* TA_ScriptClass;
 166 typedef struct TA_FaceGlobalsRec_* TA_FaceGlobals;
 167
 168 typedef struct TA_ScriptMetricsRec_
 169 {
 170   TA_ScriptClass script_class;
 171   TA_ScalerRec scaler;
 172   FT_Bool digits_have_same_width;
 173
 174   TA_FaceGlobals globals; /* to access properties */
 175 } TA_ScriptMetricsRec, *TA_ScriptMetrics;
 176
 177
 178 /* this function parses an FT_Face to compute global metrics */
 179 /* for a specific script */
 180 typedef FT_Error
 181 (*TA_Script_InitMetricsFunc)(TA_ScriptMetrics metrics,
 182                              FT_Face face);
 183 typedef void
 184 (*TA_Script_ScaleMetricsFunc)(TA_ScriptMetrics metrics,
 185                               TA_Scaler scaler);
 186 typedef void
 187 (*TA_Script_DoneMetricsFunc)(TA_ScriptMetrics metrics);
 188 typedef FT_Error
 189 (*TA_Script_InitHintsFunc)(TA_GlyphHints hints,
 190                            TA_ScriptMetrics metrics);
 191 typedef void
 192 (*TA_Script_ApplyHintsFunc)(TA_GlyphHints hints,
 193                             FT_Outline* outline,
 194                             TA_ScriptMetrics metrics);
 195
 196
 197 /*
 198  *  In FreeType, a writing system consists of multiple scripts which can
 199  *  be handled similarly *in a typographical way*; the relationship is not
 200  *  based on history.  For example, both the Greek and the unrelated
 201  *  Armenian scripts share the same features like ascender, descender,
 202  *  x-height, etc.  Essentially, a writing system is covered by a
 203  *  submodule of the auto-fitter; it contains
 204  *
 205  *  - a specific global analyzer which computes global metrics specific to
 206  *    the script (based on script-specific characters to identify ascender
 207  *    height, x-height, etc.),
 208  *
 209  *  - a specific glyph analyzer that computes segments and edges for each
 210  *    glyph covered by the script,
 211  *
 212  *  - a specific grid-fitting algorithm that distorts the scaled glyph
 213  *    outline according to the results of the glyph analyzer.
 214  */
 215
 216 #define __TAWRTSYS_H__ /* don't load header files */
 217 #undef WRITING_SYSTEM
 218 #define WRITING_SYSTEM(ws, WS) \
 219           TA_WRITING_SYSTEM_ ## WS,
 220
 221 /* The list of known writing systems. */
 222 typedef enum TA_WritingSystem_
 223 {
 224 #include "tawrtsys.h"
 225
 226   TA_WRITING_SYSTEM_MAX /* do not remove */
 227 } TA_WritingSystem;
 228
 229 #undef __TAWRTSYS_H__
 230
 231
 232 typedef struct TA_WritingSystemClassRec_
 233 {
 234   TA_WritingSystem writing_system;
 235
 236   FT_Offset script_metrics_size;
 237   TA_Script_InitMetricsFunc script_metrics_init;
 238   TA_Script_ScaleMetricsFunc script_metrics_scale;
 239   TA_Script_DoneMetricsFunc script_metrics_done;
 240
 241   TA_Script_InitHintsFunc script_hints_init;
 242   TA_Script_ApplyHintsFunc script_hints_apply;
 243 } TA_WritingSystemClassRec;
 244
 245
 246 /*
 247  *  Each script is associated with a set of Unicode ranges which gets used
 248  *  to test whether the font face supports the script.  It also references
 249  *  the writing system it belongs to.
 250  *
 251  *  We use four-letter script tags from the OpenType specification.
 252  */
 253
 254 #undef SCRIPT
 255 #define SCRIPT(s, S, d) \
 256           TA_SCRIPT_ ## S,
 257
 258 /* The list of known scripts. */
 259 typedef enum TA_Script_
 260 {
 261 #include <ttfautohint-scripts.h>
 262
 263   TA_SCRIPT_MAX /* do not remove */
 264 } TA_Script;
 265
 266
 267 typedef struct TA_Script_UniRangeRec_
 268 {
 269   FT_UInt32 first;
 270   FT_UInt32 last;
 271 } TA_Script_UniRangeRec;
 272
 273 #define TA_UNIRANGE_REC(a, b) \
 274           { (FT_UInt32)(a), (FT_UInt32)(b) }
 275
 276 typedef const TA_Script_UniRangeRec* TA_Script_UniRange;
 277
 278 typedef struct TA_ScriptClassRec_
 279 {
 280   TA_Script script;
 281   TA_Blue_Stringset blue_stringset;
 282   TA_WritingSystem writing_system;
 283
 284   TA_Script_UniRange script_uni_ranges; /* last must be { 0, 0 } */
 285   FT_UInt32 standard_char; /* for default width and height */
 286 } TA_ScriptClassRec;
 287
 288 #endif /* __TATYPES_H__ */
 289
 290 /* end of tatypes.h */