types.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2012 Josh Bialkowski (jbialk@mit.edu)
 *
 *  This file is part of cppfreetype.
 *
 *  cppfreetype is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  cppfreetype is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with cppfreetype.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef CPPFREETYPE_TYPES_H_
#define CPPFREETYPE_TYPES_H_

#include <ft2build.h>
#include FT_FREETYPE_H

#include <cstring>
#include <cstddef>
#include <sigc++/sigc++.h>

namespace freetype
{


extern const unsigned int MAJOR;
extern const unsigned int MINOR;
extern const unsigned int PATCH;

typedef FT_Byte         Byte_t;     
typedef FT_Bytes        Bytes_t;    
typedef FT_Char         Char_t;     
typedef FT_Int          Int_t;      
typedef FT_UInt         UInt_t;     
typedef FT_Int16        Int16_t;    
typedef FT_UInt16       UInt16_t;   
typedef FT_Int32        Int32_t;    
typedef FT_UInt32       UInt32_t;   
typedef FT_Short        Short_t;    
typedef FT_UShort       UShort_t;   
typedef FT_Long         Long_t;     
typedef FT_ULong        ULong_t;    
typedef FT_Bool         Bool_t;     
typedef FT_Offset       Offset_t;   
typedef FT_PtrDist      PtrDist_t;  
typedef FT_String       String_t;   
typedef FT_Tag          Tag_t;      
typedef FT_Error        Error_t;    
typedef FT_Fixed        Fixed_t;    
typedef FT_Pointer      Pointer_t;  
typedef FT_Pos          Pos_t;      
typedef FT_FWord        FWord_t;    
typedef FT_UFWord       UFWord_t;   
typedef FT_F2Dot14      F2Dot14_t;  
typedef FT_F26Dot6      F26Dot6_t;  

typedef FT_Byte         Byte;       
typedef FT_Bytes        Bytes;      
typedef FT_Char         Char;       
typedef FT_Int          Int;        
typedef FT_UInt         UInt;       
typedef FT_Int16        Int16;      
typedef FT_UInt16       UInt16;     
typedef FT_Int32        Int32;      
typedef FT_UInt32       UInt32;     
typedef FT_Short        Short;      
typedef FT_UShort       UShort;     
typedef FT_Long         Long;       
typedef FT_ULong        ULong;      
typedef FT_Bool         Bool;       
typedef FT_Offset       Offset;     
typedef FT_PtrDist      PtrDist;    
typedef FT_String       String;     
typedef FT_Tag          Tag;        
typedef FT_Error        Error;      
typedef FT_Fixed        Fixed;      
typedef FT_Pointer      Pointer;    
typedef FT_Pos          Pos;        
typedef FT_FWord        FWord;      
typedef FT_UFWord       UFWord;     
typedef FT_F2Dot14      F2Dot14;    
typedef FT_F26Dot6      F26Dot6;    



namespace pixelmode
{

    enum PixelMode
    {
        NONE    = 0,    
        MONO,   
        GRAY,   
        GRAY2,  
        GRAY4,  
        LCD,    
        LCD_V,  
        MAX     
    };

}


template < ULong_t x1, ULong_t x2, ULong_t x3, ULong_t x4 >
struct ImageTag
{
    static const ULong_t value =
              ( (ULong_t) x1 << 24 )
            | ( (ULong_t) x2 << 16 )
            | ( (ULong_t) x3 <<  8 )
            | ( (ULong_t) x4 <<  0 );
};


namespace glyphformat
{

    enum GlyphFormat
    {
        NONE        = ImageTag<0,0,0,0>::value,

        COMPOSITE   = ImageTag<'c','o','m','p'>::value,

        BITMAP      = ImageTag<'b','i','t','s'>::value,

        OUTLINE     = ImageTag<'o','u','t','l'>::value,

        PLOTTER     = ImageTag<'p','l','o','t'>::value
    };
}

typedef glyphformat::GlyphFormat GlyphFormat;


typedef sigc::slot<void,void*>  GenericFinalizer_t;



typedef sigc::slot<void*,long>  AllocFunc_t;


typedef sigc::slot<void,void*>  FreeFunc_t;


typedef sigc::slot<void*,long,long,void*>  ReallocFunc_t;



namespace faceflag
{
    const ULong_t   SCALABLE            = ( 1L <<  0 );

    const ULong_t   FIXED_SIZES         = ( 1L <<  1 );

    const ULong_t   FIXED_WIDTH         = ( 1L <<  2 );

    const ULong_t   SFNT                = ( 1L <<  3 );

    const ULong_t   HORIZONTAL          = ( 1L <<  4 );

    const ULong_t   VERTICAL            = ( 1L <<  5 );

    const ULong_t   KERNING             = ( 1L <<  6 );

    const ULong_t   FAST_GLYPHS         = ( 1L <<  7 );

    const ULong_t   MULTIPLE_MASTERS    = ( 1L <<  8 );

    const ULong_t   GLYPH_NAMES         = ( 1L <<  9 );

    const ULong_t   EXTERNAL_STREAM     = ( 1L << 10 );

    const ULong_t   HINTER              = ( 1L << 11 );

    const ULong_t   CID_KEYED           = ( 1L << 12 );

    const ULong_t   TRICKY              = ( 1L << 13 );
}



namespace styleflag
{
    const UInt_t    ITALIC  = ( 1 << 0 );

    const UInt_t    BOLD    = ( 1 << 1 );


}


namespace load
{

    const UInt_t DEFAULT                      = FT_LOAD_DEFAULT;


    const UInt_t NO_SCALE                     = FT_LOAD_NO_SCALE;


    const UInt_t NO_HINTING                   = FT_LOAD_NO_HINTING;

    /*
     *  By default, the glyph is rendered in FT_RENDER_MODE_NORMAL mode. This
     *  can be overridden by FT_LOAD_TARGET_XXX or FT_LOAD_MONOCHROME.
     *
     *  This flag is unset by FT_LOAD_NO_SCALE.
     */
    const UInt_t RENDER                       = FT_LOAD_RENDER;

    /*
     *  FT_LOAD_NO_SCALE always sets this flag.
     */
    const UInt_t NO_BITMAP                    = FT_LOAD_NO_BITMAP;

    /*
     *  Don't use it as it is problematic currently.
     */
    const UInt_t VERTICAL_LAYOUT              = FT_LOAD_VERTICAL_LAYOUT;

    /*
     *  See also the note below.
     */
    const UInt_t FORCE_AUTOHINT               = FT_LOAD_FORCE_AUTOHINT;

    /*
     *  Not all drivers implement this.
     */
    const UInt_t CROP_BITMAP                  = FT_LOAD_CROP_BITMAP;

    /*
     * This is mostly used to detect broken glyphs in fonts. By default,
     * FreeType tries to handle broken fonts also.
     *
     * In particular, errors from the TrueType bytecode engine are not passed
     * to the application if this flag is not set; this might result in
     * partially hinted or distorted glyphs in case a glyph's bytecode is
     * buggy.
     */
    const UInt_t PEDANTIC                     = FT_LOAD_PEDANTIC;

    /*
     *  It merely indicates that the font driver should not load composite
     *  glyphs recursively. Instead, it should set the ‘num_subglyph’ and
     *  ‘subglyphs’ values of the glyph slot accordingly, and set
     *  ‘glyph->format’ to FT_GLYPH_FORMAT_COMPOSITE.
     *
     *  The description of sub-glyphs is not available to client applications
     *  for now.
     *
     *  This flag implies FT_LOAD_NO_SCALE and FT_LOAD_IGNORE_TRANSFORM.
     */
    const UInt_t NO_RECURSE                   = FT_LOAD_NO_RECURSE;

    /*
     *
     */
    const UInt_t IGNORE_TRANSFORM             = FT_LOAD_IGNORE_TRANSFORM;

    /*
     *  Note that this has no effect on the hinting algorithm used. You should
     *  rather use FT_LOAD_TARGET_MONO so that the monochrome-optimized
     *  hinting algorithm is used.
     */
    const UInt_t MONOCHROME                   = FT_LOAD_MONOCHROME;

    /*
     *  See FT_GlyphSlotRec for details.
     */
    const UInt_t LINEAR_DESIGN                = FT_LOAD_LINEAR_DESIGN;

    /*
     *  See also the note below.
     */
    const UInt_t NO_AUTOHINT                  = FT_LOAD_NO_AUTOHINT;
}



namespace render_mode
{

    enum RenderMode
    {
        NORMAL  = 0,

        LIGHT,

        MONO,

        LCD,

        LCD_V,

        MAX
    };
}


namespace load_target
{
    template < Int32_t x >
    struct LoadTarget
    {
        static const Int32_t value = (x & 15) << 16;
    };

    const Int32_t   NORMAL = LoadTarget< render_mode::NORMAL>::value;


    const Int32_t   LIGHT  = LoadTarget< render_mode::LIGHT >::value;

    const Int32_t   MONO   = LoadTarget< render_mode::MONO  >::value;

    const Int32_t   LCD    = LoadTarget< render_mode::LCD   >::value;

    const Int32_t   LCD_V  = LoadTarget< render_mode::LCD_V >::value;
}




namespace kerning_mode
{
    enum KerningMode
    {
        DEFAULT=    0,

        UNFITTED,

        UNSCALED
    };
}



template < ULong_t x1, ULong_t x2, ULong_t x3, ULong_t x4 >
struct EncTag
{
    static const ULong_t value =
              ( (ULong_t) x1 << 24 )
            | ( (ULong_t) x2 << 16 )
            | ( (ULong_t) x3 <<  8 )
            | ( (ULong_t) x4 <<  0 );
};



namespace encoding
{

    enum Encoding
    {
        NONE        = EncTag<0,0,0,0>::value,

        /*
         *  For more information, see ‘http://www.ceviz.net/symbol.htm’.
         */
        MS_SYMBOL   = EncTag<'s','y','m','b'>::value,

        /*
         *  This value covers all versions of the Unicode repertoire,
         *  including ASCII and Latin-1. Most fonts include a Unicode charmap,
         *  but not all of them.
         *
         *  For example, if you want to access Unicode value U+1F028 (and the
         *  font contains it), use value 0x1F028 as the input value for
         *  FT_Get_Char_Index.
         */
        UNICODE     = EncTag<'u','n','i','c'>::value,

        /*
         *  More info at at
         *  ‘http://langsupport.japanreference.com/encoding.shtml’.
         *  See note on multi-byte encodings below.
         */
        SJIS        = EncTag<'s','j','i','s'>::value,

        /*
         *
         */
        GB2312      = EncTag<'g','b',' ',' '>::value,

        /*
         *
         */
        BIG5        = EncTag<'b','i','g','5'>::value,

        /*
         *  For more information see
         *  ‘http://www.microsoft.com/typography/unicode/949.txt’.
         */
        WANSUNG     = EncTag<'w','a','n','s'>::value,

        /*
         *  This character set includes all possible Hangeul character
         *  combinations.
         */
        JOHAB       = EncTag<'j','o','h','a'>::value,


        ADOBE_STANDARD  = EncTag<'A','D','O','B'>::value,

        /*
         *  It is limited to 256 character codes.
         */
        ADOBE_EXPERT    = EncTag<'A','D','B','E'>::value,

        /*
         *  It is limited to 256 character codes.
         */
        ADOBE_CUSTOM    = EncTag<'A','D','B','C'>::value,

        /*
         *  It is limited to 256 character codes.
         */
        ADOBE_LATIN_1   = EncTag<'l','a','t','1'>::value,

        OLD_LATIN_2     = EncTag<'l','a','t','2'>::value,

        /*
         *  Many TrueType and OpenType fonts contain a charmap for this
         *  encoding, since older versions of Mac OS are able to use it
         */
        APPLE_ROMAN     = EncTag<'a', 'r', 'm', 'n'>::value
    };
}

typedef encoding::Encoding Encoding;


namespace subglyph_flag
{
    const UInt32_t ARGS_ARE_WORDS           = 1;
    const UInt32_t ARGS_ARE_XY_VALUES       = 2;
    const UInt32_t ROUND_XY_TO_GRID         = 4;
    const UInt32_t SCALE                    = 8;
    const UInt32_t XY_SCALE              = 0x40;
    const UInt32_t _2X2                  = 0x80;
    const UInt32_t USE_MY_METRICS       = 0x200;
}


namespace curve_tag
{
    const UInt  ON    = FT_CURVE_TAG_ON;
    const UInt  CONIC = FT_CURVE_TAG_CONIC;
    const UInt  CUBIC = FT_CURVE_TAG_CUBIC;

    const UInt  DROPOUT_MASK    = 0xE0;
    const UInt  DROPOUT_SHIFT   = 5;
}



namespace fstype
{
    const UShort_t INSTALLABLE_EMBEDDING          = 0x0000;

    const UShort_t RESTRICTED_LICENSE_EMBEDDING   = 0x0002;

    const UShort_t PREVIEW_AND_PRINT_EMBEDDING    = 0x0004;

    const UShort_t EDITABLE_EMBEDDING             = 0x0008;

    const UShort_t NO_SUBSETTING                  = 0x0100;

    const UShort_t BITMAP_EMBEDDING_ONLY          = 0x0200;
}


namespace size_request_type
{

    enum SizeRequestType
    {
        NOMINAL,    
        REAL_DIM,   
        BBOX,       
        CELL,       
        SCALES,     
        MAX         
    };
}

typedef size_request_type::SizeRequestType SizeRequestType;



}














#endif // CPPFREETYPE_H_