From abafe5c1841aa76b8eba5567cd48a66bce85c24b Mon Sep 17 00:00:00 2001 From: Kovid Goyal Date: Tue, 25 Dec 2012 15:47:08 +0530 Subject: [PATCH] Harfbuzz headers for compilation of qt_hack --- src/qt-harfbuzz/AUTHORS | 6 + src/qt-harfbuzz/COPYING | 24 + src/qt-harfbuzz/src/Makefile.am | 69 ++ src/qt-harfbuzz/src/harfbuzz-buffer-private.h | 107 +++ src/qt-harfbuzz/src/harfbuzz-buffer.h | 94 +++ src/qt-harfbuzz/src/harfbuzz-dump.h | 41 + src/qt-harfbuzz/src/harfbuzz-external.h | 153 ++++ src/qt-harfbuzz/src/harfbuzz-gdef-private.h | 126 +++ src/qt-harfbuzz/src/harfbuzz-gdef.h | 132 ++++ src/qt-harfbuzz/src/harfbuzz-global.h | 118 +++ src/qt-harfbuzz/src/harfbuzz-gpos-private.h | 721 ++++++++++++++++++ src/qt-harfbuzz/src/harfbuzz-gpos.h | 155 ++++ src/qt-harfbuzz/src/harfbuzz-gsub-private.h | 475 ++++++++++++ src/qt-harfbuzz/src/harfbuzz-gsub.h | 139 ++++ src/qt-harfbuzz/src/harfbuzz-impl.h | 131 ++++ src/qt-harfbuzz/src/harfbuzz-open-private.h | 102 +++ src/qt-harfbuzz/src/harfbuzz-open.h | 280 +++++++ src/qt-harfbuzz/src/harfbuzz-shape.h | 199 +++++ src/qt-harfbuzz/src/harfbuzz-shaper-private.h | 172 +++++ src/qt-harfbuzz/src/harfbuzz-shaper.h | 287 +++++++ src/qt-harfbuzz/src/harfbuzz-stream-private.h | 81 ++ src/qt-harfbuzz/src/harfbuzz-stream.h | 43 ++ src/qt-harfbuzz/src/harfbuzz.h | 38 + 23 files changed, 3693 insertions(+) create mode 100644 src/qt-harfbuzz/AUTHORS create mode 100644 src/qt-harfbuzz/COPYING create mode 100644 src/qt-harfbuzz/src/Makefile.am create mode 100644 src/qt-harfbuzz/src/harfbuzz-buffer-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-buffer.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-dump.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-external.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-gdef-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-gdef.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-global.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-gpos-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-gpos.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-gsub-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-gsub.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-impl.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-open-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-open.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-shape.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-shaper-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-shaper.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-stream-private.h create mode 100644 src/qt-harfbuzz/src/harfbuzz-stream.h create mode 100644 src/qt-harfbuzz/src/harfbuzz.h diff --git a/src/qt-harfbuzz/AUTHORS b/src/qt-harfbuzz/AUTHORS new file mode 100644 index 0000000000..023488a5b9 --- /dev/null +++ b/src/qt-harfbuzz/AUTHORS @@ -0,0 +1,6 @@ +David Turner +Werner Lemberg +Owen Taylor +Behdad Esfahbod +Lars Knoll +Simon Hausmann diff --git a/src/qt-harfbuzz/COPYING b/src/qt-harfbuzz/COPYING new file mode 100644 index 0000000000..820a9e6808 --- /dev/null +++ b/src/qt-harfbuzz/COPYING @@ -0,0 +1,24 @@ +HarfBuzz was previously licensed under different licenses. This was +changed in January 2008. If you need to relicense your old copies, +consult the announcement of the license change on the internet. +Other than that, each copy of HarfBuzz is licensed under the COPYING +file included with it. The actual license follows: + + +Permission is hereby granted, without written agreement and without +license or royalty fees, to use, copy, modify, and distribute this +software and its documentation for any purpose, provided that the +above copyright notice and the following two paragraphs appear in +all copies of this software. + +IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR +DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES +ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN +IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, +BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS +ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO +PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. diff --git a/src/qt-harfbuzz/src/Makefile.am b/src/qt-harfbuzz/src/Makefile.am new file mode 100644 index 0000000000..51d06525da --- /dev/null +++ b/src/qt-harfbuzz/src/Makefile.am @@ -0,0 +1,69 @@ +## Process this file with automake to produce Makefile.in + +noinst_LTLIBRARIES = libharfbuzz-1.la + +MAINSOURCES = \ + harfbuzz-buffer.c \ + harfbuzz-stream.c \ + harfbuzz-dump.c \ + harfbuzz-gdef.c \ + harfbuzz-gpos.c \ + harfbuzz-gsub.c \ + harfbuzz-impl.c \ + harfbuzz-open.c \ + harfbuzz-shaper.cpp \ + harfbuzz-greek.c \ + harfbuzz-tibetan.c \ + harfbuzz-khmer.c \ + harfbuzz-indic.cpp \ + harfbuzz-hebrew.c \ + harfbuzz-arabic.c \ + harfbuzz-hangul.c \ + harfbuzz-myanmar.c \ + harfbuzz-thai.c + +EXTRA_SOURCES = harfbuzz.c + +PUBLICHEADERS = \ + harfbuzz.h \ + harfbuzz-buffer.h \ + harfbuzz-dump.h \ + harfbuzz-gdef.h \ + harfbuzz-gpos.h \ + harfbuzz-gsub.h \ + harfbuzz-open.h \ + harfbuzz-global.h \ + harfbuzz-external.h \ + harfbuzz-shaper.h \ + harfbuzz-stream.h + +PRIVATEHEADERS = \ + harfbuzz-impl.h \ + harfbuzz-buffer-private.h \ + harfbuzz-stream-private.h \ + harfbuzz-gdef-private.h \ + harfbuzz-gpos-private.h \ + harfbuzz-gsub-private.h \ + harfbuzz-open-private.h \ + harfbuzz-shaper-private.h + +libharfbuzz_1_la_SOURCES = \ + $(MAINSOURCES) \ + $(PUBLICHEADERS) \ + $(PRIVATEHEADERS) + +#noinst_PROGRAMS = harfbuzz-dump +# +#harfbuzz_dump_SOURCES = \ +# harfbuzz-dump-main.c +# +#harfbuzz_dump_LDADD = \ +# libharfbuzz-1.la + +EXTRA_DIST = \ + README \ + COPYING.FTL \ + COPYING.GPL \ + COPYING \ + $(EXTRA_SOURCES) + diff --git a/src/qt-harfbuzz/src/harfbuzz-buffer-private.h b/src/qt-harfbuzz/src/harfbuzz-buffer-private.h new file mode 100644 index 0000000000..5065f2e031 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-buffer-private.h @@ -0,0 +1,107 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2004,2007 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Owen Taylor, Behdad Esfahbod + */ + +#ifndef HARFBUZZ_BUFFER_PRIVATE_H +#define HARFBUZZ_BUFFER_PRIVATE_H + +#include "harfbuzz-impl.h" +#include "harfbuzz-buffer.h" + +HB_BEGIN_HEADER + +#define HB_GLYPH_PROPERTIES_UNKNOWN 0xFFFF + +HB_INTERNAL void +_hb_buffer_swap( HB_Buffer buffer ); + +HB_INTERNAL void +_hb_buffer_clear_output( HB_Buffer buffer ); + +HB_INTERNAL HB_Error +_hb_buffer_clear_positions( HB_Buffer buffer ); + +HB_INTERNAL HB_Error +_hb_buffer_add_output_glyphs( HB_Buffer buffer, + HB_UShort num_in, + HB_UShort num_out, + HB_UShort *glyph_data, + HB_UShort component, + HB_UShort ligID ); + +HB_INTERNAL HB_Error +_hb_buffer_add_output_glyph ( HB_Buffer buffer, + HB_UInt glyph_index, + HB_UShort component, + HB_UShort ligID ); + +HB_INTERNAL HB_Error +_hb_buffer_copy_output_glyph ( HB_Buffer buffer ); + +HB_INTERNAL HB_Error +_hb_buffer_replace_output_glyph ( HB_Buffer buffer, + HB_UInt glyph_index, + HB_Bool inplace ); + +HB_INTERNAL HB_UShort +_hb_buffer_allocate_ligid( HB_Buffer buffer ); + + +/* convenience macros */ + +#define IN_GLYPH( pos ) (buffer->in_string[(pos)].gindex) +#define IN_ITEM( pos ) (&buffer->in_string[(pos)]) +#define IN_CURGLYPH() (buffer->in_string[buffer->in_pos].gindex) +#define IN_CURITEM() (&buffer->in_string[buffer->in_pos]) +#define IN_PROPERTIES( pos ) (buffer->in_string[(pos)].properties) +#define IN_LIGID( pos ) (buffer->in_string[(pos)].ligID) +#define IN_COMPONENT( pos ) (buffer->in_string[(pos)].component) +#define POSITION( pos ) (&buffer->positions[(pos)]) +#define OUT_GLYPH( pos ) (buffer->out_string[(pos)].gindex) +#define OUT_ITEM( pos ) (&buffer->out_string[(pos)]) + +#define CHECK_Property( gdef, index, flags, property ) \ + ( ( error = _HB_GDEF_Check_Property( (gdef), (index), (flags), \ + (property) ) ) != HB_Err_Ok ) + +#define ADD_String( buffer, num_in, num_out, glyph_data, component, ligID ) \ + ( ( error = _hb_buffer_add_output_glyphs( (buffer), \ + (num_in), (num_out), \ + (glyph_data), (component), (ligID) \ + ) ) != HB_Err_Ok ) +#define ADD_Glyph( buffer, glyph_index, component, ligID ) \ + ( ( error = _hb_buffer_add_output_glyph( (buffer), \ + (glyph_index), (component), (ligID) \ + ) ) != HB_Err_Ok ) +#define REPLACE_Glyph( buffer, glyph_index, nesting_level ) \ + ( ( error = _hb_buffer_replace_output_glyph( (buffer), (glyph_index), \ + (nesting_level) == 1 ) ) != HB_Err_Ok ) +#define COPY_Glyph( buffer ) \ + ( (error = _hb_buffer_copy_output_glyph ( buffer ) ) != HB_Err_Ok ) + +HB_END_HEADER + +#endif /* HARFBUZZ_BUFFER_PRIVATE_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-buffer.h b/src/qt-harfbuzz/src/harfbuzz-buffer.h new file mode 100644 index 0000000000..0d631b20a6 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-buffer.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2004,2007 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Owen Taylor, Behdad Esfahbod + */ + +#ifndef HARFBUZZ_BUFFER_H +#define HARFBUZZ_BUFFER_H + +#include "harfbuzz-global.h" + +HB_BEGIN_HEADER + +typedef struct HB_GlyphItemRec_ { + HB_UInt gindex; + HB_UInt properties; + HB_UInt cluster; + HB_UShort component; + HB_UShort ligID; + HB_UShort gproperties; +} HB_GlyphItemRec, *HB_GlyphItem; + +typedef struct HB_PositionRec_ { + HB_Fixed x_pos; + HB_Fixed y_pos; + HB_Fixed x_advance; + HB_Fixed y_advance; + HB_UShort back; /* number of glyphs to go back + for drawing current glyph */ + HB_Short cursive_chain; /* character to which this connects, + may be positive or negative; used + only internally */ + HB_Bool new_advance; /* if set, the advance width values are + absolute, i.e., they won't be + added to the original glyph's value + but rather replace them. */ +} HB_PositionRec, *HB_Position; + + +typedef struct HB_BufferRec_{ + HB_UInt allocated; + + HB_UInt in_length; + HB_UInt out_length; + HB_UInt in_pos; + HB_UInt out_pos; + + HB_GlyphItem in_string; + HB_GlyphItem out_string; + HB_GlyphItem alt_string; + HB_Position positions; + HB_UShort max_ligID; + HB_Bool separate_out; +} HB_BufferRec, *HB_Buffer; + +HB_Error +hb_buffer_new( HB_Buffer *buffer ); + +void +hb_buffer_free( HB_Buffer buffer ); + +void +hb_buffer_clear( HB_Buffer buffer ); + +HB_Error +hb_buffer_add_glyph( HB_Buffer buffer, + HB_UInt glyph_index, + HB_UInt properties, + HB_UInt cluster ); + +HB_END_HEADER + +#endif /* HARFBUZZ_BUFFER_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-dump.h b/src/qt-harfbuzz/src/harfbuzz-dump.h new file mode 100644 index 0000000000..ea4a62b2e1 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-dump.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2000, 2007 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Owen Taylor, Behdad Esfahbod + */ + +#ifndef HARFBUZZ_DUMP_H +#define HARFBUZZ_DUMP_H + +#include +#include "harfbuzz-gsub.h" +#include "harfbuzz-gpos.h" + +HB_BEGIN_HEADER + +void HB_Dump_GSUB_Table (HB_GSUB gsub, FILE *stream); +void HB_Dump_GPOS_Table (HB_GPOS gpos, FILE *stream); + +HB_END_HEADER + +#endif /* HARFBUZZ_DUMP_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-external.h b/src/qt-harfbuzz/src/harfbuzz-external.h new file mode 100644 index 0000000000..7644f0dd43 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-external.h @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_EXTERNAL_H +#define HARFBUZZ_EXTERNAL_H + +#include "harfbuzz-global.h" + +HB_BEGIN_HEADER + +/* This header contains some methods that are not part of + Harfbuzz itself, but referenced by it. + They need to be provided by the application/library +*/ + + +/* + see http://www.unicode.org/reports/tr14/tr14-19.html + we don't use the XX, AI and CB properties and map them to AL instead. + as we don't support any EBDIC based OS'es, NL is ignored and mapped to AL as well. +*/ +typedef enum { + HB_LineBreak_OP, HB_LineBreak_CL, HB_LineBreak_QU, HB_LineBreak_GL, HB_LineBreak_NS, + HB_LineBreak_EX, HB_LineBreak_SY, HB_LineBreak_IS, HB_LineBreak_PR, HB_LineBreak_PO, + HB_LineBreak_NU, HB_LineBreak_AL, HB_LineBreak_ID, HB_LineBreak_IN, HB_LineBreak_HY, + HB_LineBreak_BA, HB_LineBreak_BB, HB_LineBreak_B2, HB_LineBreak_ZW, HB_LineBreak_CM, + HB_LineBreak_WJ, HB_LineBreak_H2, HB_LineBreak_H3, HB_LineBreak_JL, HB_LineBreak_JV, + HB_LineBreak_JT, HB_LineBreak_SA, HB_LineBreak_SG, + HB_LineBreak_SP, HB_LineBreak_CR, HB_LineBreak_LF, HB_LineBreak_BK +} HB_LineBreakClass; + +typedef enum +{ + HB_NoCategory, + + HB_Mark_NonSpacing, /* Mn */ + HB_Mark_SpacingCombining, /* Mc */ + HB_Mark_Enclosing, /* Me */ + + HB_Number_DecimalDigit, /* Nd */ + HB_Number_Letter, /* Nl */ + HB_Number_Other, /* No */ + + HB_Separator_Space, /* Zs */ + HB_Separator_Line, /* Zl */ + HB_Separator_Paragraph, /* Zp */ + + HB_Other_Control, /* Cc */ + HB_Other_Format, /* Cf */ + HB_Other_Surrogate, /* Cs */ + HB_Other_PrivateUse, /* Co */ + HB_Other_NotAssigned, /* Cn */ + + HB_Letter_Uppercase, /* Lu */ + HB_Letter_Lowercase, /* Ll */ + HB_Letter_Titlecase, /* Lt */ + HB_Letter_Modifier, /* Lm */ + HB_Letter_Other, /* Lo */ + + HB_Punctuation_Connector, /* Pc */ + HB_Punctuation_Dash, /* Pd */ + HB_Punctuation_Open, /* Ps */ + HB_Punctuation_Close, /* Pe */ + HB_Punctuation_InitialQuote, /* Pi */ + HB_Punctuation_FinalQuote, /* Pf */ + HB_Punctuation_Other, /* Po */ + + HB_Symbol_Math, /* Sm */ + HB_Symbol_Currency, /* Sc */ + HB_Symbol_Modifier, /* Sk */ + HB_Symbol_Other /* So */ +} HB_CharCategory; + +typedef enum +{ + HB_Grapheme_Other, + HB_Grapheme_CR, + HB_Grapheme_LF, + HB_Grapheme_Control, + HB_Grapheme_Extend, + HB_Grapheme_L, + HB_Grapheme_V, + HB_Grapheme_T, + HB_Grapheme_LV, + HB_Grapheme_LVT +} HB_GraphemeClass; + + +typedef enum +{ + HB_Word_Other, + HB_Word_Format, + HB_Word_Katakana, + HB_Word_ALetter, + HB_Word_MidLetter, + HB_Word_MidNum, + HB_Word_Numeric, + HB_Word_ExtendNumLet +} HB_WordClass; + + +typedef enum +{ + HB_Sentence_Other, + HB_Sentence_Sep, + HB_Sentence_Format, + HB_Sentence_Sp, + HB_Sentence_Lower, + HB_Sentence_Upper, + HB_Sentence_OLetter, + HB_Sentence_Numeric, + HB_Sentence_ATerm, + HB_Sentence_STerm, + HB_Sentence_Close +} HB_SentenceClass; + +HB_GraphemeClass HB_GetGraphemeClass(HB_UChar32 ch); +HB_WordClass HB_GetWordClass(HB_UChar32 ch); +HB_SentenceClass HB_GetSentenceClass(HB_UChar32 ch); +HB_LineBreakClass HB_GetLineBreakClass(HB_UChar32 ch); + +void HB_GetGraphemeAndLineBreakClass(HB_UChar32 ch, HB_GraphemeClass *grapheme, HB_LineBreakClass *lineBreak); +void HB_GetUnicodeCharProperties(HB_UChar32 ch, HB_CharCategory *category, int *combiningClass); +HB_CharCategory HB_GetUnicodeCharCategory(HB_UChar32 ch); +int HB_GetUnicodeCharCombiningClass(HB_UChar32 ch); +HB_UChar16 HB_GetMirroredChar(HB_UChar16 ch); + +void *HB_Library_Resolve(const char *library, int version, const char *symbol); + +HB_END_HEADER + +#endif diff --git a/src/qt-harfbuzz/src/harfbuzz-gdef-private.h b/src/qt-harfbuzz/src/harfbuzz-gdef-private.h new file mode 100644 index 0000000000..94e9b43e61 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-gdef-private.h @@ -0,0 +1,126 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_GDEF_PRIVATE_H +#define HARFBUZZ_GDEF_PRIVATE_H + +#include "harfbuzz-impl.h" +#include "harfbuzz-stream-private.h" +#include "harfbuzz-buffer-private.h" +#include "harfbuzz-gdef.h" + +HB_BEGIN_HEADER + +/* Attachment related structures */ + +struct HB_AttachPoint_ +{ + HB_UShort* PointIndex; /* array of contour points */ + HB_UShort PointCount; /* size of the PointIndex array */ +}; + +/* Ligature Caret related structures */ + +struct HB_CaretValueFormat1_ +{ + HB_Short Coordinate; /* x or y value (in design units) */ +}; + +typedef struct HB_CaretValueFormat1_ HB_CaretValueFormat1; + + +struct HB_CaretValueFormat2_ +{ + HB_UShort CaretValuePoint; /* contour point index on glyph */ +}; + +typedef struct HB_CaretValueFormat2_ HB_CaretValueFormat2; + + +struct HB_CaretValueFormat3_ +{ + HB_Device* Device; /* Device table for x or y value */ + HB_Short Coordinate; /* x or y value (in design units) */ +}; + +typedef struct HB_CaretValueFormat3_ HB_CaretValueFormat3; + + +#ifdef HB_SUPPORT_MULTIPLE_MASTER +struct HB_CaretValueFormat4_ +{ + HB_UShort IdCaretValue; /* metric ID */ +}; + +typedef struct HB_CaretValueFormat4_ HB_CaretValueFormat4; +#endif + + +struct HB_CaretValue_ +{ + union + { + HB_CaretValueFormat1 cvf1; + HB_CaretValueFormat2 cvf2; + HB_CaretValueFormat3 cvf3; +#ifdef HB_SUPPORT_MULTIPLE_MASTER + HB_CaretValueFormat4 cvf4; +#endif + } cvf; + + HB_Byte CaretValueFormat; /* 1, 2, 3, or 4 */ +}; + +typedef struct HB_CaretValue_ HB_CaretValue; + + +struct HB_LigGlyph_ +{ + HB_CaretValue* CaretValue; /* array of caret values */ + HB_UShort CaretCount; /* number of caret values */ + HB_Bool loaded; +}; + + +HB_INTERNAL HB_Error +_HB_GDEF_Add_Glyph_Property( HB_GDEFHeader* gdef, + HB_UShort glyphID, + HB_UShort property ); + +HB_INTERNAL HB_Error +_HB_GDEF_Check_Property( HB_GDEFHeader* gdef, + HB_GlyphItem item, + HB_UShort flags, + HB_UShort* property ); + +HB_INTERNAL HB_Error +_HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( HB_GDEFHeader* gdef, + HB_Stream input, + HB_Lookup* lo, + HB_UShort num_lookups ); + +HB_END_HEADER + +#endif /* HARFBUZZ_GDEF_PRIVATE_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-gdef.h b/src/qt-harfbuzz/src/harfbuzz-gdef.h new file mode 100644 index 0000000000..ccb6bf9734 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-gdef.h @@ -0,0 +1,132 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_GDEF_H +#define HARFBUZZ_GDEF_H + +#include "harfbuzz-open.h" +#include "harfbuzz-stream.h" + +HB_BEGIN_HEADER + +/* GDEF glyph properties. Note that HB_GDEF_COMPONENT has no corresponding + * flag in the LookupFlag field. */ +#define HB_GDEF_BASE_GLYPH 0x0002 +#define HB_GDEF_LIGATURE 0x0004 +#define HB_GDEF_MARK 0x0008 +#define HB_GDEF_COMPONENT 0x0010 + + +typedef struct HB_AttachPoint_ HB_AttachPoint; + + +struct HB_AttachList_ +{ + HB_AttachPoint* AttachPoint; /* array of AttachPoint tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort GlyphCount; /* number of glyphs with + attachments */ + HB_Bool loaded; +}; + +typedef struct HB_AttachList_ HB_AttachList; + +typedef struct HB_LigGlyph_ HB_LigGlyph; + +struct HB_LigCaretList_ +{ + HB_LigGlyph* LigGlyph; /* array of LigGlyph tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort LigGlyphCount; /* number of ligature glyphs */ + HB_Bool loaded; +}; + +typedef struct HB_LigCaretList_ HB_LigCaretList; + + + +/* The `NewGlyphClasses' field is not defined in the TTO specification. + We use it for fonts with a constructed `GlyphClassDef' structure + (i.e., which don't have a GDEF table) to collect glyph classes + assigned during the lookup process. The number of arrays in this + pointer array is GlyphClassDef->cd.cd2.ClassRangeCount+1; the nth + array then contains the glyph class values of the glyphs not covered + by the ClassRangeRecords structures with index n-1 and n. We store + glyph class values for four glyphs in a single array element. + + `LastGlyph' is identical to the number of glyphs minus one in the + font; we need it only if `NewGlyphClasses' is not NULL (to have an + upper bound for the last array). + + Note that we first store the file offset to the `MarkAttachClassDef' + field (which has been introduced in OpenType 1.2) -- since the + `Version' field value hasn't been increased to indicate that we have + one more field for some obscure reason, we must parse the GSUB table + to find out whether class values refer to this table. Only then we + can finally load the MarkAttachClassDef structure if necessary. */ + +struct HB_GDEFHeader_ +{ + HB_UShort** NewGlyphClasses; + HB_UInt offset; + HB_UInt MarkAttachClassDef_offset; + + HB_16Dot16 Version; + + HB_ClassDefinition GlyphClassDef; + HB_AttachList AttachList; + HB_LigCaretList LigCaretList; + HB_ClassDefinition MarkAttachClassDef; /* new in OT 1.2 */ + + HB_UShort LastGlyph; +}; + +typedef struct HB_GDEFHeader_ HB_GDEFHeader; +typedef struct HB_GDEFHeader_* HB_GDEF; + + +HB_Error HB_New_GDEF_Table( HB_GDEFHeader** retptr ); + + +HB_Error HB_Load_GDEF_Table( HB_Stream stream, + HB_GDEFHeader** gdef ); + + +HB_Error HB_Done_GDEF_Table ( HB_GDEFHeader* gdef ); + + +HB_Error HB_GDEF_Get_Glyph_Property( HB_GDEFHeader* gdef, + HB_UShort glyphID, + HB_UShort* property ); + +HB_Error HB_GDEF_Build_ClassDefinition( HB_GDEFHeader* gdef, + HB_UShort num_glyphs, + HB_UShort glyph_count, + HB_UShort* glyph_array, + HB_UShort* class_array ); + +HB_END_HEADER + +#endif /* HARFBUZZ_GDEF_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-global.h b/src/qt-harfbuzz/src/harfbuzz-global.h new file mode 100644 index 0000000000..d4e6b466b6 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-global.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + * Copyright (C) 2007 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Behdad Esfahbod + */ + +#ifndef HARFBUZZ_GLOBAL_H +#define HARFBUZZ_GLOBAL_H + +#include +#include + +#ifdef __cplusplus +#define HB_BEGIN_HEADER extern "C" { +#define HB_END_HEADER } +#else +#define HB_BEGIN_HEADER /* nothing */ +#define HB_END_HEADER /* nothing */ +#endif + +HB_BEGIN_HEADER + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef TRUE +#define TRUE (!FALSE) +#endif + +#define HB_MAKE_TAG( _x1, _x2, _x3, _x4 ) \ + ( ( (HB_UInt)_x1 << 24 ) | \ + ( (HB_UInt)_x2 << 16 ) | \ + ( (HB_UInt)_x3 << 8 ) | \ + (HB_UInt)_x4 ) + +typedef char hb_int8; +typedef unsigned char hb_uint8; +typedef short hb_int16; +typedef unsigned short hb_uint16; +typedef int hb_int32; +typedef unsigned int hb_uint32; + +typedef hb_uint8 HB_Bool; + +typedef hb_uint8 HB_Byte; +typedef hb_uint16 HB_UShort; +typedef hb_uint32 HB_UInt; +typedef hb_int8 HB_Char; +typedef hb_int16 HB_Short; +typedef hb_int32 HB_Int; + +typedef hb_uint16 HB_UChar16; +typedef hb_uint32 HB_UChar32; +typedef hb_uint32 HB_Glyph; +typedef hb_int32 HB_Fixed; /* 26.6 */ + +#define HB_FIXED_CONSTANT(v) ((v) * 64) +#define HB_FIXED_ROUND(v) (((v)+32) & -64) + +typedef hb_int32 HB_16Dot16; /* 16.16 */ + +typedef void * HB_Pointer; +typedef hb_uint32 HB_Tag; + +typedef enum { + /* no error */ + HB_Err_Ok = 0x0000, + HB_Err_Not_Covered = 0xFFFF, + + /* _hb_err() is called whenever returning the following errors, + * and in a couple places for HB_Err_Not_Covered too. */ + + /* programmer error */ + HB_Err_Invalid_Argument = 0x1A66, + + /* font error */ + HB_Err_Invalid_SubTable_Format = 0x157F, + HB_Err_Invalid_SubTable = 0x1570, + HB_Err_Read_Error = 0x6EAD, + + /* system error */ + HB_Err_Out_Of_Memory = 0xDEAD +} HB_Error; + +typedef struct { + HB_Fixed x; + HB_Fixed y; +} HB_FixedPoint; + +typedef struct HB_Font_ *HB_Font; +typedef struct HB_StreamRec_ *HB_Stream; +typedef struct HB_FaceRec_ *HB_Face; + +HB_END_HEADER + +#endif diff --git a/src/qt-harfbuzz/src/harfbuzz-gpos-private.h b/src/qt-harfbuzz/src/harfbuzz-gpos-private.h new file mode 100644 index 0000000000..63ba90797d --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-gpos-private.h @@ -0,0 +1,721 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_GPOS_PRIVATE_H +#define HARFBUZZ_GPOS_PRIVATE_H + +#include "harfbuzz-impl.h" +#include "harfbuzz-stream-private.h" +#include "harfbuzz-gpos.h" + +HB_BEGIN_HEADER + +/* shared tables */ + +#define VR_X_PLACEMENT_DEVICE 0 +#define VR_Y_PLACEMENT_DEVICE 1 +#define VR_X_ADVANCE_DEVICE 2 +#define VR_Y_ADVANCE_DEVICE 3 + +struct HB_ValueRecord_ +{ + HB_Short XPlacement; /* horizontal adjustment for + placement */ + HB_Short YPlacement; /* vertical adjustment for + placement */ + HB_Short XAdvance; /* horizontal adjustment for + advance */ + HB_Short YAdvance; /* vertical adjustment for + advance */ + + HB_Device** DeviceTables; /* device tables for placement + and advance */ + +#ifdef HB_SUPPORT_MULTIPLE_MASTER + HB_UShort XIdPlacement; /* horizontal placement metric ID */ + HB_UShort YIdPlacement; /* vertical placement metric ID */ + HB_UShort XIdAdvance; /* horizontal advance metric ID */ + HB_UShort YIdAdvance; /* vertical advance metric ID */ +#endif +}; + +typedef struct HB_ValueRecord_ HB_ValueRecord; + + +/* Mask values to scan the value format of the ValueRecord structure. + We always expand compressed ValueRecords of the font. */ + +#define HB_GPOS_FORMAT_HAVE_DEVICE_TABLES 0x00F0 + +#define HB_GPOS_FORMAT_HAVE_X_PLACEMENT 0x0001 +#define HB_GPOS_FORMAT_HAVE_Y_PLACEMENT 0x0002 +#define HB_GPOS_FORMAT_HAVE_X_ADVANCE 0x0004 +#define HB_GPOS_FORMAT_HAVE_Y_ADVANCE 0x0008 +#define HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE 0x0010 +#define HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE 0x0020 +#define HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE 0x0040 +#define HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE 0x0080 +#define HB_GPOS_FORMAT_HAVE_X_ID_PLACEMENT 0x0100 +#define HB_GPOS_FORMAT_HAVE_Y_ID_PLACEMENT 0x0200 +#define HB_GPOS_FORMAT_HAVE_X_ID_ADVANCE 0x0400 +#define HB_GPOS_FORMAT_HAVE_Y_ID_ADVANCE 0x0800 + + +struct HB_AnchorFormat1_ +{ + HB_Short XCoordinate; /* horizontal value */ + HB_Short YCoordinate; /* vertical value */ +}; + +typedef struct HB_AnchorFormat1_ HB_AnchorFormat1; + + +struct HB_AnchorFormat2_ +{ + HB_Short XCoordinate; /* horizontal value */ + HB_Short YCoordinate; /* vertical value */ + HB_UShort AnchorPoint; /* index to glyph contour point */ +}; + +typedef struct HB_AnchorFormat2_ HB_AnchorFormat2; + +#define AF3_X_DEVICE_TABLE 0 +#define AF3_Y_DEVICE_TABLE 1 + +struct HB_AnchorFormat3_ +{ + HB_Short XCoordinate; /* horizontal value */ + HB_Short YCoordinate; /* vertical value */ + HB_Device** DeviceTables; /* device tables for coordinates */ +}; + +typedef struct HB_AnchorFormat3_ HB_AnchorFormat3; + + +#ifdef HB_SUPPORT_MULTIPLE_MASTER +struct HB_AnchorFormat4_ +{ + HB_UShort XIdAnchor; /* horizontal metric ID */ + HB_UShort YIdAnchor; /* vertical metric ID */ +}; + +typedef struct HB_AnchorFormat4_ HB_AnchorFormat4; +#endif + + +struct HB_Anchor_ +{ + HB_Byte PosFormat; /* 1, 2, 3, or 4 -- 0 indicates + that there is no Anchor table */ + + union + { + HB_AnchorFormat1 af1; + HB_AnchorFormat2 af2; + HB_AnchorFormat3 af3; +#ifdef HB_SUPPORT_MULTIPLE_MASTER + HB_AnchorFormat4 af4; +#endif + } af; +}; + +typedef struct HB_Anchor_ HB_Anchor; + + +struct HB_MarkRecord_ +{ + HB_UShort Class; /* mark class */ + HB_Anchor MarkAnchor; /* anchor table */ +}; + +typedef struct HB_MarkRecord_ HB_MarkRecord; + + +struct HB_MarkArray_ +{ + HB_UShort MarkCount; /* number of MarkRecord tables */ + HB_MarkRecord* MarkRecord; /* array of MarkRecord tables */ +}; + +typedef struct HB_MarkArray_ HB_MarkArray; + + +/* LookupType 1 */ + +struct HB_SinglePosFormat1_ +{ + HB_ValueRecord Value; /* ValueRecord for all covered + glyphs */ +}; + +typedef struct HB_SinglePosFormat1_ HB_SinglePosFormat1; + + +struct HB_SinglePosFormat2_ +{ + HB_UShort ValueCount; /* number of ValueRecord tables */ + HB_ValueRecord* Value; /* array of ValueRecord tables */ +}; + +typedef struct HB_SinglePosFormat2_ HB_SinglePosFormat2; + + +struct HB_SinglePos_ +{ + HB_Byte PosFormat; /* 1 or 2 */ + HB_Coverage Coverage; /* Coverage table */ + + HB_UShort ValueFormat; /* format of ValueRecord table */ + + union + { + HB_SinglePosFormat1 spf1; + HB_SinglePosFormat2 spf2; + } spf; +}; + +typedef struct HB_SinglePos_ HB_SinglePos; + + +/* LookupType 2 */ + +struct HB_PairValueRecord_ +{ + HB_UShort SecondGlyph; /* glyph ID for second glyph */ + HB_ValueRecord Value1; /* pos. data for first glyph */ + HB_ValueRecord Value2; /* pos. data for second glyph */ +}; + +typedef struct HB_PairValueRecord_ HB_PairValueRecord; + + +struct HB_PairSet_ +{ + HB_UShort PairValueCount; + /* number of PairValueRecord tables */ + HB_PairValueRecord* PairValueRecord; + /* array of PairValueRecord tables */ +}; + +typedef struct HB_PairSet_ HB_PairSet; + + +struct HB_PairPosFormat1_ +{ + HB_UShort PairSetCount; /* number of PairSet tables */ + HB_PairSet* PairSet; /* array of PairSet tables */ +}; + +typedef struct HB_PairPosFormat1_ HB_PairPosFormat1; + + +struct HB_Class2Record_ +{ + HB_ValueRecord Value1; /* pos. data for first glyph */ + HB_ValueRecord Value2; /* pos. data for second glyph */ +}; + +typedef struct HB_Class2Record_ HB_Class2Record; + + +struct HB_Class1Record_ +{ + HB_Class2Record* Class2Record; /* array of Class2Record tables */ +}; + +typedef struct HB_Class1Record_ HB_Class1Record; + + +struct HB_PairPosFormat2_ +{ + HB_ClassDefinition ClassDef1; /* class def. for first glyph */ + HB_ClassDefinition ClassDef2; /* class def. for second glyph */ + HB_UShort Class1Count; /* number of classes in ClassDef1 + table */ + HB_UShort Class2Count; /* number of classes in ClassDef2 + table */ + HB_Class1Record* Class1Record; /* array of Class1Record tables */ +}; + +typedef struct HB_PairPosFormat2_ HB_PairPosFormat2; + + +struct HB_PairPos_ +{ + HB_Byte PosFormat; /* 1 or 2 */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort ValueFormat1; /* format of ValueRecord table + for first glyph */ + HB_UShort ValueFormat2; /* format of ValueRecord table + for second glyph */ + + union + { + HB_PairPosFormat1 ppf1; + HB_PairPosFormat2 ppf2; + } ppf; +}; + +typedef struct HB_PairPos_ HB_PairPos; + + +/* LookupType 3 */ + +struct HB_EntryExitRecord_ +{ + HB_Anchor EntryAnchor; /* entry Anchor table */ + HB_Anchor ExitAnchor; /* exit Anchor table */ +}; + + +typedef struct HB_EntryExitRecord_ HB_EntryExitRecord; + +struct HB_CursivePos_ +{ + HB_UShort PosFormat; /* always 1 */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort EntryExitCount; + /* number of EntryExitRecord tables */ + HB_EntryExitRecord* EntryExitRecord; + /* array of EntryExitRecord tables */ +}; + +typedef struct HB_CursivePos_ HB_CursivePos; + + +/* LookupType 4 */ + +struct HB_BaseRecord_ +{ + HB_Anchor* BaseAnchor; /* array of base glyph anchor + tables */ +}; + +typedef struct HB_BaseRecord_ HB_BaseRecord; + + +struct HB_BaseArray_ +{ + HB_UShort BaseCount; /* number of BaseRecord tables */ + HB_BaseRecord* BaseRecord; /* array of BaseRecord tables */ +}; + +typedef struct HB_BaseArray_ HB_BaseArray; + + +struct HB_MarkBasePos_ +{ + HB_UShort PosFormat; /* always 1 */ + HB_Coverage MarkCoverage; /* mark glyph coverage table */ + HB_Coverage BaseCoverage; /* base glyph coverage table */ + HB_UShort ClassCount; /* number of mark classes */ + HB_MarkArray MarkArray; /* mark array table */ + HB_BaseArray BaseArray; /* base array table */ +}; + +typedef struct HB_MarkBasePos_ HB_MarkBasePos; + + +/* LookupType 5 */ + +struct HB_ComponentRecord_ +{ + HB_Anchor* LigatureAnchor; /* array of ligature glyph anchor + tables */ +}; + +typedef struct HB_ComponentRecord_ HB_ComponentRecord; + + +struct HB_LigatureAttach_ +{ + HB_UShort ComponentCount; + /* number of ComponentRecord tables */ + HB_ComponentRecord* ComponentRecord; + /* array of ComponentRecord tables */ +}; + +typedef struct HB_LigatureAttach_ HB_LigatureAttach; + + +struct HB_LigatureArray_ +{ + HB_UShort LigatureCount; /* number of LigatureAttach tables */ + HB_LigatureAttach* LigatureAttach; + /* array of LigatureAttach tables */ +}; + +typedef struct HB_LigatureArray_ HB_LigatureArray; + + +struct HB_MarkLigPos_ +{ + HB_UShort PosFormat; /* always 1 */ + HB_Coverage MarkCoverage; /* mark glyph coverage table */ + HB_Coverage LigatureCoverage; + /* ligature glyph coverage table */ + HB_UShort ClassCount; /* number of mark classes */ + HB_MarkArray MarkArray; /* mark array table */ + HB_LigatureArray LigatureArray; /* ligature array table */ +}; + +typedef struct HB_MarkLigPos_ HB_MarkLigPos; + + +/* LookupType 6 */ + +struct HB_Mark2Record_ +{ + HB_Anchor* Mark2Anchor; /* array of mark glyph anchor + tables */ +}; + +typedef struct HB_Mark2Record_ HB_Mark2Record; + + +struct HB_Mark2Array_ +{ + HB_UShort Mark2Count; /* number of Mark2Record tables */ + HB_Mark2Record* Mark2Record; /* array of Mark2Record tables */ +}; + +typedef struct HB_Mark2Array_ HB_Mark2Array; + + +struct HB_MarkMarkPos_ +{ + HB_UShort PosFormat; /* always 1 */ + HB_Coverage Mark1Coverage; /* first mark glyph coverage table */ + HB_Coverage Mark2Coverage; /* second mark glyph coverave table */ + HB_UShort ClassCount; /* number of combining mark classes */ + HB_MarkArray Mark1Array; /* MarkArray table for first mark */ + HB_Mark2Array Mark2Array; /* MarkArray table for second mark */ +}; + +typedef struct HB_MarkMarkPos_ HB_MarkMarkPos; + + +/* needed by both lookup type 7 and 8 */ + +struct HB_PosLookupRecord_ +{ + HB_UShort SequenceIndex; /* index into current + glyph sequence */ + HB_UShort LookupListIndex; /* Lookup to apply to that pos. */ +}; + +typedef struct HB_PosLookupRecord_ HB_PosLookupRecord; + + +/* LookupType 7 */ + +struct HB_PosRule_ +{ + HB_UShort GlyphCount; /* total number of input glyphs */ + HB_UShort PosCount; /* number of PosLookupRecord tables */ + HB_UShort* Input; /* array of input glyph IDs */ + HB_PosLookupRecord* PosLookupRecord; + /* array of PosLookupRecord tables */ +}; + +typedef struct HB_PosRule_ HB_PosRule; + + +struct HB_PosRuleSet_ +{ + HB_UShort PosRuleCount; /* number of PosRule tables */ + HB_PosRule* PosRule; /* array of PosRule tables */ +}; + +typedef struct HB_PosRuleSet_ HB_PosRuleSet; + + +struct HB_ContextPosFormat1_ +{ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort PosRuleSetCount; /* number of PosRuleSet tables */ + HB_PosRuleSet* PosRuleSet; /* array of PosRuleSet tables */ +}; + +typedef struct HB_ContextPosFormat1_ HB_ContextPosFormat1; + + +struct HB_PosClassRule_ +{ + HB_UShort GlyphCount; /* total number of context classes */ + HB_UShort PosCount; /* number of PosLookupRecord tables */ + HB_UShort* Class; /* array of classes */ + HB_PosLookupRecord* PosLookupRecord; + /* array of PosLookupRecord tables */ +}; + +typedef struct HB_PosClassRule_ HB_PosClassRule; + + +struct HB_PosClassSet_ +{ + HB_UShort PosClassRuleCount; + /* number of PosClassRule tables */ + HB_PosClassRule* PosClassRule; /* array of PosClassRule tables */ +}; + +typedef struct HB_PosClassSet_ HB_PosClassSet; + + +/* The `MaxContextLength' field is not defined in the TTO specification + but simplifies the implementation of this format. It holds the + maximal context length used in the context rules. */ + +struct HB_ContextPosFormat2_ +{ + HB_UShort MaxContextLength; + /* maximal context length */ + HB_Coverage Coverage; /* Coverage table */ + HB_ClassDefinition ClassDef; /* ClassDef table */ + HB_UShort PosClassSetCount; + /* number of PosClassSet tables */ + HB_PosClassSet* PosClassSet; /* array of PosClassSet tables */ +}; + +typedef struct HB_ContextPosFormat2_ HB_ContextPosFormat2; + + +struct HB_ContextPosFormat3_ +{ + HB_UShort GlyphCount; /* number of input glyphs */ + HB_UShort PosCount; /* number of PosLookupRecord tables */ + HB_Coverage* Coverage; /* array of Coverage tables */ + HB_PosLookupRecord* PosLookupRecord; + /* array of PosLookupRecord tables */ +}; + +typedef struct HB_ContextPosFormat3_ HB_ContextPosFormat3; + + +struct HB_ContextPos_ +{ + HB_Byte PosFormat; /* 1, 2, or 3 */ + + union + { + HB_ContextPosFormat1 cpf1; + HB_ContextPosFormat2 cpf2; + HB_ContextPosFormat3 cpf3; + } cpf; +}; + +typedef struct HB_ContextPos_ HB_ContextPos; + + +/* LookupType 8 */ + +struct HB_ChainPosRule_ +{ + HB_UShort* Backtrack; /* array of backtrack glyph IDs */ + HB_UShort* Input; /* array of input glyph IDs */ + HB_UShort* Lookahead; /* array of lookahead glyph IDs */ + HB_PosLookupRecord* PosLookupRecord; + /* array of PosLookupRecords */ + HB_UShort BacktrackGlyphCount; + /* total number of backtrack glyphs */ + HB_UShort InputGlyphCount; + /* total number of input glyphs */ + HB_UShort LookaheadGlyphCount; + /* total number of lookahead glyphs */ + HB_UShort PosCount; /* number of PosLookupRecords */ +}; + +typedef struct HB_ChainPosRule_ HB_ChainPosRule; + + +struct HB_ChainPosRuleSet_ +{ + HB_UShort ChainPosRuleCount; + /* number of ChainPosRule tables */ + HB_ChainPosRule* ChainPosRule; /* array of ChainPosRule tables */ +}; + +typedef struct HB_ChainPosRuleSet_ HB_ChainPosRuleSet; + + +struct HB_ChainContextPosFormat1_ +{ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort ChainPosRuleSetCount; + /* number of ChainPosRuleSet tables */ + HB_ChainPosRuleSet* ChainPosRuleSet; + /* array of ChainPosRuleSet tables */ +}; + +typedef struct HB_ChainContextPosFormat1_ HB_ChainContextPosFormat1; + + +struct HB_ChainPosClassRule_ +{ + HB_UShort* Backtrack; /* array of backtrack classes */ + HB_UShort* Input; /* array of context classes */ + HB_UShort* Lookahead; /* array of lookahead classes */ + HB_PosLookupRecord* PosLookupRecord; + /* array of substitution lookups */ + HB_UShort BacktrackGlyphCount; + /* total number of backtrack + classes */ + HB_UShort InputGlyphCount; + /* total number of context classes */ + HB_UShort LookaheadGlyphCount; + /* total number of lookahead + classes */ + HB_UShort PosCount; /* number of PosLookupRecords */ +}; + +typedef struct HB_ChainPosClassRule_ HB_ChainPosClassRule; + + +struct HB_ChainPosClassSet_ +{ + HB_UShort ChainPosClassRuleCount; + /* number of ChainPosClassRule + tables */ + HB_ChainPosClassRule* ChainPosClassRule; + /* array of ChainPosClassRule + tables */ +}; + +typedef struct HB_ChainPosClassSet_ HB_ChainPosClassSet; + + +/* The `MaxXXXLength' fields are not defined in the TTO specification + but simplifies the implementation of this format. It holds the + maximal context length used in the specific context rules. */ + +struct HB_ChainContextPosFormat2_ +{ + HB_Coverage Coverage; /* Coverage table */ + + HB_UShort MaxBacktrackLength; + /* maximal backtrack length */ + HB_ClassDefinition BacktrackClassDef; + /* BacktrackClassDef table */ + HB_UShort MaxInputLength; + /* maximal input length */ + HB_ClassDefinition InputClassDef; + /* InputClassDef table */ + HB_UShort MaxLookaheadLength; + /* maximal lookahead length */ + HB_ClassDefinition LookaheadClassDef; + /* LookaheadClassDef table */ + + HB_UShort ChainPosClassSetCount; + /* number of ChainPosClassSet + tables */ + HB_ChainPosClassSet* ChainPosClassSet; + /* array of ChainPosClassSet + tables */ +}; + +typedef struct HB_ChainContextPosFormat2_ HB_ChainContextPosFormat2; + + +struct HB_ChainContextPosFormat3_ +{ + HB_UShort BacktrackGlyphCount; + /* number of backtrack glyphs */ + HB_Coverage* BacktrackCoverage; + /* array of backtrack Coverage + tables */ + HB_UShort InputGlyphCount; + /* number of input glyphs */ + HB_Coverage* InputCoverage; + /* array of input coverage + tables */ + HB_UShort LookaheadGlyphCount; + /* number of lookahead glyphs */ + HB_Coverage* LookaheadCoverage; + /* array of lookahead coverage + tables */ + HB_UShort PosCount; /* number of PosLookupRecords */ + HB_PosLookupRecord* PosLookupRecord; + /* array of substitution lookups */ +}; + +typedef struct HB_ChainContextPosFormat3_ HB_ChainContextPosFormat3; + + +struct HB_ChainContextPos_ +{ + HB_Byte PosFormat; /* 1, 2, or 3 */ + + union + { + HB_ChainContextPosFormat1 ccpf1; + HB_ChainContextPosFormat2 ccpf2; + HB_ChainContextPosFormat3 ccpf3; + } ccpf; +}; + +typedef struct HB_ChainContextPos_ HB_ChainContextPos; + + +#if 0 +/* LookupType 10 */ +struct HB_ExtensionPos_ +{ + HB_UShort PosFormat; /* always 1 */ + HB_UShort LookuptType; /* lookup-type of referenced subtable */ + HB_GPOS_SubTable *subtable; /* referenced subtable */ +}; + +typedef struct HB_ExtensionPos_ HB_ExtensionPos; +#endif + + +union HB_GPOS_SubTable_ +{ + HB_SinglePos single; + HB_PairPos pair; + HB_CursivePos cursive; + HB_MarkBasePos markbase; + HB_MarkLigPos marklig; + HB_MarkMarkPos markmark; + HB_ContextPos context; + HB_ChainContextPos chain; +}; + +typedef union HB_GPOS_SubTable_ HB_GPOS_SubTable; + + + +HB_INTERNAL HB_Error +_HB_GPOS_Load_SubTable( HB_GPOS_SubTable* st, + HB_Stream stream, + HB_UShort lookup_type ); + +HB_INTERNAL void +_HB_GPOS_Free_SubTable( HB_GPOS_SubTable* st, + HB_UShort lookup_type ); + +HB_END_HEADER + +#endif /* HARFBUZZ_GPOS_PRIVATE_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-gpos.h b/src/qt-harfbuzz/src/harfbuzz-gpos.h new file mode 100644 index 0000000000..92bff84a94 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-gpos.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_GPOS_H +#define HARFBUZZ_GPOS_H + +#include "harfbuzz-gdef.h" +#include "harfbuzz-buffer.h" + +HB_BEGIN_HEADER + + +/* Lookup types for glyph positioning */ + +#define HB_GPOS_LOOKUP_SINGLE 1 +#define HB_GPOS_LOOKUP_PAIR 2 +#define HB_GPOS_LOOKUP_CURSIVE 3 +#define HB_GPOS_LOOKUP_MARKBASE 4 +#define HB_GPOS_LOOKUP_MARKLIG 5 +#define HB_GPOS_LOOKUP_MARKMARK 6 +#define HB_GPOS_LOOKUP_CONTEXT 7 +#define HB_GPOS_LOOKUP_CHAIN 8 +#define HB_GPOS_LOOKUP_EXTENSION 9 + +#ifdef HB_SUPPORT_MULTIPLE_MASTER +/* A pointer to a function which accesses the PostScript interpreter. + Multiple Master fonts need this interface to convert a metric ID + (as stored in an OpenType font version 1.2 or higher) `metric_id' + into a metric value (returned in `metric_value'). + + `data' points to the user-defined structure specified during a + call to HB_GPOS_Register_MM_Function(). + + `metric_value' must be returned as a scaled value (but shouldn't + be rounded). */ + +typedef HB_Error (*HB_MMFunction)(HB_Font font, + HB_UShort metric_id, + HB_Fixed* metric_value, + void* data ); +#endif + + +struct HB_GPOSHeader_ +{ + HB_16Dot16 Version; + + HB_ScriptList ScriptList; + HB_FeatureList FeatureList; + HB_LookupList LookupList; + + HB_GDEFHeader* gdef; + +#ifdef HB_SUPPORT_MULTIPLE_MASTER + /* this is OpenType 1.2 -- Multiple Master fonts need this + callback function to get various metric values from the + PostScript interpreter. */ + + HB_MMFunction mmfunc; + void* data; +#endif +}; + +typedef struct HB_GPOSHeader_ HB_GPOSHeader; +typedef HB_GPOSHeader* HB_GPOS; + + +HB_Error HB_Load_GPOS_Table( HB_Stream stream, + HB_GPOSHeader** gpos, + HB_GDEFHeader* gdef, + HB_Stream gdefStream ); + + +HB_Error HB_Done_GPOS_Table( HB_GPOSHeader* gpos ); + + +HB_Error HB_GPOS_Select_Script( HB_GPOSHeader* gpos, + HB_UInt script_tag, + HB_UShort* script_index ); + +HB_Error HB_GPOS_Select_Language( HB_GPOSHeader* gpos, + HB_UInt language_tag, + HB_UShort script_index, + HB_UShort* language_index, + HB_UShort* req_feature_index ); + +HB_Error HB_GPOS_Select_Feature( HB_GPOSHeader* gpos, + HB_UInt feature_tag, + HB_UShort script_index, + HB_UShort language_index, + HB_UShort* feature_index ); + + +HB_Error HB_GPOS_Query_Scripts( HB_GPOSHeader* gpos, + HB_UInt** script_tag_list ); + +HB_Error HB_GPOS_Query_Languages( HB_GPOSHeader* gpos, + HB_UShort script_index, + HB_UInt** language_tag_list ); + +HB_Error HB_GPOS_Query_Features( HB_GPOSHeader* gpos, + HB_UShort script_index, + HB_UShort language_index, + HB_UInt** feature_tag_list ); + + +HB_Error HB_GPOS_Add_Feature( HB_GPOSHeader* gpos, + HB_UShort feature_index, + HB_UInt property ); + +HB_Error HB_GPOS_Clear_Features( HB_GPOSHeader* gpos ); + + +#ifdef HB_SUPPORT_MULTIPLE_MASTER +HB_Error HB_GPOS_Register_MM_Function( HB_GPOSHeader* gpos, + HB_MMFunction mmfunc, + void* data ); +#endif + +/* If `dvi' is TRUE, glyph contour points for anchor points and device + tables are ignored -- you will get device independent values. */ + + +HB_Error HB_GPOS_Apply_String( HB_Font font, + HB_GPOSHeader* gpos, + HB_UShort load_flags, + HB_Buffer buffer, + HB_Bool dvi, + HB_Bool r2l ); + +HB_END_HEADER + +#endif /* HARFBUZZ_GPOS_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-gsub-private.h b/src/qt-harfbuzz/src/harfbuzz-gsub-private.h new file mode 100644 index 0000000000..df0c3f639f --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-gsub-private.h @@ -0,0 +1,475 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_GSUB_PRIVATE_H +#define HARFBUZZ_GSUB_PRIVATE_H + +#include "harfbuzz-impl.h" +#include "harfbuzz-stream-private.h" +#include "harfbuzz-gsub.h" + +HB_BEGIN_HEADER + +typedef union HB_GSUB_SubTable_ HB_GSUB_SubTable; + +/* LookupType 1 */ + +struct HB_SingleSubstFormat1_ +{ + HB_Short DeltaGlyphID; /* constant added to get + substitution glyph index */ +}; + +typedef struct HB_SingleSubstFormat1_ HB_SingleSubstFormat1; + + +struct HB_SingleSubstFormat2_ +{ + HB_UShort* Substitute; /* array of substitute glyph IDs */ + HB_UShort GlyphCount; /* number of glyph IDs in + Substitute array */ +}; + +typedef struct HB_SingleSubstFormat2_ HB_SingleSubstFormat2; + + +struct HB_SingleSubst_ +{ + union + { + HB_SingleSubstFormat1 ssf1; + HB_SingleSubstFormat2 ssf2; + } ssf; + + HB_Coverage Coverage; /* Coverage table */ + HB_Byte SubstFormat; /* 1 or 2 */ +}; + +typedef struct HB_SingleSubst_ HB_SingleSubst; + + +/* LookupType 2 */ + +struct HB_Sequence_ +{ + HB_UShort* Substitute; /* string of glyph IDs to + substitute */ + HB_UShort GlyphCount; /* number of glyph IDs in the + Substitute array */ +}; + +typedef struct HB_Sequence_ HB_Sequence; + + +struct HB_MultipleSubst_ +{ + HB_Sequence* Sequence; /* array of Sequence tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort SubstFormat; /* always 1 */ + HB_UShort SequenceCount; /* number of Sequence tables */ +}; + +typedef struct HB_MultipleSubst_ HB_MultipleSubst; + + +/* LookupType 3 */ + +struct HB_AlternateSet_ +{ + HB_UShort* Alternate; /* array of alternate glyph IDs */ + HB_UShort GlyphCount; /* number of glyph IDs in the + Alternate array */ +}; + +typedef struct HB_AlternateSet_ HB_AlternateSet; + + +struct HB_AlternateSubst_ +{ + HB_AlternateSet* AlternateSet; /* array of AlternateSet tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort SubstFormat; /* always 1 */ + HB_UShort AlternateSetCount; + /* number of AlternateSet tables */ +}; + +typedef struct HB_AlternateSubst_ HB_AlternateSubst; + + +/* LookupType 4 */ + +struct HB_Ligature_ +{ + HB_UShort* Component; /* array of component glyph IDs */ + HB_UShort LigGlyph; /* glyphID of ligature + to substitute */ + HB_UShort ComponentCount; /* number of components in ligature */ +}; + +typedef struct HB_Ligature_ HB_Ligature; + + +struct HB_LigatureSet_ +{ + HB_Ligature* Ligature; /* array of Ligature tables */ + HB_UShort LigatureCount; /* number of Ligature tables */ +}; + +typedef struct HB_LigatureSet_ HB_LigatureSet; + + +struct HB_LigatureSubst_ +{ + HB_LigatureSet* LigatureSet; /* array of LigatureSet tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort SubstFormat; /* always 1 */ + HB_UShort LigatureSetCount; /* number of LigatureSet tables */ +}; + +typedef struct HB_LigatureSubst_ HB_LigatureSubst; + + +/* needed by both lookup type 5 and 6 */ + +struct HB_SubstLookupRecord_ +{ + HB_UShort SequenceIndex; /* index into current + glyph sequence */ + HB_UShort LookupListIndex; /* Lookup to apply to that pos. */ +}; + +typedef struct HB_SubstLookupRecord_ HB_SubstLookupRecord; + + +/* LookupType 5 */ + +struct HB_SubRule_ +{ + HB_UShort* Input; /* array of input glyph IDs */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of SubstLookupRecord + tables */ + HB_UShort GlyphCount; /* total number of input glyphs */ + HB_UShort SubstCount; /* number of SubstLookupRecord + tables */ +}; + +typedef struct HB_SubRule_ HB_SubRule; + + +struct HB_SubRuleSet_ +{ + HB_SubRule* SubRule; /* array of SubRule tables */ + HB_UShort SubRuleCount; /* number of SubRule tables */ +}; + +typedef struct HB_SubRuleSet_ HB_SubRuleSet; + + +struct HB_ContextSubstFormat1_ +{ + HB_SubRuleSet* SubRuleSet; /* array of SubRuleSet tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort SubRuleSetCount; /* number of SubRuleSet tables */ +}; + +typedef struct HB_ContextSubstFormat1_ HB_ContextSubstFormat1; + + +struct HB_SubClassRule_ +{ + HB_UShort* Class; /* array of classes */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of SubstLookupRecord + tables */ + HB_UShort GlyphCount; /* total number of context classes */ + HB_UShort SubstCount; /* number of SubstLookupRecord + tables */ +}; + +typedef struct HB_SubClassRule_ HB_SubClassRule; + + +struct HB_SubClassSet_ +{ + HB_SubClassRule* SubClassRule; /* array of SubClassRule tables */ + HB_UShort SubClassRuleCount; + /* number of SubClassRule tables */ +}; + +typedef struct HB_SubClassSet_ HB_SubClassSet; + + +/* The `MaxContextLength' field is not defined in the TTO specification + but simplifies the implementation of this format. It holds the + maximal context length used in the context rules. */ + +struct HB_ContextSubstFormat2_ +{ + HB_SubClassSet* SubClassSet; /* array of SubClassSet tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_ClassDefinition ClassDef; /* ClassDef table */ + HB_UShort SubClassSetCount; + /* number of SubClassSet tables */ + HB_UShort MaxContextLength; + /* maximal context length */ +}; + +typedef struct HB_ContextSubstFormat2_ HB_ContextSubstFormat2; + + +struct HB_ContextSubstFormat3_ +{ + HB_Coverage* Coverage; /* array of Coverage tables */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of substitution lookups */ + HB_UShort GlyphCount; /* number of input glyphs */ + HB_UShort SubstCount; /* number of SubstLookupRecords */ +}; + +typedef struct HB_ContextSubstFormat3_ HB_ContextSubstFormat3; + + +struct HB_ContextSubst_ +{ + union + { + HB_ContextSubstFormat1 csf1; + HB_ContextSubstFormat2 csf2; + HB_ContextSubstFormat3 csf3; + } csf; + + HB_Byte SubstFormat; /* 1, 2, or 3 */ +}; + +typedef struct HB_ContextSubst_ HB_ContextSubst; + + +/* LookupType 6 */ + +struct HB_ChainSubRule_ +{ + HB_UShort* Backtrack; /* array of backtrack glyph IDs */ + HB_UShort* Input; /* array of input glyph IDs */ + HB_UShort* Lookahead; /* array of lookahead glyph IDs */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of SubstLookupRecords */ + HB_UShort BacktrackGlyphCount; + /* total number of backtrack glyphs */ + HB_UShort InputGlyphCount; + /* total number of input glyphs */ + HB_UShort LookaheadGlyphCount; + /* total number of lookahead glyphs */ + HB_UShort SubstCount; /* number of SubstLookupRecords */ +}; + +typedef struct HB_ChainSubRule_ HB_ChainSubRule; + + +struct HB_ChainSubRuleSet_ +{ + HB_ChainSubRule* ChainSubRule; /* array of ChainSubRule tables */ + HB_UShort ChainSubRuleCount; + /* number of ChainSubRule tables */ +}; + +typedef struct HB_ChainSubRuleSet_ HB_ChainSubRuleSet; + + +struct HB_ChainContextSubstFormat1_ +{ + HB_ChainSubRuleSet* ChainSubRuleSet; + /* array of ChainSubRuleSet tables */ + HB_Coverage Coverage; /* Coverage table */ + HB_UShort ChainSubRuleSetCount; + /* number of ChainSubRuleSet tables */ +}; + +typedef struct HB_ChainContextSubstFormat1_ HB_ChainContextSubstFormat1; + + +struct HB_ChainSubClassRule_ +{ + HB_UShort* Backtrack; /* array of backtrack classes */ + HB_UShort* Input; /* array of context classes */ + HB_UShort* Lookahead; /* array of lookahead classes */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of substitution lookups */ + HB_UShort BacktrackGlyphCount; + /* total number of backtrack + classes */ + HB_UShort InputGlyphCount; + /* total number of context classes */ + HB_UShort LookaheadGlyphCount; + /* total number of lookahead + classes */ + HB_UShort SubstCount; /* number of SubstLookupRecords */ +}; + +typedef struct HB_ChainSubClassRule_ HB_ChainSubClassRule; + + +struct HB_ChainSubClassSet_ +{ + HB_ChainSubClassRule* ChainSubClassRule; + /* array of ChainSubClassRule + tables */ + HB_UShort ChainSubClassRuleCount; + /* number of ChainSubClassRule + tables */ +}; + +typedef struct HB_ChainSubClassSet_ HB_ChainSubClassSet; + + +/* The `MaxXXXLength' fields are not defined in the TTO specification + but simplifies the implementation of this format. It holds the + maximal context length used in the specific context rules. */ + +struct HB_ChainContextSubstFormat2_ +{ + HB_ChainSubClassSet* ChainSubClassSet; + /* array of ChainSubClassSet + tables */ + HB_Coverage Coverage; /* Coverage table */ + + HB_ClassDefinition BacktrackClassDef; + /* BacktrackClassDef table */ + HB_ClassDefinition InputClassDef; + /* InputClassDef table */ + HB_ClassDefinition LookaheadClassDef; + /* LookaheadClassDef table */ + + HB_UShort ChainSubClassSetCount; + /* number of ChainSubClassSet + tables */ + HB_UShort MaxBacktrackLength; + /* maximal backtrack length */ + HB_UShort MaxLookaheadLength; + /* maximal lookahead length */ + HB_UShort MaxInputLength; + /* maximal input length */ +}; + +typedef struct HB_ChainContextSubstFormat2_ HB_ChainContextSubstFormat2; + + +struct HB_ChainContextSubstFormat3_ +{ + HB_Coverage* BacktrackCoverage; + /* array of backtrack Coverage + tables */ + HB_Coverage* InputCoverage; + /* array of input coverage + tables */ + HB_Coverage* LookaheadCoverage; + /* array of lookahead coverage + tables */ + HB_SubstLookupRecord* SubstLookupRecord; + /* array of substitution lookups */ + HB_UShort BacktrackGlyphCount; + /* number of backtrack glyphs */ + HB_UShort InputGlyphCount; + /* number of input glyphs */ + HB_UShort LookaheadGlyphCount; + /* number of lookahead glyphs */ + HB_UShort SubstCount; /* number of SubstLookupRecords */ +}; + +typedef struct HB_ChainContextSubstFormat3_ HB_ChainContextSubstFormat3; + + +struct HB_ChainContextSubst_ +{ + union + { + HB_ChainContextSubstFormat1 ccsf1; + HB_ChainContextSubstFormat2 ccsf2; + HB_ChainContextSubstFormat3 ccsf3; + } ccsf; + + HB_Byte SubstFormat; /* 1, 2, or 3 */ +}; + +typedef struct HB_ChainContextSubst_ HB_ChainContextSubst; + + +#if 0 +/* LookupType 7 */ +struct HB_ExtensionSubst_ +{ + HB_GSUB_SubTable *subtable; /* referenced subtable */ + HB_UShort SubstFormat; /* always 1 */ + HB_UShort LookuptType; /* lookup-type of referenced subtable */ +}; + +typedef struct HB_ExtensionSubst_ HB_ExtensionSubst; +#endif + + +/* LookupType 8 */ +struct HB_ReverseChainContextSubst_ +{ + HB_Coverage* LookaheadCoverage; /* array of lookahead Coverage + tables */ + HB_UShort* Substitute; /* array of substitute Glyph ID */ + HB_Coverage* BacktrackCoverage; /* array of backtrack Coverage + tables */ + HB_Coverage Coverage; /* coverage table for input glyphs */ + HB_UShort SubstFormat; /* always 1 */ + HB_UShort BacktrackGlyphCount; /* number of backtrack glyphs */ + HB_UShort LookaheadGlyphCount; /* number of lookahead glyphs */ + HB_UShort GlyphCount; /* number of Glyph IDs */ +}; + +typedef struct HB_ReverseChainContextSubst_ HB_ReverseChainContextSubst; + + +union HB_GSUB_SubTable_ +{ + HB_SingleSubst single; + HB_MultipleSubst multiple; + HB_AlternateSubst alternate; + HB_LigatureSubst ligature; + HB_ContextSubst context; + HB_ChainContextSubst chain; + HB_ReverseChainContextSubst reverse; +}; + + + + +HB_INTERNAL HB_Error +_HB_GSUB_Load_SubTable( HB_GSUB_SubTable* st, + HB_Stream stream, + HB_UShort lookup_type ); + +HB_INTERNAL void +_HB_GSUB_Free_SubTable( HB_GSUB_SubTable* st, + HB_UShort lookup_type ); + +HB_END_HEADER + +#endif /* HARFBUZZ_GSUB_PRIVATE_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-gsub.h b/src/qt-harfbuzz/src/harfbuzz-gsub.h new file mode 100644 index 0000000000..6e452bdb35 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-gsub.h @@ -0,0 +1,139 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_GSUB_H +#define HARFBUZZ_GSUB_H + +#include "harfbuzz-gdef.h" +#include "harfbuzz-buffer.h" + +HB_BEGIN_HEADER + +/* Lookup types for glyph substitution */ + +#define HB_GSUB_LOOKUP_SINGLE 1 +#define HB_GSUB_LOOKUP_MULTIPLE 2 +#define HB_GSUB_LOOKUP_ALTERNATE 3 +#define HB_GSUB_LOOKUP_LIGATURE 4 +#define HB_GSUB_LOOKUP_CONTEXT 5 +#define HB_GSUB_LOOKUP_CHAIN 6 +#define HB_GSUB_LOOKUP_EXTENSION 7 +#define HB_GSUB_LOOKUP_REVERSE_CHAIN 8 + + +/* A pointer to a function which selects the alternate glyph. `pos' is + the position of the glyph with index `glyphID', `num_alternates' + gives the number of alternates in the `alternates' array. `data' + points to the user-defined structure specified during a call to + HB_GSUB_Register_Alternate_Function(). The function must return an + index into the `alternates' array. */ + +typedef HB_UShort (*HB_AltFunction)(HB_UInt pos, + HB_UShort glyphID, + HB_UShort num_alternates, + HB_UShort* alternates, + void* data ); + + +struct HB_GSUBHeader_ +{ + HB_GDEFHeader* gdef; + + /* the next two fields are used for an alternate substitution callback + function to select the proper alternate glyph. */ + + void* data; + HB_AltFunction altfunc; + + HB_UInt offset; + + HB_16Dot16 Version; + + HB_ScriptList ScriptList; + HB_FeatureList FeatureList; + HB_LookupList LookupList; +}; + +typedef struct HB_GSUBHeader_ HB_GSUBHeader; +typedef HB_GSUBHeader* HB_GSUB; + + +HB_Error HB_Load_GSUB_Table( HB_Stream stream, + HB_GSUBHeader** gsub, + HB_GDEFHeader* gdef, + HB_Stream gdefStream ); + + +HB_Error HB_Done_GSUB_Table( HB_GSUBHeader* gsub ); + + +HB_Error HB_GSUB_Select_Script( HB_GSUBHeader* gsub, + HB_UInt script_tag, + HB_UShort* script_index ); + +HB_Error HB_GSUB_Select_Language( HB_GSUBHeader* gsub, + HB_UInt language_tag, + HB_UShort script_index, + HB_UShort* language_index, + HB_UShort* req_feature_index ); + +HB_Error HB_GSUB_Select_Feature( HB_GSUBHeader* gsub, + HB_UInt feature_tag, + HB_UShort script_index, + HB_UShort language_index, + HB_UShort* feature_index ); + + +HB_Error HB_GSUB_Query_Scripts( HB_GSUBHeader* gsub, + HB_UInt** script_tag_list ); + +HB_Error HB_GSUB_Query_Languages( HB_GSUBHeader* gsub, + HB_UShort script_index, + HB_UInt** language_tag_list ); + +HB_Error HB_GSUB_Query_Features( HB_GSUBHeader* gsub, + HB_UShort script_index, + HB_UShort language_index, + HB_UInt** feature_tag_list ); + + +HB_Error HB_GSUB_Add_Feature( HB_GSUBHeader* gsub, + HB_UShort feature_index, + HB_UInt property ); + +HB_Error HB_GSUB_Clear_Features( HB_GSUBHeader* gsub ); + + +HB_Error HB_GSUB_Register_Alternate_Function( HB_GSUBHeader* gsub, + HB_AltFunction altfunc, + void* data ); + + +HB_Error HB_GSUB_Apply_String( HB_GSUBHeader* gsub, + HB_Buffer buffer ); + +HB_END_HEADER + +#endif /* HARFBUZZ_GSUB_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-impl.h b/src/qt-harfbuzz/src/harfbuzz-impl.h new file mode 100644 index 0000000000..5f430498c4 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-impl.h @@ -0,0 +1,131 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_IMPL_H +#define HARFBUZZ_IMPL_H + +#include "harfbuzz-global.h" + +#include + +HB_BEGIN_HEADER + +#ifndef HB_INTERNAL +# define HB_INTERNAL +#endif + +#ifndef NULL +# define NULL ((void *)0) +#endif + +#ifndef FALSE +# define FALSE 0 +#endif + +#ifndef TRUE +# define TRUE 1 +#endif + +#ifndef TTAG_GDEF +# define TTAG_GDEF HB_MAKE_TAG( 'G', 'D', 'E', 'F' ) +#endif +#ifndef TTAG_GPOS +# define TTAG_GPOS HB_MAKE_TAG( 'G', 'P', 'O', 'S' ) +#endif +#ifndef TTAG_GSUB +# define TTAG_GSUB HB_MAKE_TAG( 'G', 'S', 'U', 'B' ) +#endif + +#ifndef HB_UNUSED +# define HB_UNUSED(arg) ((arg) = (arg)) +#endif + +#define HB_LIKELY(cond) (cond) +#define HB_UNLIKELY(cond) (cond) + +#define ARRAY_LEN(Array) ((int)(sizeof (Array) / sizeof (Array)[0])) + + + +#define HB_IsHighSurrogate(ucs) \ + (((ucs) & 0xfc00) == 0xd800) + +#define HB_IsLowSurrogate(ucs) \ + (((ucs) & 0xfc00) == 0xdc00) + +#define HB_SurrogateToUcs4(high, low) \ + (((HB_UChar32)(high))<<10) + (low) - 0x35fdc00; + + + + + +#define ALLOC(_ptr,_size) \ + ( (_ptr) = _hb_alloc( _size, &error ), error != 0 ) + +#define REALLOC(_ptr,_newsz) \ + ( (_ptr) = _hb_realloc( (_ptr), (_newsz), &error ), error != 0 ) + +#define FREE(_ptr) \ + do { \ + if ( (_ptr) ) \ + { \ + _hb_free( _ptr ); \ + _ptr = NULL; \ + } \ + } while (0) + +#define ALLOC_ARRAY(_ptr,_count,_type) \ + ALLOC(_ptr,(_count)*sizeof(_type)) + +#define REALLOC_ARRAY(_ptr,_newcnt,_type) \ + REALLOC(_ptr,(_newcnt)*sizeof(_type)) + +#define MEM_Copy(dest,source,count) memcpy( (char*)(dest), (const char*)(source), (size_t)(count) ) + +#define ERR(err) _hb_err (err) + + +HB_INTERNAL HB_Pointer +_hb_alloc( size_t size, + HB_Error *perror_ ); + +HB_INTERNAL HB_Pointer +_hb_realloc( HB_Pointer block, + size_t new_size, + HB_Error *perror_ ); + +HB_INTERNAL void +_hb_free( HB_Pointer block ); + + +/* helper func to set a breakpoint on */ +HB_INTERNAL HB_Error +_hb_err (HB_Error code); + + +HB_END_HEADER + +#endif /* HARFBUZZ_IMPL_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-open-private.h b/src/qt-harfbuzz/src/harfbuzz-open-private.h new file mode 100644 index 0000000000..f1ca27809b --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-open-private.h @@ -0,0 +1,102 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_OPEN_PRIVATE_H +#define HARFBUZZ_OPEN_PRIVATE_H + +#include "harfbuzz-impl.h" +#include "harfbuzz-open.h" +#include "harfbuzz-gsub-private.h" +#include "harfbuzz-gpos-private.h" + +HB_BEGIN_HEADER + + +struct HB_SubTable_ +{ + union + { + HB_GSUB_SubTable gsub; + HB_GPOS_SubTable gpos; + } st; +}; + + +HB_INTERNAL HB_Error +_HB_OPEN_Load_ScriptList( HB_ScriptList* sl, + HB_Stream input ); +HB_INTERNAL HB_Error +_HB_OPEN_Load_FeatureList( HB_FeatureList* fl, + HB_Stream input ); +HB_INTERNAL HB_Error +_HB_OPEN_Load_LookupList( HB_LookupList* ll, + HB_Stream input, + HB_Type type ); + +HB_INTERNAL HB_Error +_HB_OPEN_Load_Coverage( HB_Coverage* c, + HB_Stream input ); +HB_INTERNAL HB_Error +_HB_OPEN_Load_ClassDefinition( HB_ClassDefinition* cd, + HB_UShort limit, + HB_Stream input ); +HB_INTERNAL HB_Error +_HB_OPEN_Load_EmptyOrClassDefinition( HB_ClassDefinition* cd, + HB_UShort limit, + HB_UInt class_offset, + HB_UInt base_offset, + HB_Stream input ); +HB_INTERNAL HB_Error +_HB_OPEN_Load_Device( HB_Device** d, + HB_Stream input ); + +HB_INTERNAL void _HB_OPEN_Free_ScriptList( HB_ScriptList* sl ); +HB_INTERNAL void _HB_OPEN_Free_FeatureList( HB_FeatureList* fl ); +HB_INTERNAL void _HB_OPEN_Free_LookupList( HB_LookupList* ll, + HB_Type type ); + +HB_INTERNAL void _HB_OPEN_Free_Coverage( HB_Coverage* c ); +HB_INTERNAL void _HB_OPEN_Free_ClassDefinition( HB_ClassDefinition* cd ); +HB_INTERNAL void _HB_OPEN_Free_Device( HB_Device* d ); + + + +HB_INTERNAL HB_Error +_HB_OPEN_Coverage_Index( HB_Coverage* c, + HB_UShort glyphID, + HB_UShort* index ); +HB_INTERNAL HB_Error +_HB_OPEN_Get_Class( HB_ClassDefinition* cd, + HB_UShort glyphID, + HB_UShort* klass, + HB_UShort* index ); +HB_INTERNAL HB_Error +_HB_OPEN_Get_Device( HB_Device* d, + HB_UShort size, + HB_Short* value ); + +HB_END_HEADER + +#endif /* HARFBUZZ_OPEN_PRIVATE_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-open.h b/src/qt-harfbuzz/src/harfbuzz-open.h new file mode 100644 index 0000000000..9ad7c98b2c --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-open.h @@ -0,0 +1,280 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_OPEN_H +#define HARFBUZZ_OPEN_H + +#include "harfbuzz-global.h" + +HB_BEGIN_HEADER + +/* Use this if a feature applies to all glyphs */ +#define HB_ALL_GLYPHS 0xFFFF + +#define HB_DEFAULT_LANGUAGE 0xFFFF + +#define HB_MAX_NESTING_LEVEL 100 + + +/* Script list related structures */ + +struct HB_LangSys_ +{ + HB_UShort* FeatureIndex; /* array of Feature indices */ + HB_UShort LookupOrderOffset; /* always 0 for TT Open 1.0 */ + HB_UShort ReqFeatureIndex; /* required FeatureIndex */ + HB_UShort FeatureCount; /* number of Feature indices */ +}; + +typedef struct HB_LangSys_ HB_LangSys; + + +struct HB_LangSysRecord_ +{ + HB_LangSys LangSys; /* LangSys table */ + HB_UInt LangSysTag; /* LangSysTag identifier */ +}; + +typedef struct HB_LangSysRecord_ HB_LangSysRecord; + + +struct HB_ScriptTable_ +{ + HB_LangSysRecord* LangSysRecord; /* array of LangSysRecords */ + HB_LangSys DefaultLangSys; /* DefaultLangSys table */ + HB_UShort LangSysCount; /* number of LangSysRecords */ +}; + +typedef struct HB_ScriptTable_ HB_ScriptTable; + + +struct HB_ScriptRecord_ +{ + HB_UInt ScriptTag; /* ScriptTag identifier */ + HB_ScriptTable Script; /* Script table */ +}; + +typedef struct HB_ScriptRecord_ HB_ScriptRecord; + + +struct HB_ScriptList_ +{ + HB_ScriptRecord* ScriptRecord; /* array of ScriptRecords */ + HB_UShort ScriptCount; /* number of ScriptRecords */ +}; + +typedef struct HB_ScriptList_ HB_ScriptList; + + +/* Feature list related structures */ + +struct HB_Feature_ +{ + HB_UShort* LookupListIndex; /* array of LookupList indices */ + HB_UShort FeatureParams; /* always 0 for TT Open 1.0 */ + HB_UShort LookupListCount; /* number of LookupList indices */ +}; + +typedef struct HB_Feature_ HB_Feature; + + +struct HB_FeatureRecord_ +{ + HB_UInt FeatureTag; /* FeatureTag identifier */ + HB_Feature Feature; /* Feature table */ +}; + +typedef struct HB_FeatureRecord_ HB_FeatureRecord; + + +struct HB_FeatureList_ +{ + HB_UShort* ApplyOrder; /* order to apply features */ + HB_FeatureRecord* FeatureRecord; /* array of FeatureRecords */ + HB_UShort FeatureCount; /* number of FeatureRecords */ + HB_UShort ApplyCount; /* number of elements in ApplyOrder */ +}; + +typedef struct HB_FeatureList_ HB_FeatureList; + + +/* Lookup list related structures */ + +typedef struct HB_SubTable_ HB_SubTable; + + +struct HB_Lookup_ +{ + HB_SubTable* SubTable; /* array of SubTables */ + HB_UShort LookupType; /* Lookup type */ + HB_UShort LookupFlag; /* Lookup qualifiers */ + HB_UShort SubTableCount; /* number of SubTables */ +}; + +typedef struct HB_Lookup_ HB_Lookup; + + +/* The `Properties' field is not defined in the OpenType specification but + is needed for processing lookups. If properties[n] is > 0, the + functions HB_GSUB_Apply_String() resp. HB_GPOS_Apply_String() will + process Lookup[n] for glyphs which have the specific bit not set in + the `properties' field of the input string object. */ + +struct HB_LookupList_ +{ + HB_Lookup* Lookup; /* array of Lookup records */ + HB_UInt* Properties; /* array of flags */ + HB_UShort LookupCount; /* number of Lookups */ +}; + +typedef struct HB_LookupList_ HB_LookupList; + + +/* Possible LookupFlag bit masks. `HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS' comes from the + OpenType 1.2 specification; HB_LOOKUP_FLAG_RIGHT_TO_LEFT has been (re)introduced in + OpenType 1.3 -- if set, the last glyph in a cursive attachment + sequence has to be positioned on the baseline -- regardless of the + writing direction. */ + +#define HB_LOOKUP_FLAG_RIGHT_TO_LEFT 0x0001 +#define HB_LOOKUP_FLAG_IGNORE_BASE_GLYPHS 0x0002 +#define HB_LOOKUP_FLAG_IGNORE_LIGATURES 0x0004 +#define HB_LOOKUP_FLAG_IGNORE_MARKS 0x0008 +#define HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS 0xFF00 + + +struct HB_CoverageFormat1_ +{ + HB_UShort* GlyphArray; /* array of glyph IDs */ + HB_UShort GlyphCount; /* number of glyphs in GlyphArray */ +}; + +typedef struct HB_CoverageFormat1_ HB_CoverageFormat1; + + +struct HB_RangeRecord_ +{ + HB_UShort Start; /* first glyph ID in the range */ + HB_UShort End; /* last glyph ID in the range */ + HB_UShort StartCoverageIndex; /* coverage index of first + glyph ID in the range */ +}; + +typedef struct HB_RangeRecord_ HB_RangeRecord; + + +struct HB_CoverageFormat2_ +{ + HB_RangeRecord* RangeRecord; /* array of RangeRecords */ + HB_UShort RangeCount; /* number of RangeRecords */ +}; + +typedef struct HB_CoverageFormat2_ HB_CoverageFormat2; + + +struct HB_Coverage_ +{ + HB_Byte CoverageFormat; /* 1 or 2 */ + + union + { + HB_CoverageFormat1 cf1; + HB_CoverageFormat2 cf2; + } cf; +}; + +typedef struct HB_Coverage_ HB_Coverage; + + +struct HB_ClassDefFormat1_ +{ + HB_UShort* ClassValueArray; /* array of class values */ + HB_UShort StartGlyph; /* first glyph ID of the + ClassValueArray */ + HB_UShort GlyphCount; /* size of the ClassValueArray */ +}; + +typedef struct HB_ClassDefFormat1_ HB_ClassDefFormat1; + + +struct HB_ClassRangeRecord_ +{ + HB_UShort Start; /* first glyph ID in the range */ + HB_UShort End; /* last glyph ID in the range */ + HB_UShort Class; /* applied to all glyphs in range */ +}; + +typedef struct HB_ClassRangeRecord_ HB_ClassRangeRecord; + + +struct HB_ClassDefFormat2_ +{ + HB_ClassRangeRecord* ClassRangeRecord; + /* array of ClassRangeRecords */ + HB_UShort ClassRangeCount; + /* number of ClassRangeRecords */ +}; + +typedef struct HB_ClassDefFormat2_ HB_ClassDefFormat2; + + +struct HB_ClassDefinition_ +{ + union + { + HB_ClassDefFormat1 cd1; + HB_ClassDefFormat2 cd2; + } cd; + + HB_Byte ClassFormat; /* 1 or 2 */ + HB_Bool loaded; +}; + +typedef struct HB_ClassDefinition_ HB_ClassDefinition; + + +struct HB_Device_ +{ + HB_UShort* DeltaValue; /* array of compressed data */ + HB_UShort StartSize; /* smallest size to correct */ + HB_UShort EndSize; /* largest size to correct */ + HB_Byte DeltaFormat; /* DeltaValue array data format: + 1, 2, or 3 */ +}; + +typedef struct HB_Device_ HB_Device; + + +enum HB_Type_ +{ + HB_Type_GSUB, + HB_Type_GPOS +}; + +typedef enum HB_Type_ HB_Type; + +HB_END_HEADER + +#endif /* HARFBUZZ_OPEN_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-shape.h b/src/qt-harfbuzz/src/harfbuzz-shape.h new file mode 100644 index 0000000000..e4b5f9ad8a --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-shape.h @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2006 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Owen Taylor + */ + +#include + +/* Base Types */ + +typedef hb_uint16 HB_CodePoint; /* UTF-16 codepoint (not character ) */ +typedef char HB_Boolean; +typedef hb_uint32 HB_Fixed; /* 26.6 */ +typedef hb_uint32 HB_Glyph; +typedef hb_uint32 HB_Unichar; + +/* Metrics reported by the font backend for use of the shaper */ +typedef struct _HB_GlyphMetrics HB_GlyphMetrics; +struct _HB_GlyphMetrics +{ + HB_Fixed advance; + + /* Do we need ink/logical extents for the glyph here? */ +}; + +/* + * HB_Font: Abstract font interface. + * First pass of this might just have FT_Face *getFace(); + */ +typedef struct _HB_Font HB_Font; +typedef struct _HB_FontClass HB_FontClass; + +struct HB_FontClass { + HB_Glyph (*charToGlyph)(HB_Font *font, HB_Unichar chr); + void (*getMetrics)(HB_Font *font, HB_Glyph glyph, HB_GlyphMetrics *metrics); + HB_Boolean (*getSFontTable)(HB_Font *font, void **cookie, char **start, int *len); + HB_Boolean (*freeSFontTable)(void **cookie); +}; + +struct _HB_Font { + HB_FontClass *clazz; +}; + +/* + * Language tags, of the form en-us; represented as interned, canonicalized + * strings. hb_language_from_string("en_US"), hb_language_from_string("en-us") + * both return the same (pointer-comparable) HB_Language). + */ +typedef struct HB_Language_ *HB_Language; + +HB_Language hb_language_from_string(const char *str); +const char *hb_language_to_string(HB_Language language); + +/* Special treatment for the edges of runs. + */ +typedef enum { + HB_RUN_EDGE_LINE_VISUAL_EDGE = 1 << 0, + HB_RUN_EDGE_LINE_LOGICAL_EDGE = 1 << 1, + HB_RUN_EDGE_LINE_ADD_HYPHEN = 1 << 2 /* ???? */ +} HB_RunEdge; + +/* Defines optional informaiton in HB_ShapeInput; this allows extension + * of HB_ShapeInput while keeping binary compatibility + */ +typedef enum { + HB_SHAPE_START_TYPE = 1 << 0, + HB_SHAPE_END_TYPE = 1 << 1 +} HB_ShapeFlags; + +/* Attributes types are described by "interned strings"; this is a little + * annoying if you want to write a switch statement, but keeps things + * simple. + */ +typedef struct _HB_AttributeType *HB_AttributeType; + +HB_AttributeType hb_attribute_type_from_string(const char *str); +const char *hb_attribute_type_to_string(HB_AttributeType attribute_type); + +struct HB_Attribute { + HB_AttributeType type; + int start; + int end; +}; + + +/** + * You could handle this like HB_Language, but an enum seems a little nicer; + * another approach would be to use OpenType script tags. + */ +typedef enum { + HB_SCRIPT_LATIN + /* ... */ +} HB_ShapeScript; + +/* This is just the subset of direction information needed by the shaper */ +typedef enum { + HB_DIRECTION_LTR, + HB_DIRECTION_RTL, + HB_DIRECTION_TTB +} HB_Direction; + +typedef struct _HB_ShapeInput HB_ShapeInput; +struct _HB_ShapeInput { + /* Defines what fields the caller has initialized - fields not in + * the enum are mandatory. + */ + HB_ShapeFlags flags; + + HB_CodePoint *text; + int length; /* total length of text to shape */ + int shape_offset; /* start of section to shape */ + int shape_length; /* number of code points to shape */ + + HB_Direction direction; + HB_ShapeScript script; + HB_Language language; + + HB_AttributeType *attributes; + int n_attributes; + + HB_RunEdge start_type; + HB_RunEdge end_type; +}; + +struct HB_GlyphItem { + HB_Glyph glyph; + + HB_Fixed x_offset; + HB_Fixed y_offset; + HB_Fixed advance; + + /* Add kashida information, etc, here */ +}; + +typedef enum { + HB_RESULT_SUCCESS, + HB_RESULT_NO_MEMORY, + HB_SHAPE_RESULT_FAILED +} HB_Result; + +/* + * Buffer for output + */ +typedef struct _HB_GlyphBuffer HB_GlyphBuffer; +struct _HB_GlyphBuffer { + int glyph_item_size; + int total_glyphs; + + int *log_clusters; /* Uniscribe style */ + int cluster_space; + + int glyph_space; + void *glyph_buffer; +}; + +/* Making this self-allocating simplifies writing shapers and + * also keeps things easier for caller. item_size passed in + * must be at least sizeof(HB_GlyphItem) but can be bigger, + * to accomodate application structures that extend HB_GlyphItem. + * The allocated items will be zero-initialized. + * + * (Hack: Harfbuzz could choose to use even a *bigger* item size + * and stick internal information before the public item structure. + * This hack could possibly be used to unify this with HB_Buffer) + */ +HB_GlyphBuffer *hb_glyph_buffer_new (size_t item_size); +void hb_glyph_buffer_clear (HB_GlyphBuffer *buf); +HB_Result hb_glyph_buffer_extend_glyphs (HB_GlyphBuffer *buf, int n_items); +HB_Result hb_glyph_buffer_extend_clusters (HB_GlyphBuffer *buf, int n_clusters); +void hb_glyph_buffer_free (HB_GlyphBuffer *buf); + + +/* Accessor for a particular glyph */ +#define HB_GLYPH_BUFFER_ITEM(buffer, index) + +/* + * Main shaping function + */ +HB_Result hb_shape(HB_ShapeInput *input, HB_GlyphBuffer *output); diff --git a/src/qt-harfbuzz/src/harfbuzz-shaper-private.h b/src/qt-harfbuzz/src/harfbuzz-shaper-private.h new file mode 100644 index 0000000000..05214e7368 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-shaper-private.h @@ -0,0 +1,172 @@ +/* + * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_SHAPER_PRIVATE_H +#define HARFBUZZ_SHAPER_PRIVATE_H + +HB_BEGIN_HEADER + +enum { + C_DOTTED_CIRCLE = 0x25CC +}; + +typedef enum +{ + HB_Combining_BelowLeftAttached = 200, + HB_Combining_BelowAttached = 202, + HB_Combining_BelowRightAttached = 204, + HB_Combining_LeftAttached = 208, + HB_Combining_RightAttached = 210, + HB_Combining_AboveLeftAttached = 212, + HB_Combining_AboveAttached = 214, + HB_Combining_AboveRightAttached = 216, + + HB_Combining_BelowLeft = 218, + HB_Combining_Below = 220, + HB_Combining_BelowRight = 222, + HB_Combining_Left = 224, + HB_Combining_Right = 226, + HB_Combining_AboveLeft = 228, + HB_Combining_Above = 230, + HB_Combining_AboveRight = 232, + + HB_Combining_DoubleBelow = 233, + HB_Combining_DoubleAbove = 234, + HB_Combining_IotaSubscript = 240 +} HB_CombiningClass; + +typedef enum { + LocaProperty = 0x1, + CcmpProperty = 0x2, + InitProperty = 0x4, + IsolProperty = 0x8, + FinaProperty = 0x10, + MediProperty = 0x20, + RligProperty = 0x40, + CaltProperty = 0x80, + LigaProperty = 0x100, + DligProperty = 0x200, + CswhProperty = 0x400, + MsetProperty = 0x800, + + /* used by indic and myanmar shaper */ + NuktaProperty = 0x8, + AkhantProperty = 0x10, + RephProperty = 0x20, + PreFormProperty = 0x40, + BelowFormProperty = 0x80, + AboveFormProperty = 0x100, + HalfFormProperty = 0x200, + PostFormProperty = 0x400, + ConjunctFormProperty = 0x800, + VattuProperty = 0x1000, + PreSubstProperty = 0x2000, + BelowSubstProperty = 0x4000, + AboveSubstProperty = 0x8000, + PostSubstProperty = 0x10000, + HalantProperty = 0x20000, + CligProperty = 0x40000, + IndicCaltProperty = 0x80000 + +} HB_OpenTypeProperty; + +/* return true if ok. */ +typedef HB_Bool (*HB_ShapeFunction)(HB_ShaperItem *shaper_item); +typedef void (*HB_AttributeFunction)(HB_Script script, const HB_UChar16 *string, hb_uint32 from, hb_uint32 len, HB_CharAttributes *attributes); + +typedef struct { + HB_ShapeFunction shape; + HB_AttributeFunction charAttributes; +} HB_ScriptEngine; + +extern const HB_ScriptEngine hb_scriptEngines[]; + +extern HB_Bool HB_BasicShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_GreekShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_TibetanShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_HebrewShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_ArabicShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_HangulShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_MyanmarShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_KhmerShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_IndicShape(HB_ShaperItem *shaper_item); +extern HB_Bool HB_ThaiShape(HB_ShaperItem *shaper_item); + +extern void HB_TibetanAttributes(HB_Script script, const HB_UChar16 *string, hb_uint32 from, hb_uint32 len, HB_CharAttributes *attributes); + +extern void HB_MyanmarAttributes(HB_Script script, const HB_UChar16 *string, hb_uint32 from, hb_uint32 len, HB_CharAttributes *attributes); + +extern void HB_KhmerAttributes(HB_Script script, const HB_UChar16 *string, hb_uint32 from, hb_uint32 len, HB_CharAttributes *attributes); + +extern void HB_IndicAttributes(HB_Script script, const HB_UChar16 *string, hb_uint32 from, hb_uint32 len, HB_CharAttributes *attributes); + +extern void HB_ThaiAttributes(HB_Script script, const HB_UChar16 *string, hb_uint32 from, hb_uint32 len, HB_CharAttributes *attributes); + +typedef struct { + hb_uint32 tag; + hb_uint32 property; +} HB_OpenTypeFeature; + +#define PositioningProperties 0x80000000 + +HB_Bool HB_SelectScript(HB_ShaperItem *item, const HB_OpenTypeFeature *features); + +HB_Bool HB_OpenTypeShape(HB_ShaperItem *item, const hb_uint32 *properties); +HB_Bool HB_OpenTypePosition(HB_ShaperItem *item, int availableGlyphs, HB_Bool doLogClusters); + +void HB_HeuristicPosition(HB_ShaperItem *item); +void HB_HeuristicSetGlyphAttributes(HB_ShaperItem *item); + +#define HB_IsControlChar(uc) \ + ((uc >= 0x200b && uc <= 0x200f /* ZW Space, ZWNJ, ZWJ, LRM and RLM */) \ + || (uc >= 0x2028 && uc <= 0x202f /* LS, PS, LRE, RLE, PDF, LRO, RLO, NNBSP */) \ + || (uc >= 0x206a && uc <= 0x206f /* ISS, ASS, IAFS, AFS, NADS, NODS */)) + +HB_Bool HB_ConvertStringToGlyphIndices(HB_ShaperItem *shaper_item); + +#define HB_GetGlyphAdvances(shaper_item) \ + shaper_item->font->klass->getGlyphAdvances(shaper_item->font, \ + shaper_item->glyphs, shaper_item->num_glyphs, \ + shaper_item->advances, \ + shaper_item->face->current_flags); + +#define HB_DECLARE_STACKARRAY(Type, Name) \ + Type stack##Name[512]; \ + Type *Name = stack##Name; + +#define HB_INIT_STACKARRAY(Type, Name, Length) \ + if ((Length) >= 512) \ + Name = (Type *)malloc((Length) * sizeof(Type)); + +#define HB_STACKARRAY(Type, Name, Length) \ + HB_DECLARE_STACKARRAY(Type, Name) \ + HB_INIT_STACKARRAY(Type, Name, Length) + +#define HB_FREE_STACKARRAY(Name) \ + if (stack##Name != Name) \ + free(Name); + +HB_END_HEADER + +#endif diff --git a/src/qt-harfbuzz/src/harfbuzz-shaper.h b/src/qt-harfbuzz/src/harfbuzz-shaper.h new file mode 100644 index 0000000000..b3f5226423 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-shaper.h @@ -0,0 +1,287 @@ +/* + * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_SHAPER_H +#define HARFBUZZ_SHAPER_H + +#include "harfbuzz-global.h" +#include "harfbuzz-gdef.h" +#include "harfbuzz-gpos.h" +#include "harfbuzz-gsub.h" +#include "harfbuzz-external.h" +#include "harfbuzz-stream-private.h" + +HB_BEGIN_HEADER + +/* + using anything else than signed or unsigned for bitfields in C is non standard, + but accepted by almost all compilers. And it gives a significant reduction in + memory consumption as HB_CharAttributes and HB_GlyphAttributes will not have + a 4 byte alignment +*/ +#ifdef __xlC__ +typedef unsigned hb_bitfield; +#else +typedef hb_uint8 hb_bitfield; +#endif + +typedef enum { + HB_Script_Common, + HB_Script_Greek, + HB_Script_Cyrillic, + HB_Script_Armenian, + HB_Script_Hebrew, + HB_Script_Arabic, + HB_Script_Syriac, + HB_Script_Thaana, + HB_Script_Devanagari, + HB_Script_Bengali, + HB_Script_Gurmukhi, + HB_Script_Gujarati, + HB_Script_Oriya, + HB_Script_Tamil, + HB_Script_Telugu, + HB_Script_Kannada, + HB_Script_Malayalam, + HB_Script_Sinhala, + HB_Script_Thai, + HB_Script_Lao, + HB_Script_Tibetan, + HB_Script_Myanmar, + HB_Script_Georgian, + HB_Script_Hangul, + HB_Script_Ogham, + HB_Script_Runic, + HB_Script_Khmer, + HB_Script_Nko, + HB_Script_Inherited, + HB_ScriptCount = HB_Script_Inherited + /* + HB_Script_Latin = Common, + HB_Script_Ethiopic = Common, + HB_Script_Cherokee = Common, + HB_Script_CanadianAboriginal = Common, + HB_Script_Mongolian = Common, + HB_Script_Hiragana = Common, + HB_Script_Katakana = Common, + HB_Script_Bopomofo = Common, + HB_Script_Han = Common, + HB_Script_Yi = Common, + HB_Script_OldItalic = Common, + HB_Script_Gothic = Common, + HB_Script_Deseret = Common, + HB_Script_Tagalog = Common, + HB_Script_Hanunoo = Common, + HB_Script_Buhid = Common, + HB_Script_Tagbanwa = Common, + HB_Script_Limbu = Common, + HB_Script_TaiLe = Common, + HB_Script_LinearB = Common, + HB_Script_Ugaritic = Common, + HB_Script_Shavian = Common, + HB_Script_Osmanya = Common, + HB_Script_Cypriot = Common, + HB_Script_Braille = Common, + HB_Script_Buginese = Common, + HB_Script_Coptic = Common, + HB_Script_NewTaiLue = Common, + HB_Script_Glagolitic = Common, + HB_Script_Tifinagh = Common, + HB_Script_SylotiNagri = Common, + HB_Script_OldPersian = Common, + HB_Script_Kharoshthi = Common, + HB_Script_Balinese = Common, + HB_Script_Cuneiform = Common, + HB_Script_Phoenician = Common, + HB_Script_PhagsPa = Common, + */ +} HB_Script; + +typedef struct +{ + hb_uint32 pos; + hb_uint32 length; + HB_Script script; + hb_uint8 bidiLevel; +} HB_ScriptItem; + +typedef enum { + HB_NoBreak, + HB_SoftHyphen, + HB_Break, + HB_ForcedBreak +} HB_LineBreakType; + + +typedef struct { + /*HB_LineBreakType*/ hb_bitfield lineBreakType :2; + /*HB_Bool*/ hb_bitfield whiteSpace :1; /* A unicode whitespace character, except NBSP, ZWNBSP */ + /*HB_Bool*/ hb_bitfield charStop :1; /* Valid cursor position (for left/right arrow) */ + /*HB_Bool*/ hb_bitfield wordBoundary :1; + /*HB_Bool*/ hb_bitfield sentenceBoundary :1; + hb_bitfield unused :2; +} HB_CharAttributes; + +void HB_GetCharAttributes(const HB_UChar16 *string, hb_uint32 stringLength, + const HB_ScriptItem *items, hb_uint32 numItems, + HB_CharAttributes *attributes); + +/* requires HB_GetCharAttributes to be called before */ +void HB_GetWordBoundaries(const HB_UChar16 *string, hb_uint32 stringLength, + const HB_ScriptItem *items, hb_uint32 numItems, + HB_CharAttributes *attributes); + +/* requires HB_GetCharAttributes to be called before */ +void HB_GetSentenceBoundaries(const HB_UChar16 *string, hb_uint32 stringLength, + const HB_ScriptItem *items, hb_uint32 numItems, + HB_CharAttributes *attributes); + + +typedef enum { + HB_LeftToRight = 0, + HB_RightToLeft = 1 +} HB_StringToGlyphsFlags; + +typedef enum { + HB_ShaperFlag_Default = 0, + HB_ShaperFlag_NoKerning = 1, + HB_ShaperFlag_UseDesignMetrics = 2 +} HB_ShaperFlag; + +/* + highest value means highest priority for justification. Justification is done by first inserting kashidas + starting with the highest priority positions, then stretching spaces, afterwards extending inter char + spacing, and last spacing between arabic words. + NoJustification is for example set for arabic where no Kashida can be inserted or for diacritics. +*/ +typedef enum { + HB_NoJustification= 0, /* Justification can't be applied after this glyph */ + HB_Arabic_Space = 1, /* This glyph represents a space inside arabic text */ + HB_Character = 2, /* Inter-character justification point follows this glyph */ + HB_Space = 4, /* This glyph represents a blank outside an Arabic run */ + HB_Arabic_Normal = 7, /* Normal Middle-Of-Word glyph that connects to the right (begin) */ + HB_Arabic_Waw = 8, /* Next character is final form of Waw/Ain/Qaf/Fa */ + HB_Arabic_BaRa = 9, /* Next two chars are Ba + Ra/Ya/AlefMaksura */ + HB_Arabic_Alef = 10, /* Next character is final form of Alef/Tah/Lam/Kaf/Gaf */ + HB_Arabic_HaaDal = 11, /* Next character is final form of Haa/Dal/Taa Marbutah */ + HB_Arabic_Seen = 12, /* Initial or Medial form Of Seen/Sad */ + HB_Arabic_Kashida = 13 /* Kashida(U+640) in middle of word */ +} HB_JustificationClass; + +/* This structure is binary compatible with Uniscribe's SCRIPT_VISATTR. Would be nice to keep + * it like that. If this is a problem please tell Trolltech :) + */ +typedef struct { + hb_bitfield justification :4; /* Justification class */ + hb_bitfield clusterStart :1; /* First glyph of representation of cluster */ + hb_bitfield mark :1; /* needs to be positioned around base char */ + hb_bitfield zeroWidth :1; /* ZWJ, ZWNJ etc, with no width */ + hb_bitfield dontPrint :1; + hb_bitfield combiningClass :8; +} HB_GlyphAttributes; + +typedef struct HB_FaceRec_ { + HB_Bool isSymbolFont; + + HB_GDEF gdef; + HB_GSUB gsub; + HB_GPOS gpos; + HB_Bool supported_scripts[HB_ScriptCount]; + HB_Buffer buffer; + HB_Script current_script; + int current_flags; /* HB_ShaperFlags */ + HB_Bool has_opentype_kerning; + HB_Bool glyphs_substituted; + HB_GlyphAttributes *tmpAttributes; + unsigned int *tmpLogClusters; + int length; + int orig_nglyphs; +} HB_FaceRec; + +typedef HB_Error (*HB_GetFontTableFunc)(void *font, HB_Tag tag, HB_Byte *buffer, HB_UInt *length); + +HB_Face HB_NewFace(void *font, HB_GetFontTableFunc tableFunc); +void HB_FreeFace(HB_Face face); + +typedef struct { + HB_Fixed x, y; + HB_Fixed width, height; + HB_Fixed xOffset, yOffset; +} HB_GlyphMetrics; + +typedef enum { + HB_FontAscent, + HB_FontDescent +} HB_FontMetric; + +typedef struct { + HB_Bool (*convertStringToGlyphIndices)(HB_Font font, const HB_UChar16 *string, hb_uint32 length, HB_Glyph *glyphs, hb_uint32 *numGlyphs, HB_Bool rightToLeft); + void (*getGlyphAdvances)(HB_Font font, const HB_Glyph *glyphs, hb_uint32 numGlyphs, HB_Fixed *advances, int flags /*HB_ShaperFlag*/); + HB_Bool (*canRender)(HB_Font font, const HB_UChar16 *string, hb_uint32 length); + /* implementation needs to make sure to load a scaled glyph, so /no/ FT_LOAD_NO_SCALE */ + HB_Error (*getPointInOutline)(HB_Font font, HB_Glyph glyph, int flags /*HB_ShaperFlag*/, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints); + void (*getGlyphMetrics)(HB_Font font, HB_Glyph glyph, HB_GlyphMetrics *metrics); + HB_Fixed (*getFontMetric)(HB_Font font, HB_FontMetric metric); +} HB_FontClass; + +typedef struct HB_Font_ { + const HB_FontClass *klass; + + /* Metrics */ + HB_UShort x_ppem, y_ppem; + HB_16Dot16 x_scale, y_scale; + + void *userData; +} HB_FontRec; + +typedef struct HB_ShaperItem_ HB_ShaperItem; + +struct HB_ShaperItem_ { + const HB_UChar16 *string; /* input: the Unicode UTF16 text to be shaped */ + hb_uint32 stringLength; /* input: the length of the input in 16-bit words */ + HB_ScriptItem item; /* input: the current run to be shaped: a run of text all in the same script that is a substring of */ + HB_Font font; /* input: the font: scale, units and function pointers supplying glyph indices and metrics */ + HB_Face face; /* input: the shaper state; current script, access to the OpenType tables , etc. */ + int shaperFlags; /* input (unused) should be set to 0; intended to support flags defined in HB_ShaperFlag */ + HB_Bool glyphIndicesPresent; /* input: true if the array contains glyph indices ready to be shaped */ + hb_uint32 initialGlyphCount; /* input: if glyphIndicesPresent is true, the number of glyph indices in the array */ + + hb_uint32 num_glyphs; /* input: capacity of output arrays , , , , and ; */ + /* output: required capacity (may be larger than actual capacity) */ + + HB_Glyph *glyphs; /* output: indices of shaped glyphs */ + HB_GlyphAttributes *attributes; /* output: glyph attributes */ + HB_Fixed *advances; /* output: advances */ + HB_FixedPoint *offsets; /* output: offsets */ + unsigned short *log_clusters; /* output: for each output glyph, the index in the input of the start of its logical cluster */ + + /* internal */ + HB_Bool kerning_applied; /* output: true if kerning was applied by the shaper */ +}; + +HB_Bool HB_ShapeItem(HB_ShaperItem *item); + +HB_END_HEADER + +#endif diff --git a/src/qt-harfbuzz/src/harfbuzz-stream-private.h b/src/qt-harfbuzz/src/harfbuzz-stream-private.h new file mode 100644 index 0000000000..fbd9f81379 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-stream-private.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_STREAM_PRIVATE_H +#define HARFBUZZ_STREAM_PRIVATE_H + +#include "harfbuzz-impl.h" +#include "harfbuzz-stream.h" + +HB_BEGIN_HEADER + +HB_INTERNAL void +_hb_close_stream( HB_Stream stream ); + +HB_INTERNAL HB_Int +_hb_stream_pos( HB_Stream stream ); + +HB_INTERNAL HB_Error +_hb_stream_seek( HB_Stream stream, + HB_UInt pos ); + +HB_INTERNAL HB_Error +_hb_stream_frame_enter( HB_Stream stream, + HB_UInt size ); + +HB_INTERNAL void +_hb_stream_frame_exit( HB_Stream stream ); + +/* convenience macros */ + +#define SET_ERR(c) ( (error = (c)) != 0 ) + +#define GOTO_Table(tag) (0) +#define FILE_Pos() _hb_stream_pos( stream ) +#define FILE_Seek(pos) SET_ERR( _hb_stream_seek( stream, pos ) ) +#define ACCESS_Frame(size) SET_ERR( _hb_stream_frame_enter( stream, size ) ) +#define FORGET_Frame() _hb_stream_frame_exit( stream ) + +#define GET_Byte() (*stream->cursor++) +#define GET_Short() (stream->cursor += 2, (HB_Short)( \ + (*(((HB_Byte*)stream->cursor)-2) << 8) | \ + *(((HB_Byte*)stream->cursor)-1) \ + )) +#define GET_Long() (stream->cursor += 4, (HB_Int)( \ + (*(((HB_Byte*)stream->cursor)-4) << 24) | \ + (*(((HB_Byte*)stream->cursor)-3) << 16) | \ + (*(((HB_Byte*)stream->cursor)-2) << 8) | \ + *(((HB_Byte*)stream->cursor)-1) \ + )) + + +#define GET_Char() ((HB_Char)GET_Byte()) +#define GET_UShort() ((HB_UShort)GET_Short()) +#define GET_ULong() ((HB_UInt)GET_Long()) +#define GET_Tag4() GET_ULong() + +HB_END_HEADER + +#endif /* HARFBUZZ_STREAM_PRIVATE_H */ diff --git a/src/qt-harfbuzz/src/harfbuzz-stream.h b/src/qt-harfbuzz/src/harfbuzz-stream.h new file mode 100644 index 0000000000..cfbfb1c4fe --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz-stream.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2005 David Turner + * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_STREAM_H +#define HARFBUZZ_STREAM_H + +#include "harfbuzz-global.h" + +HB_BEGIN_HEADER + +typedef struct HB_StreamRec_ +{ + HB_Byte* base; + HB_Byte* cursor; + HB_UInt size; + HB_UInt pos; +} HB_StreamRec; + +HB_END_HEADER + +#endif diff --git a/src/qt-harfbuzz/src/harfbuzz.h b/src/qt-harfbuzz/src/harfbuzz.h new file mode 100644 index 0000000000..e91a33eb71 --- /dev/null +++ b/src/qt-harfbuzz/src/harfbuzz.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 1998-2004 David Turner and Werner Lemberg + * Copyright (C) 2006 Behdad Esfahbod + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifndef HARFBUZZ_H +#define HARFBUZZ_H + +#include "harfbuzz-external.h" +#include "harfbuzz-global.h" +#include "harfbuzz-buffer.h" +#include "harfbuzz-gdef.h" +#include "harfbuzz-gsub.h" +#include "harfbuzz-gpos.h" +#include "harfbuzz-open.h" +#include "harfbuzz-shaper.h" + +#endif /* HARFBUZZ_OPEN_H */