vcl/inc/sft.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 /**
  21  * @file sft.hxx
  22  * @brief Sun Font Tools
  23  * @author Alexander Gelfenbain
  24  */
  25
  26 /*
  27  *        If NO_MAPPERS is defined, MapChar() and MapString() and consequently GetTTSimpleCharMetrics()
  28  *        don't get compiled in. This is done to avoid including a large chunk of code (TranslateXY() from
  29  *        xlat.c in the projects that don't require it.
  30  *
  31  *        If NO_TYPE3 is defined CreateT3FromTTGlyphs() does not get compiled in.
  32  *        If NO_TYPE42 is defined Type42-related code is excluded
  33  *        If NO_TTCR is defined TrueType creation related code is excluded\
  34  */
  35
  36 /*
  37  *        Generated fonts contain an XUID entry in the form of:
  38  *
  39  *                  103 0 T C1 N C2 C3
  40  *
  41  *        103 - Sun's Adobe assigned XUID number. Contact person: Alexander Gelfenbain <gelf@eng.sun.com>
  42  *
  43  *        T  - font type. 0: Type 3, 1: Type 42
  44  *        C1 - CRC-32 of the entire source TrueType font
  45  *        N  - number of glyphs in the subset
  46  *        C2 - CRC-32 of the array of glyph IDs used to generate the subset
  47  *        C3 - CRC-32 of the array of encoding numbers used to generate the subset
  48  *
  49  */
  50
  51 #ifndef INCLUDED_VCL_INC_SFT_HXX
  52 #define INCLUDED_VCL_INC_SFT_HXX
  53
  54 #ifdef UNX
  55 #include <sys/types.h>
  56 #include <unistd.h>
  57 #endif
  58 #include <stdio.h>
  59
  60 #include <sal/types.h>
  61
  62 #include "vcl/dllapi.h"
  63
  64 #include <vector>
  65
  66 #include "vcl/fontcapabilities.hxx"
  67
  68 namespace vcl
  69 {
  70
  71 /*@{*/
  72     typedef sal_Int16       F2Dot14;            /**< fixed: 2.14 */
  73     typedef sal_Int32       F16Dot16;           /**< fixed: 16.16 */
  74 /*@}*/
  75
  76     typedef struct {
  77         sal_uInt16 s;
  78         sal_uInt16 d;
  79     } sal_uInt16pair;
  80
  81 /** Return value of OpenTTFont() and CreateT3FromTTGlyphs() */
  82     enum SFErrCodes {
  83         SF_OK,                              /**< no error                                     */
  84         SF_BADFILE,                         /**< file not found                               */
  85         SF_FILEIO,                          /**< file I/O error                               */
  86         SF_MEMORY,                          /**< memory allocation error                      */
  87         SF_GLYPHNUM,                        /**< incorrect number of glyphs                   */
  88         SF_BADARG,                          /**< incorrect arguments                          */
  89         SF_TTFORMAT,                        /**< incorrect TrueType font format               */
  90         SF_TABLEFORMAT,                     /**< incorrect format of a TrueType table         */
  91         SF_FONTNO                           /**< incorrect logical font number of a TTC font  */
  92     };
  93
  94 #ifndef FW_THIN /* WIN32 compilation would conflict */
  95 /** Value of the weight member of the TTGlobalFontInfo struct */
  96     enum WeightClass {
  97         FW_THIN = 100,                      /**< Thin                               */
  98         FW_EXTRALIGHT = 200,                /**< Extra-light (Ultra-light)          */
  99         FW_LIGHT = 300,                     /**< Light                              */
 100         FW_NORMAL = 400,                    /**< Normal (Regular)                   */
 101         FW_MEDIUM = 500,                    /**< Medium                             */
 102         FW_SEMIBOLD = 600,                  /**< Semi-bold (Demi-bold)              */
 103         FW_BOLD = 700,                      /**< Bold                               */
 104         FW_EXTRABOLD = 800,                 /**< Extra-bold (Ultra-bold)            */
 105         FW_BLACK = 900                      /**< Black (Heavy)                      */
 106     };
 107
 108 /** Value of the width member of the TTGlobalFontInfo struct */
 109     enum WidthClass {
 110         FWIDTH_ULTRA_CONDENSED = 1,         /**< 50% of normal                      */
 111         FWIDTH_EXTRA_CONDENSED = 2,         /**< 62.5% of normal                    */
 112         FWIDTH_CONDENSED = 3,               /**< 75% of normal                      */
 113         FWIDTH_SEMI_CONDENSED = 4,          /**< 87.5% of normal                    */
 114         FWIDTH_NORMAL = 5,                  /**< Medium, 100%                       */
 115         FWIDTH_SEMI_EXPANDED = 6,           /**< 112.5% of normal                   */
 116         FWIDTH_EXPANDED = 7,                /**< 125% of normal                     */
 117         FWIDTH_EXTRA_EXPANDED = 8,          /**< 150% of normal                     */
 118         FWIDTH_ULTRA_EXPANDED = 9           /**< 200% of normal                     */
 119     };
 120 #endif /* FW_THIN */
 121
 122 /** Type of the 'kern' table, stored in _TrueTypeFont::kerntype */
 123     enum KernType {
 124         KT_NONE         = 0,                /**< no kern table                      */
 125         KT_APPLE_NEW    = 1,                /**< new Apple kern table               */
 126         KT_MICROSOFT    = 2                 /**< Microsoft table                    */
 127     };
 128
 129 /* Composite glyph flags definition */
 130     enum CompositeFlags {
 131         ARG_1_AND_2_ARE_WORDS     = 1,
 132         ARGS_ARE_XY_VALUES        = 1<<1,
 133         ROUND_XY_TO_GRID          = 1<<2,
 134         WE_HAVE_A_SCALE           = 1<<3,
 135         MORE_COMPONENTS           = 1<<5,
 136         WE_HAVE_AN_X_AND_Y_SCALE  = 1<<6,
 137         WE_HAVE_A_TWO_BY_TWO      = 1<<7,
 138         WE_HAVE_INSTRUCTIONS      = 1<<8,
 139         USE_MY_METRICS            = 1<<9,
 140         OVERLAP_COMPOUND          = 1<<10
 141     };
 142
 143 #ifndef NO_TTCR
 144 /** Flags for TrueType generation */
 145     enum TTCreationFlags {
 146         TTCF_AutoName = 1,                  /**< Automatically generate a compact 'name' table.
 147                                                If this flag is not set, name table is generated
 148                                                either from an array of NameRecord structs passed as
 149                                                arguments or if the array is NULL, 'name' table
 150                                                of the generated TrueType file will be a copy
 151                                                of the name table of the original file.
 152                                                If this flag is set the array of NameRecord structs
 153                                                is ignored and a very compact 'name' table is automatically
 154                                                generated. */
 155
 156         TTCF_IncludeOS2 = 2                 /** If this flag is set OS/2 table from the original font will be
 157                                                 copied to the subset */
 158     };
 159 #endif
 160
 161 /** Structure used by GetTTSimpleGlyphMetrics() and GetTTSimpleCharMetrics() functions */
 162     typedef struct {
 163         sal_uInt16 adv;                         /**< advance width or height            */
 164         sal_Int16 sb;                           /**< left or top sidebearing            */
 165     } TTSimpleGlyphMetrics;
 166
 167 /** Structure used by the TrueType Creator and GetRawGlyphData() */
 168
 169     typedef struct {
 170         sal_uInt32 glyphID;                     /**< glyph ID                           */
 171         sal_uInt16 nbytes;                      /**< number of bytes in glyph data      */
 172         sal_uInt8  *ptr;                         /**< pointer to glyph data              */
 173         sal_uInt16 aw;                          /**< advance width                      */
 174         sal_Int16  lsb;                         /**< left sidebearing                   */
 175         bool compflag;                          /**< false- if non-composite */
 176         sal_uInt16 npoints;                     /**< number of points                   */
 177         sal_uInt16 ncontours;                   /**< number of contours                 */
 178         /* */
 179         sal_uInt32 newID;                       /**< used internally by the TTCR        */
 180     } GlyphData;
 181
 182 /** Structure used by the TrueType Creator and CreateTTFromTTGlyphs() */
 183     typedef struct {
 184         sal_uInt16 platformID;                  /**< Platform ID                                            */
 185         sal_uInt16 encodingID;                  /**< Platform-specific encoding ID                          */
 186         sal_uInt16 languageID;                  /**< Language ID                                            */
 187         sal_uInt16 nameID;                      /**< Name ID                                                */
 188         sal_uInt16 slen;                        /**< String length in bytes                                 */
 189         sal_uInt8  *sptr;                        /**< Pointer to string data (not zero-terminated!)          */
 190     } NameRecord;
 191
 192 /** Return value of GetTTGlobalFontInfo() */
 193
 194     typedef struct {
 195         char *family;             /**< family name                                             */
 196         sal_uInt16 *ufamily;          /**< family name UCS2                                         */
 197         char *subfamily;          /**< subfamily name                                          */
 198         sal_uInt16 *usubfamily;   /**< subfamily name UCS2 */
 199         char *psname;             /**< PostScript name                                         */
 200         sal_uInt16 macStyle;      /**< macstyle bits from 'HEAD' table */
 201         int   weight;             /**< value of WeightClass or 0 if can't be determined        */
 202         int   width;              /**< value of WidthClass or 0 if can't be determined         */
 203         int   pitch;              /**< 0: proportianal font, otherwise: monospaced             */
 204         int   italicAngle;        /**< in counter-clockwise degrees * 65536                    */
 205         int   xMin;               /**< global bounding box: xMin                               */
 206         int   yMin;               /**< global bounding box: yMin                               */
 207         int   xMax;               /**< global bounding box: xMax                               */
 208         int   yMax;               /**< global bounding box: yMax                               */
 209         int   ascender;           /**< typographic ascent.                                     */
 210         int   descender;          /**< typographic descent.                                    */
 211         int   linegap;            /**< typographic line gap.\ Negative values are treated as
 212                                      zero in Win 3.1, System 6 and System 7.                 */
 213         int   vascent;            /**< typographic ascent for vertical writing mode            */
 214         int   vdescent;           /**< typographic descent for vertical writing mode           */
 215         int   typoAscender;       /**< OS/2 portable typographic ascender                      */
 216         int   typoDescender;      /**< OS/2 portable typographic descender                     */
 217         int   typoLineGap;        /**< OS/2 portable typographc line gap                       */
 218         int   winAscent;          /**< ascender metric for Windows                             */
 219         int   winDescent;         /**< descender metric for Windows                            */
 220         bool  symbolEncoded;      /**< true: MS symbol encoded */
 221         int   rangeFlag;          /**< if set to 1 Unicode Range flags are applicable          */
 222         sal_uInt32 ur1;               /**< bits 0 - 31 of Unicode Range flags                      */
 223         sal_uInt32 ur2;               /**< bits 32 - 63 of Unicode Range flags                     */
 224         sal_uInt32 ur3;               /**< bits 64 - 95 of Unicode Range flags                     */
 225         sal_uInt32 ur4;               /**< bits 96 - 127 of Unicode Range flags                    */
 226         sal_uInt8   panose[10];        /**< PANOSE classification number                            */
 227         sal_uInt32 typeFlags;         /**< type flags (copyright bits + PS-OpenType flag)       */
 228     } TTGlobalFontInfo;
 229
 230 #define TYPEFLAG_INVALID        0x8000000
 231 #define TYPEFLAG_COPYRIGHT_MASK 0x000000E
 232 #define TYPEFLAG_PS_OPENTYPE    0x0010000
 233
 234 /** Structure used by KernGlyphs()      */
 235     typedef struct {
 236         int x;                    /**< positive: right, negative: left                        */
 237         int y;                    /**< positive: up, negative: down                           */
 238     } KernData;
 239
 240 /** ControlPoint structure used by GetTTGlyphPoints() */
 241     typedef struct {
 242         sal_uInt32 flags;             /**< 00000000 00000000 e0000000 bbbbbbbb */
 243         /**< b - byte flags from the glyf array  */
 244         /**< e == 0 - regular point              */
 245         /**< e == 1 - end contour                */
 246         sal_Int16 x;                  /**< X coordinate in EmSquare units      */
 247         sal_Int16 y;                  /**< Y coordinate in EmSquare units      */
 248     } ControlPoint;
 249
 250     typedef struct _TrueTypeFont TrueTypeFont;
 251
 252 /**
 253  * @defgroup sft Sun Font Tools Exported Functions
 254  */
 255
 256 /**
 257  * Get the number of fonts contained in a TrueType collection
 258  * @param  fname - file name
 259  * @return number of fonts or zero, if file is not a TTC file.
 260  * @ingroup sft
 261  */
 262     int CountTTCFonts(const char* fname);
 263
 264 /**
 265  * TrueTypeFont constructor.
 266  * The font file has to be provided as a memory buffer and length
 267  * @param  facenum - logical font number within a TTC file. This value is ignored
 268  *                   for TrueType fonts
 269  * @return value of SFErrCodes enum
 270  * @ingroup sft
 271  */
 272     int VCL_DLLPUBLIC OpenTTFontBuffer(const void* pBuffer, sal_uInt32 nLen, sal_uInt32 facenum, TrueTypeFont** ttf);
 273 #if !defined(WIN32)
 274 /**
 275  * TrueTypeFont constructor.
 276  * Reads the font file and allocates the memory for the structure.
 277  * on WIN32 the font has to be provided as a memory buffer and length
 278  * @param  facenum - logical font number within a TTC file. This value is ignored
 279  *                   for TrueType fonts
 280  * @return value of SFErrCodes enum
 281  * @ingroup sft
 282  */
 283     int VCL_DLLPUBLIC OpenTTFontFile(const char *fname, sal_uInt32 facenum, TrueTypeFont** ttf);
 284 #endif
 285
 286     void getTTScripts(std::vector< sal_uInt32 > &rScriptTags, const unsigned char* pTable, size_t nLength);
 287     bool getTTCoverage(
 288         boost::dynamic_bitset<sal_uInt32> &rUnicodeCoverage,
 289         boost::dynamic_bitset<sal_uInt32> &rCodePageCoverage,
 290         const unsigned char* pTable, size_t nLength);
 291
 292 /**
 293  * TrueTypeFont destructor. Deallocates the memory.
 294  * @ingroup sft
 295  */
 296     void VCL_DLLPUBLIC CloseTTFont(TrueTypeFont *);
 297
 298 /**
 299  * Extracts TrueType control points, and stores them in an allocated array pointed to
 300  * by *pointArray. This function returns the number of extracted points.
 301  *
 302  * @param ttf         pointer to the TrueTypeFont structure
 303  * @param glyphID     Glyph ID
 304  * @param pointArray  Return value - address of the pointer to the first element of the array
 305  *                    of points allocated by the function
 306  * @return            Returns the number of points in *pointArray or -1 if glyphID is
 307  *                    invalid.
 308  * @ingroup sft
 309  *
 310  */
 311     int GetTTGlyphPoints(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray);
 312
 313 /**
 314  * Extracts raw glyph data from the 'glyf' table and returns it in an allocated
 315  * GlyphData structure.
 316  *
 317  * @param ttf         pointer to the TrueTypeFont structure
 318  * @param glyphID     Glyph ID
 319  *
 320  * @return            pointer to an allocated GlyphData structure or NULL if
 321  *                    glyphID is not present in the font
 322  * @ingroup sft
 323  *
 324  */
 325     GlyphData *GetTTRawGlyphData(TrueTypeFont *ttf, sal_uInt32 glyphID);
 326
 327 /**
 328  * For a specified glyph adds all component glyphs IDs to the list and
 329  * return their number. If the glyph is a single glyph it has one component
 330  * glyph (which is added to the list) and the function returns 1.
 331  * For a composite glyphs it returns the number of component glyphs
 332  * and adds all of them to the list.
 333  *
 334  * @param ttf         pointer to the TrueTypeFont structure
 335  * @param glyphID     Glyph ID
 336  * @param glyphlist   list of glyphs
 337  *
 338  * @return            number of component glyphs
 339  * @ingroup sft
 340  *
 341  */
 342     int GetTTGlyphComponents(TrueTypeFont *ttf, sal_uInt32 glyphID, std::vector< sal_uInt32 >& glyphlist);
 343
 344 /**
 345  * Extracts all Name Records from the font and stores them in an allocated
 346  * array of NameRecord structs
 347  *
 348  * @param ttf       pointer to the TrueTypeFont struct
 349  * @param nr        pointer to the array of NameRecord structs
 350  *
 351  * @return          number of NameRecord structs
 352  * @ingroup sft
 353  */
 354
 355     int GetTTNameRecords(TrueTypeFont *ttf, NameRecord **nr);
 356
 357 /**
 358  * Deallocates previously allocated array of NameRecords.
 359  *
 360  * @param nr        array of NameRecord structs
 361  * @param n         number of elements in the array
 362  *
 363  * @ingroup sft
 364  */
 365     void DisposeNameRecords(NameRecord* nr, int n);
 366
 367 #ifndef NO_TYPE3
 368 /**
 369  * Generates a new PostScript Type 3 font and dumps it to <b>outf</b> file.
 370  * This functions subsititues glyph 0 for all glyphIDs that are not found in the font.
 371  * @param ttf         pointer to the TrueTypeFont structure
 372  * @param outf        the resulting font is written to this stream
 373  * @param fname       font name for the new font. If it is NULL the PostScript name of the
 374  *                    original font will be used
 375  * @param glyphArray  pointer to an array of glyphs that are to be extracted from ttf
 376  * @param encoding    array of encoding values. encoding[i] specifies the position of the glyph
 377  *                    glyphArray[i] in the encoding vector of the resulting Type3 font
 378  * @param nGlyphs     number of glyph IDs in glyphArray and encoding values in encoding
 379  * @param wmode       writing mode for the output file: 0 - horizontal, 1 - vertical
 380  * @return            return the value of SFErrCodes enum
 381  * @see               SFErrCodes
 382  * @ingroup sft
 383  *
 384  */
 385     int  CreateT3FromTTGlyphs(TrueTypeFont *ttf, FILE *outf, const char *fname, sal_uInt16 *glyphArray, sal_uInt8 *encoding, int nGlyphs, int wmode);
 386 #endif
 387
 388 #ifndef NO_TTCR
 389 /**
 390  * Generates a new TrueType font and dumps it to <b>outf</b> file.
 391  * This functions subsititues glyph 0 for all glyphIDs that are not found in the font.
 392  * @param ttf         pointer to the TrueTypeFont structure
 393  * @param fname       file name for the output TrueType font file
 394  * @param glyphArray  pointer to an array of glyphs that are to be extracted from ttf. The first
 395  *                    element of this array has to be glyph 0 (default glyph)
 396  * @param encoding    array of encoding values. encoding[i] specifies character code for
 397  *                    the glyphID glyphArray[i]. Character code 0 usually points to a default
 398  *                    glyph (glyphID 0)
 399  * @param nGlyphs     number of glyph IDs in glyphArray and encoding values in encoding
 400  * @param nNameRecs   number of NameRecords for the font, if 0 the name table from the
 401  *                    original font will be used
 402  * @param nr          array of NameRecords
 403  * @param flags       or'ed TTCreationFlags
 404  * @return            return the value of SFErrCodes enum
 405  * @see               SFErrCodes
 406  * @ingroup sft
 407  *
 408  */
 409     int  CreateTTFromTTGlyphs(TrueTypeFont  *ttf,
 410                               const char    *fname,
 411                               sal_uInt16        *glyphArray,
 412                               sal_uInt8          *encoding,
 413                               int            nGlyphs,
 414                               int            nNameRecs,
 415                               NameRecord    *nr,
 416                               sal_uInt32        flags);
 417 #endif
 418
 419 #ifndef NO_TYPE42
 420 /**
 421  * Generates a new PostScript Type42 font and dumps it to <b>outf</b> file.
 422  * This functions subsititues glyph 0 for all glyphIDs that are not found in the font.
 423  * @param ttf         pointer to the TrueTypeFont structure
 424  * @param outf        output stream for a resulting font
 425  * @param psname      PostScript name of the resulting font
 426  * @param glyphArray  pointer to an array of glyphs that are to be extracted from ttf. The first
 427  *                    element of this array has to be glyph 0 (default glyph)
 428  * @param encoding    array of encoding values. encoding[i] specifies character code for
 429  *                    the glyphID glyphArray[i]. Character code 0 usually points to a default
 430  *                    glyph (glyphID 0)
 431  * @param nGlyphs     number of glyph IDs in glyphArray and encoding values in encoding
 432  * @return            SF_OK - no errors
 433  *                    SF_GLYPHNUM - too many glyphs (> 255)
 434  *                    SF_TTFORMAT - corrupted TrueType fonts
 435  *
 436  * @see               SFErrCodes
 437  * @ingroup sft
 438  *
 439  */
 440     int  CreateT42FromTTGlyphs(TrueTypeFont  *ttf,
 441                                FILE          *outf,
 442                                const char    *psname,
 443                                sal_uInt16        *glyphArray,
 444                                sal_uInt8          *encoding,
 445                                int            nGlyphs);
 446 #endif
 447
 448 /**
 449  * Queries glyph metrics. Allocates an array of TTSimpleGlyphMetrics structs and returns it.
 450  *
 451  * @param ttf         pointer to the TrueTypeFont structure
 452  * @param glyphArray  pointer to an array of glyphs that are to be extracted from ttf
 453  * @param nGlyphs     number of glyph IDs in glyphArray and encoding values in encoding
 454  * @param vertical    writing mode: false - horizontal, true - vertical
 455  * @ingroup sft
 456  *
 457  */
 458     TTSimpleGlyphMetrics *GetTTSimpleGlyphMetrics(TrueTypeFont *ttf, sal_uInt16 *glyphArray, int nGlyphs, bool vertical);
 459
 460 #ifndef NO_MAPPERS
 461 /**
 462  * Queries glyph metrics. Allocates an array of TTSimpleGlyphMetrics structs and returns it.
 463  * This function behaves just like GetTTSimpleGlyphMetrics() but it takes a range of Unicode
 464  * characters instead of an array of glyphs.
 465  *
 466  * @param ttf         pointer to the TrueTypeFont structure
 467  * @param firstChar   Unicode value of the first character in the range
 468  * @param nChars      number of Unicode characters in the range
 469  * @param vertical    writing mode: false - horizontal, true - vertical
 470  *
 471  * @see GetTTSimpleGlyphMetrics
 472  * @ingroup sft
 473  *
 474  */
 475     TTSimpleGlyphMetrics *GetTTSimpleCharMetrics(TrueTypeFont *ttf, sal_uInt16 firstChar, int nChars, bool vertical);
 476
 477 /**
 478  * Maps a Unicode (UCS-2) string to a glyph array. Returns the number of glyphs in the array,
 479  * which for TrueType fonts is always the same as the number of input characters.
 480  *
 481  * @param ttf         pointer to the TrueTypeFont structure
 482  * @param str         pointer to a UCS-2 string
 483  * @param nchars      number of characters in <b>str</b>
 484  * @param glyphArray  pointer to the glyph array where glyph IDs are to be recorded.
 485  *
 486  * @return MapString() returns -1 if the TrueType font has no usable 'cmap' tables.
 487  *         Otherwise it returns the number of characters processed: <b>nChars</b>
 488  *
 489  * glyphIDs of TrueType fonts are 2 byte positive numbers. glyphID of 0 denotes a missing
 490  * glyph and traditionally defaults to an empty square.
 491  * glyphArray should be at least sizeof(sal_uInt16) * nchars bytes long. If glyphArray is NULL
 492  * MapString() replaces the UCS-2 characters in str with glyphIDs.
 493  * @ingroup sft
 494  */
 495     int VCL_DLLPUBLIC MapString(TrueTypeFont *ttf, sal_uInt16 *str, int nchars, sal_uInt16 *glyphArray, bool bvertical);
 496
 497 /**
 498  * Maps a Unicode (UCS-2) character to a glyph ID and returns it. Missing glyph has
 499  * a glyphID of 0 so this function can be used to test if a character is encoded in the font.
 500  *
 501  * @param ttf         pointer to the TrueTypeFont structure
 502  * @param ch          Unicode (UCS-2) character
 503  * @return glyph ID, if the character is missing in the font, the return value is 0.
 504  * @ingroup sft
 505  */
 506     sal_uInt16 MapChar(TrueTypeFont *ttf, sal_uInt16 ch, bool bvertical);
 507
 508 /**
 509  * Returns 0 when the font does not substitute vertical glyphs
 510  *
 511  * @param ttf         pointer to the TrueTypeFont structure
 512  */
 513     int DoesVerticalSubstitution( TrueTypeFont *ttf, int bvertical);
 514
 515 #endif
 516
 517 /**
 518  * Returns global font information about the TrueType font.
 519  * @see TTGlobalFontInfo
 520  *
 521  * @param ttf         pointer to a TrueTypeFont structure
 522  * @param info        pointer to a TTGlobalFontInfo structure
 523  * @ingroup sft
 524  *
 525  */
 526     void GetTTGlobalFontInfo(TrueTypeFont *ttf, TTGlobalFontInfo *info);
 527
 528 /**
 529  * Returns nonzero if font is a symbol encoded font
 530  */
 531     int CheckSymbolEncoding(TrueTypeFont* ttf);
 532
 533 /**
 534  * returns the number of glyphs in a font
 535  */
 536  int GetTTGlyphCount( TrueTypeFont* ttf );
 537
 538 /**
 539  * provide access to the raw data of a SFNT-container's subtable
 540  */
 541  bool GetSfntTable( TrueTypeFont* ttf, int nSubtableIndex,
 542      const sal_uInt8** ppRawBytes, int* pRawLength );
 543
 544 /*- private definitions */
 545
 546     struct _TrueTypeFont {
 547         sal_uInt32 tag;
 548
 549         char        *fname;
 550         sal_Int32   fsize;
 551         sal_uInt8   *ptr;
 552
 553         char        *psname;
 554         char        *family;
 555         sal_uInt16  *ufamily;
 556         char        *subfamily;
 557         sal_uInt16  *usubfamily;
 558
 559         sal_uInt32  ntables;
 560         sal_uInt32  *goffsets;
 561         sal_uInt32  nglyphs;
 562         sal_uInt32  unitsPerEm;
 563         sal_uInt32  numberOfHMetrics;
 564         sal_uInt32  numOfLongVerMetrics;                   /* if this number is not 0, font has vertical metrics information */
 565         const sal_uInt8* cmap;
 566         int         cmapType;
 567         sal_uInt32 (*mapper)(const sal_uInt8 *, sal_uInt32); /* character to glyphID translation function                          */
 568         const sal_uInt8   **tables;                        /* array of pointers to raw subtables in SFNT file                    */
 569         sal_uInt32  *tlens;                                /* array of table lengths                                             */
 570         int         kerntype;                              /* Defined in the KernType enum                                       */
 571         sal_uInt32  nkern;                                 /* number of kern subtables                                           */
 572         const sal_uInt8** kerntables;                      /* array of pointers to kern subtables                                */
 573         void        *pGSubstitution;                       /* info provided by GSUB for UseGSUB()                                */
 574     };
 575
 576 /* indexes into _TrueTypeFont::tables[] and _TrueTypeFont::tlens[] */
 577 #define O_maxp 0     /* 'maxp' */
 578 #define O_glyf 1     /* 'glyf' */
 579 #define O_head 2     /* 'head' */
 580 #define O_loca 3     /* 'loca' */
 581 #define O_name 4     /* 'name' */
 582 #define O_hhea 5     /* 'hhea' */
 583 #define O_hmtx 6     /* 'hmtx' */
 584 #define O_cmap 7     /* 'cmap' */
 585 #define O_vhea 8     /* 'vhea' */
 586 #define O_vmtx 9     /* 'vmtx' */
 587 #define O_OS2  10    /* 'OS/2' */
 588 #define O_post 11    /* 'post' */
 589 #define O_kern 12    /* 'kern' */
 590 #define O_cvt  13    /* 'cvt_' - only used in TT->TT generation */
 591 #define O_prep 14    /* 'prep' - only used in TT->TT generation */
 592 #define O_fpgm 15    /* 'fpgm' - only used in TT->TT generation */
 593 #define O_gsub 16    /* 'GSUB' */
 594 #define O_CFF  17    /* 'CFF' */
 595 #define NUM_TAGS 18
 596
 597 } // namespace vcl
 598
 599 #endif // INCLUDED_VCL_INC_SFT_HXX
 600
 601 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */