dwrite_private.h File Reference

#include "dwrite_3.h"
#include "d2d1.h"
#include "winternl.h"
#include "wine/debug.h"
#include "wine/list.h"
#include "wine/rbtree.h"

Include dependency graph for dwrite_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MATRIX_2X2
struct	textlayout_desc
struct	glyphrunanalysis_desc
struct	fontface_desc
struct	dwrite_fonttable
struct	fontfacecached
struct	dwrite_cmap
struct	dwrite_fontface
struct	dwrite_textformat_data
struct	dwrite_textformat
struct	dwrite_font_props
struct	file_stream_desc
struct	tag_array
struct	ot_gsubgpos_table
struct	dwrite_var_axis
struct	dwrite_colorglyph
struct	bidi_char
struct	dwrite_glyphbitmap
struct	dwrite_outline
struct	scriptshaping_cache
struct	shaping_glyph_info
struct	shaping_glyph_properties
struct	shaping_feature
struct	shaping_stage
struct	shaping_features
struct	shaper
struct	scriptshaping_context
struct	shaping_font_ops

Macros
#define	MS_GSUB_TAG   DWRITE_MAKE_OPENTYPE_TAG('G','S','U','B')
#define	MS_GPOS_TAG   DWRITE_MAKE_OPENTYPE_TAG('G','P','O','S')
#define	GLYPH_BLOCK_SHIFT   8
#define	GLYPH_BLOCK_SIZE   (1UL << GLYPH_BLOCK_SHIFT)
#define	GLYPH_BLOCK_MASK   (GLYPH_BLOCK_SIZE - 1)
#define	GLYPH_MAX   65536
#define	MAX_SHAPING_STAGE   16

Typedefs
typedef struct MATRIX_2X2	MATRIX_2X2
typedef UINT16(*	p_cmap_get_glyph_func) (const struct dwrite_cmap *cmap, unsigned int ch)
typedef unsigned int(*	p_cmap_get_ranges_func) (const struct dwrite_cmap *cmap, unsigned int max_count, DWRITE_UNICODE_RANGE *ranges)
typedef UINT64(*	p_dwrite_fontface_get_font_object) (struct dwrite_fontface *fontface)
typedef void(*	p_apply_context_lookup) (struct scriptshaping_context *context, unsigned int lookup_index)
typedef void(*	stage_func) (struct scriptshaping_context *context, const struct shaping_features *features)

Enumerations
enum	font_flags {   FONT_IS_SYMBOL = 0x00000001 , FONT_IS_MONOSPACED = 0x00000002 , FONT_IS_COLORED = 0x00000004 , FONTFACE_KERNING_PAIRS = 0x00000008 ,   FONTFACE_NO_KERNING_PAIRS = 0x00000010 , FONTFACE_VERTICAL_VARIANTS = 0x00000020 , FONTFACE_NO_VERTICAL_VARIANTS = 0x00000040 }
enum	gasp_flags { GASP_GRIDFIT = 0x0001 , GASP_DOGRAY = 0x0002 , GASP_SYMMETRIC_GRIDFIT = 0x0004 , GASP_SYMMETRIC_SMOOTHING = 0x0008 }
enum	dwrite_outline_tags { OUTLINE_BEGIN_FIGURE , OUTLINE_END_FIGURE , OUTLINE_LINE , OUTLINE_BEZIER }
enum	SCRIPT_JUSTIFY {   SCRIPT_JUSTIFY_NONE , SCRIPT_JUSTIFY_ARABIC_BLANK , SCRIPT_JUSTIFY_CHARACTER , SCRIPT_JUSTIFY_RESERVED1 ,   SCRIPT_JUSTIFY_BLANK , SCRIPT_JUSTIFY_RESERVED2 , SCRIPT_JUSTIFY_RESERVED3 , SCRIPT_JUSTIFY_ARABIC_NORMAL ,   SCRIPT_JUSTIFY_ARABIC_KASHIDA , SCRIPT_JUSTIFY_ARABIC_ALEF , SCRIPT_JUSTIFY_ARABIC_HA , SCRIPT_JUSTIFY_ARABIC_RA ,   SCRIPT_JUSTIFY_ARABIC_BA , SCRIPT_JUSTIFY_ARABIC_BARA , SCRIPT_JUSTIFY_ARABIC_SEEN , SCRIPT_JUSTIFY_ARABIC_SEEN_M }
enum	shaping_feature_flags {   FEATURE_GLOBAL = 0x1 , FEATURE_GLOBAL_SEARCH = 0x2 , FEATURE_MANUAL_ZWNJ = 0x4 , FEATURE_MANUAL_ZWJ = 0x8 ,   FEATURE_MANUAL_JOINERS = FEATURE_MANUAL_ZWNJ | FEATURE_MANUAL_ZWJ , FEATURE_HAS_FALLBACK = 0x10 , FEATURE_NEEDS_FALLBACK = 0x20 }

Functions
static LPWSTR	heap_strdupnW (const WCHAR *str, UINT32 len)
static const char *	debugstr_range (const DWRITE_TEXT_RANGE *range)
static const char *	debugstr_matrix (const DWRITE_MATRIX *m)
static BOOL	dwrite_array_reserve (void **elements, size_t *capacity, size_t count, size_t size)
const char *	debugstr_sa_script (UINT16)
static unsigned short	get_table_entry_16 (const unsigned short *table, WCHAR ch)
static unsigned short	get_table_entry_32 (const unsigned short *table, UINT ch)
static BOOL	is_simulation_valid (DWRITE_FONT_SIMULATIONS simulations)
static void	dwrite_matrix_multiply (DWRITE_MATRIX *a, const DWRITE_MATRIX *b)
void	dwrite_cmap_init (struct dwrite_cmap *cmap, IDWriteFontFile *file, unsigned int face_index, DWRITE_FONT_FACE_TYPE face_type)
void	dwrite_cmap_release (struct dwrite_cmap *cmap)
UINT16	opentype_cmap_get_glyph (const struct dwrite_cmap *cmap, unsigned int ch)
HRESULT	opentype_cmap_get_unicode_ranges (const struct dwrite_cmap *cmap, unsigned int max_count, DWRITE_UNICODE_RANGE *ranges, unsigned int *count)
HRESULT	create_numbersubstitution (DWRITE_NUMBER_SUBSTITUTION_METHOD, const WCHAR *locale, BOOL, IDWriteNumberSubstitution **)
HRESULT	create_text_format (const WCHAR *family_name, IDWriteFontCollection *collection, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style, DWRITE_FONT_STRETCH stretch, float size, const WCHAR *locale, REFIID riid, void **out)
HRESULT	create_textlayout (const struct textlayout_desc *, IDWriteTextLayout **)
HRESULT	create_trimmingsign (IDWriteFactory7 *factory, IDWriteTextFormat *format, IDWriteInlineObject **sign)
HRESULT	create_typography (IDWriteTypography **)
HRESULT	create_localizedstrings (IDWriteLocalizedStrings **)
HRESULT	add_localizedstring (IDWriteLocalizedStrings *, const WCHAR *, const WCHAR *)
HRESULT	clone_localizedstrings (IDWriteLocalizedStrings *iface, IDWriteLocalizedStrings **strings)
void	set_en_localizedstring (IDWriteLocalizedStrings *, const WCHAR *)
void	sort_localizedstrings (IDWriteLocalizedStrings *)
unsigned int	get_localizedstrings_count (IDWriteLocalizedStrings *strings)
BOOL	localizedstrings_contains (IDWriteLocalizedStrings *strings, const WCHAR *str)
HRESULT	get_system_fontcollection (IDWriteFactory7 *factory, DWRITE_FONT_FAMILY_MODEL family_model, IDWriteFontCollection **collection)
HRESULT	get_eudc_fontcollection (IDWriteFactory7 *factory, IDWriteFontCollection3 **collection)
IDWriteTextAnalyzer2 *	get_text_analyzer (void)
HRESULT	create_font_file (IDWriteFontFileLoader *loader, const void *reference_key, UINT32 key_size, IDWriteFontFile **font_file)
void	init_local_fontfile_loader (void)
IDWriteFontFileLoader *	get_local_fontfile_loader (void)
HRESULT	create_fontface (const struct fontface_desc *desc, struct list *cached_list, IDWriteFontFace5 **fontface)
HRESULT	create_font_collection (IDWriteFactory7 *factory, IDWriteFontFileEnumerator *enumerator, BOOL is_system, IDWriteFontCollection3 **collection)
HRESULT	create_glyphrunanalysis (const struct glyphrunanalysis_desc *, IDWriteGlyphRunAnalysis **)
BOOL	is_system_collection (IDWriteFontCollection *)
HRESULT	get_local_refkey (const WCHAR *, const FILETIME *, void **, UINT32 *)
HRESULT	get_filestream_from_file (IDWriteFontFile *, IDWriteFontFileStream **)
BOOL	is_face_type_supported (DWRITE_FONT_FACE_TYPE)
HRESULT	get_family_names_from_stream (IDWriteFontFileStream *, UINT32, DWRITE_FONT_FACE_TYPE, IDWriteLocalizedStrings **)
HRESULT	create_colorglyphenum (D2D1_POINT_2F origin, const DWRITE_GLYPH_RUN *run, const DWRITE_GLYPH_RUN_DESCRIPTION *desc, DWRITE_GLYPH_IMAGE_FORMATS formats, DWRITE_MEASURING_MODE mode, const DWRITE_MATRIX *transform, UINT32 palette, IDWriteColorGlyphRunEnumerator1 **enumerator)
BOOL	lb_is_newline_char (WCHAR)
HRESULT	create_system_fontfallback (IDWriteFactory7 *factory, IDWriteFontFallback1 **fallback)
void	release_system_fontfallback (IDWriteFontFallback1 *fallback)
void	release_system_fallback_data (void)
HRESULT	create_fontfallback_builder (IDWriteFactory7 *factory, IDWriteFontFallbackBuilder **builder)
HRESULT	create_matching_font (IDWriteFontCollection *collection, const WCHAR *family, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style, DWRITE_FONT_STRETCH stretch, REFIID riid, void **obj)
HRESULT	create_fontfacereference (IDWriteFactory7 *factory, IDWriteFontFile *file, UINT32 face_index, DWRITE_FONT_SIMULATIONS simulations, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 axis_values_count, IDWriteFontFaceReference1 **reference)
HRESULT	factory_get_cached_fontface (IDWriteFactory7 *factory, IDWriteFontFile *const *files, UINT32 num_files, DWRITE_FONT_SIMULATIONS simulations, struct list **cache, REFIID riid, void **obj)
void	factory_detach_fontcollection (IDWriteFactory7 *factory, IDWriteFontCollection3 *collection)
void	factory_detach_gdiinterop (IDWriteFactory7 *factory, IDWriteGdiInterop1 *interop)
struct fontfacecached *	factory_cache_fontface (IDWriteFactory7 *factory, struct list *fontfaces, IDWriteFontFace5 *fontface)
void	get_logfont_from_font (IDWriteFont *, LOGFONTW *)
void	get_logfont_from_fontface (IDWriteFontFace *, LOGFONTW *)
HRESULT	get_fontsig_from_font (IDWriteFont *, FONTSIGNATURE *)
HRESULT	get_fontsig_from_fontface (IDWriteFontFace *, FONTSIGNATURE *)
HRESULT	create_gdiinterop (IDWriteFactory7 *factory, IDWriteGdiInterop1 **interop)
void	fontface_detach_from_cache (IDWriteFontFace5 *fontface)
void	factory_lock (IDWriteFactory7 *factory)
void	factory_unlock (IDWriteFactory7 *factory)
HRESULT	create_inmemory_fileloader (IDWriteInMemoryFontFileLoader **loader)
HRESULT	create_font_resource (IDWriteFactory7 *factory, IDWriteFontFile *file, UINT32 face_index, IDWriteFontResource **resource)
HRESULT	create_fontset_builder (IDWriteFactory7 *factory, IDWriteFontSetBuilder2 **ret)
HRESULT	compute_glyph_origins (DWRITE_GLYPH_RUN const *run, DWRITE_MEASURING_MODE measuring_mode, D2D1_POINT_2F baseline_origin, DWRITE_MATRIX const *transform, D2D1_POINT_2F *origins)
HRESULT	create_font_collection_from_set (IDWriteFactory7 *factory, IDWriteFontSet *set, DWRITE_FONT_FAMILY_MODEL family_model, REFGUID riid, void **ret)
HRESULT	create_system_fontset (IDWriteFactory7 *factory, REFIID riid, void **obj)
float	fontface_get_scaled_design_advance (struct dwrite_fontface *fontface, DWRITE_MEASURING_MODE measuring_mode, float emsize, float ppdip, const DWRITE_MATRIX *transform, UINT16 glyph, BOOL is_sideways)
struct dwrite_fontface *	unsafe_impl_from_IDWriteFontFace (IDWriteFontFace *iface)
struct dwrite_textformat *	unsafe_impl_from_IDWriteTextFormat (IDWriteTextFormat *iface)
void	release_format_data (struct dwrite_textformat_data *data)
HRESULT	format_set_vertical_orientation (struct dwrite_textformat_data *format, DWRITE_VERTICAL_GLYPH_ORIENTATION orientation, BOOL *changed)
HRESULT	format_set_fontfallback (struct dwrite_textformat_data *format, IDWriteFontFallback *fallback)
HRESULT	format_get_fontfallback (const struct dwrite_textformat_data *format, IDWriteFontFallback **fallback)
HRESULT	format_set_font_axisvalues (struct dwrite_textformat_data *format, DWRITE_FONT_AXIS_VALUE const *axis_values, unsigned int num_values)
HRESULT	format_get_font_axisvalues (struct dwrite_textformat_data *format, DWRITE_FONT_AXIS_VALUE *axis_values, unsigned int num_values)
HRESULT	format_set_optical_alignment (struct dwrite_textformat_data *format, DWRITE_OPTICAL_ALIGNMENT alignment)
HRESULT	format_set_trimming (struct dwrite_textformat_data *format, DWRITE_TRIMMING const *trimming, IDWriteInlineObject *trimming_sign, BOOL *changed)
HRESULT	format_set_flowdirection (struct dwrite_textformat_data *format, DWRITE_FLOW_DIRECTION direction, BOOL *changed)
HRESULT	format_set_readingdirection (struct dwrite_textformat_data *format, DWRITE_READING_DIRECTION direction, BOOL *changed)
HRESULT	format_set_wordwrapping (struct dwrite_textformat_data *format, DWRITE_WORD_WRAPPING wrapping, BOOL *changed)
HRESULT	format_set_paralignment (struct dwrite_textformat_data *format, DWRITE_PARAGRAPH_ALIGNMENT alignment, BOOL *changed)
HRESULT	format_set_textalignment (struct dwrite_textformat_data *format, DWRITE_TEXT_ALIGNMENT alignment, BOOL *changed)
HRESULT	format_set_linespacing (struct dwrite_textformat_data *format, DWRITE_LINE_SPACING const *spacing, BOOL *changed)
const void *	get_fontface_table (IDWriteFontFace5 *fontface, UINT32 tag, struct dwrite_fonttable *table)
HRESULT	opentype_analyze_font (IDWriteFontFileStream *, BOOL *, DWRITE_FONT_FILE_TYPE *, DWRITE_FONT_FACE_TYPE *, UINT32 *)
HRESULT	opentype_try_get_font_table (const struct file_stream_desc *stream_desc, UINT32 tag, const void **data, void **context, UINT32 *size, BOOL *exists)
void	opentype_get_font_properties (const struct file_stream_desc *stream_desc, struct dwrite_font_props *props)
void	opentype_get_font_metrics (struct file_stream_desc *, DWRITE_FONT_METRICS1 *, DWRITE_CARET_METRICS *)
void	opentype_get_font_typo_metrics (struct file_stream_desc *stream_desc, unsigned int *ascent, unsigned int *descent)
HRESULT	opentype_get_font_info_strings (const struct file_stream_desc *stream_desc, DWRITE_INFORMATIONAL_STRING_ID id, IDWriteLocalizedStrings **strings)
HRESULT	opentype_get_font_familyname (const struct file_stream_desc *desc, DWRITE_FONT_FAMILY_MODEL family_model, IDWriteLocalizedStrings **names)
HRESULT	opentype_get_font_facename (struct file_stream_desc *, WCHAR *, IDWriteLocalizedStrings **)
void	opentype_get_typographic_features (struct ot_gsubgpos_table *table, unsigned int script_index, unsigned int language_index, struct tag_array *tags)
BOOL	opentype_get_vdmx_size (const struct dwrite_fonttable *table, INT ppem, UINT16 *ascent, UINT16 *descent)
unsigned int	opentype_get_cpal_palettecount (const struct dwrite_fonttable *table)
unsigned int	opentype_get_cpal_paletteentrycount (const struct dwrite_fonttable *table)
HRESULT	opentype_get_cpal_entries (const struct dwrite_fonttable *table, unsigned int palette, unsigned int first_entry_index, unsigned int entry_count, DWRITE_COLOR_F *entries)
UINT32	opentype_get_glyph_image_formats (IDWriteFontFace5 *fontface)
DWRITE_CONTAINER_TYPE	opentype_analyze_container_type (void const *, UINT32)
HRESULT	opentype_get_kerning_pairs (struct dwrite_fontface *fontface, unsigned int count, const UINT16 *glyphs, INT32 *values)
BOOL	opentype_has_kerning_pairs (struct dwrite_fontface *fontface)
HRESULT	opentype_get_font_var_axis (const struct file_stream_desc *stream_desc, struct dwrite_var_axis **axis, unsigned int *axis_count)
HRESULT	opentype_get_colr_glyph (const struct dwrite_fonttable *table, UINT16 glyph, struct dwrite_colorglyph *color_glyph)
void	opentype_colr_next_glyph (const struct dwrite_fonttable *table, struct dwrite_colorglyph *color_glyph)
unsigned int	opentype_get_gasp_flags (const struct dwrite_fonttable *gasp, float emsize)
HRESULT	bidi_computelevels (struct bidi_char *chars, unsigned int count, UINT8 baselevel)
void	shape_enable_feature (struct shaping_features *features, unsigned int tag, unsigned int flags)
void	shape_add_feature_full (struct shaping_features *features, unsigned int tag, unsigned int flags, unsigned int value)
unsigned int	shape_get_feature_1_mask (const struct shaping_features *features, unsigned int tag)
void	shape_start_next_stage (struct shaping_features *features, stage_func func)
struct scriptshaping_cache *	create_scriptshaping_cache (void *context, const struct shaping_font_ops *font_ops)
void	release_scriptshaping_cache (struct scriptshaping_cache *)
struct scriptshaping_cache *	fontface_get_shaping_cache (struct dwrite_fontface *fontface)
void	opentype_layout_scriptshaping_cache_init (struct scriptshaping_cache *cache)
unsigned int	opentype_layout_find_script (const struct scriptshaping_cache *cache, unsigned int kind, DWORD tag, unsigned int *script_index)
unsigned int	opentype_layout_find_language (const struct scriptshaping_cache *cache, unsigned int kind, DWORD tag, unsigned int script_index, unsigned int *language_index)
void	opentype_layout_apply_gsub_features (struct scriptshaping_context *context, unsigned int script_index, unsigned int language_index, struct shaping_features *features)
void	opentype_layout_apply_gpos_features (struct scriptshaping_context *context, unsigned int script_index, unsigned int language_index, struct shaping_features *features)
BOOL	opentype_layout_check_feature (struct scriptshaping_context *context, unsigned int script_index, unsigned int language_index, struct shaping_feature *feature, unsigned int glyph_count, const UINT16 *glyphs, UINT8 *feature_applies)
void	opentype_layout_unsafe_to_break (struct scriptshaping_context *context, unsigned int start, unsigned int end)
BOOL	opentype_has_vertical_variants (struct dwrite_fontface *fontface)
HRESULT	opentype_get_vertical_glyph_variants (struct dwrite_fontface *fontface, unsigned int glyph_count, const UINT16 *nominal_glyphs, UINT16 *glyphs)
HRESULT	shape_get_glyphs (struct scriptshaping_context *context, const unsigned int *scripts)
HRESULT	shape_get_positions (struct scriptshaping_context *context, const unsigned int *scripts)
HRESULT	shape_get_typographic_features (struct scriptshaping_context *context, const unsigned int *scripts, unsigned int max_tagcount, unsigned int *actual_tagcount, DWRITE_FONT_FEATURE_TAG *tags)
HRESULT	shape_check_typographic_feature (struct scriptshaping_context *context, const unsigned int *scripts, unsigned int tag, unsigned int glyph_count, const UINT16 *glyphs, UINT8 *feature_applies)
void	dwrite_fontface_get_glyph_bbox (IDWriteFontFace *fontface, struct dwrite_glyphbitmap *bitmap)

Variables
static const DWRITE_MATRIX	identity
static const MATRIX_2X2	identity_2x2
const struct shaper	arabic_shaper
HMODULE	dwrite_module

Macro Definition Documentation

GLYPH_BLOCK_MASK

#define GLYPH_BLOCK_MASK   (GLYPH_BLOCK_SIZE - 1)

Definition at line 194 of file dwrite_private.h.

GLYPH_BLOCK_SHIFT

#define GLYPH_BLOCK_SHIFT   8

Definition at line 192 of file dwrite_private.h.

GLYPH_BLOCK_SIZE

#define GLYPH_BLOCK_SIZE   (1UL << GLYPH_BLOCK_SHIFT)

Definition at line 193 of file dwrite_private.h.

GLYPH_MAX

#define GLYPH_MAX   65536

Definition at line 195 of file dwrite_private.h.

MAX_SHAPING_STAGE

#define MAX_SHAPING_STAGE   16

Definition at line 699 of file dwrite_private.h.

MS_GPOS_TAG

#define MS_GPOS_TAG   DWRITE_MAKE_OPENTYPE_TAG('G','P','O','S')

Definition at line 31 of file dwrite_private.h.

MS_GSUB_TAG

#define MS_GSUB_TAG   DWRITE_MAKE_OPENTYPE_TAG('G','S','U','B')

Definition at line 30 of file dwrite_private.h.

Typedef Documentation

MATRIX_2X2

typedef struct MATRIX_2X2 MATRIX_2X2

p_apply_context_lookup

typedef void(* p_apply_context_lookup) (struct scriptshaping_context *context, unsigned int lookup_index)

Definition at line 674 of file dwrite_private.h.

p_cmap_get_glyph_func

typedef UINT16(* p_cmap_get_glyph_func) (const struct dwrite_cmap *cmap, unsigned int ch)

Definition at line 210 of file dwrite_private.h.

p_cmap_get_ranges_func

typedef unsigned int(* p_cmap_get_ranges_func) (const struct dwrite_cmap *cmap, unsigned int max_count, DWRITE_UNICODE_RANGE *ranges)

Definition at line 211 of file dwrite_private.h.

p_dwrite_fontface_get_font_object

typedef UINT64(* p_dwrite_fontface_get_font_object) (struct dwrite_fontface *fontface)

Definition at line 255 of file dwrite_private.h.

stage_func

typedef void(* stage_func) (struct scriptshaping_context *context, const struct shaping_features *features)

Definition at line 703 of file dwrite_private.h.

Enumeration Type Documentation

dwrite_outline_tags

enum dwrite_outline_tags

Enumerator
OUTLINE_BEGIN_FIGURE
OUTLINE_END_FIGURE
OUTLINE_LINE
OUTLINE_BEZIER

Definition at line 584 of file dwrite_private.h.

{
    OUTLINE_BEGIN_FIGURE,
    OUTLINE_END_FIGURE,
    OUTLINE_LINE,
    OUTLINE_BEZIER,
};

font_flags

enum font_flags

Enumerator
FONT_IS_SYMBOL
FONT_IS_MONOSPACED
FONT_IS_COLORED
FONTFACE_KERNING_PAIRS
FONTFACE_NO_KERNING_PAIRS
FONTFACE_VERTICAL_VARIANTS
FONTFACE_NO_VERTICAL_VARIANTS

Definition at line 197 of file dwrite_private.h.

{
    FONT_IS_SYMBOL                = 0x00000001,
    FONT_IS_MONOSPACED            = 0x00000002,
    FONT_IS_COLORED               = 0x00000004, /* CPAL/COLR support */
    FONTFACE_KERNING_PAIRS        = 0x00000008,
    FONTFACE_NO_KERNING_PAIRS     = 0x00000010,
    FONTFACE_VERTICAL_VARIANTS    = 0x00000020,
    FONTFACE_NO_VERTICAL_VARIANTS = 0x00000040,
};

gasp_flags

enum gasp_flags

Enumerator
GASP_GRIDFIT
GASP_DOGRAY
GASP_SYMMETRIC_GRIDFIT
GASP_SYMMETRIC_SMOOTHING

Definition at line 552 of file dwrite_private.h.

                {
    GASP_GRIDFIT             = 0x0001,
    GASP_DOGRAY              = 0x0002,
    GASP_SYMMETRIC_GRIDFIT   = 0x0004,
    GASP_SYMMETRIC_SMOOTHING = 0x0008,
};

SCRIPT_JUSTIFY

enum SCRIPT_JUSTIFY

Enumerator
SCRIPT_JUSTIFY_NONE
SCRIPT_JUSTIFY_ARABIC_BLANK
SCRIPT_JUSTIFY_CHARACTER
SCRIPT_JUSTIFY_RESERVED1
SCRIPT_JUSTIFY_BLANK
SCRIPT_JUSTIFY_RESERVED2
SCRIPT_JUSTIFY_RESERVED3
SCRIPT_JUSTIFY_ARABIC_NORMAL
SCRIPT_JUSTIFY_ARABIC_KASHIDA
SCRIPT_JUSTIFY_ARABIC_ALEF
SCRIPT_JUSTIFY_ARABIC_HA
SCRIPT_JUSTIFY_ARABIC_RA
SCRIPT_JUSTIFY_ARABIC_BA
SCRIPT_JUSTIFY_ARABIC_BARA
SCRIPT_JUSTIFY_ARABIC_SEEN
SCRIPT_JUSTIFY_ARABIC_SEEN_M

Definition at line 610 of file dwrite_private.h.

{
    SCRIPT_JUSTIFY_NONE,
    SCRIPT_JUSTIFY_ARABIC_BLANK,
    SCRIPT_JUSTIFY_CHARACTER,
    SCRIPT_JUSTIFY_RESERVED1,
    SCRIPT_JUSTIFY_BLANK,
    SCRIPT_JUSTIFY_RESERVED2,
    SCRIPT_JUSTIFY_RESERVED3,
    SCRIPT_JUSTIFY_ARABIC_NORMAL,
    SCRIPT_JUSTIFY_ARABIC_KASHIDA,
    SCRIPT_JUSTIFY_ARABIC_ALEF,
    SCRIPT_JUSTIFY_ARABIC_HA,
    SCRIPT_JUSTIFY_ARABIC_RA,
    SCRIPT_JUSTIFY_ARABIC_BA,
    SCRIPT_JUSTIFY_ARABIC_BARA,
    SCRIPT_JUSTIFY_ARABIC_SEEN,
    SCRIPT_JUSTIFY_ARABIC_SEEN_M
};

shaping_feature_flags

enum shaping_feature_flags

Enumerator
FEATURE_GLOBAL
FEATURE_GLOBAL_SEARCH
FEATURE_MANUAL_ZWNJ
FEATURE_MANUAL_ZWJ
FEATURE_MANUAL_JOINERS
FEATURE_HAS_FALLBACK
FEATURE_NEEDS_FALLBACK

Definition at line 676 of file dwrite_private.h.

{
    FEATURE_GLOBAL = 0x1,
    FEATURE_GLOBAL_SEARCH = 0x2,
    FEATURE_MANUAL_ZWNJ = 0x4,
    FEATURE_MANUAL_ZWJ = 0x8,
    FEATURE_MANUAL_JOINERS = FEATURE_MANUAL_ZWNJ | FEATURE_MANUAL_ZWJ,
    FEATURE_HAS_FALLBACK = 0x10,
    FEATURE_NEEDS_FALLBACK = 0x20,
};

Function Documentation

add_localizedstring()

HRESULT add_localizedstring	(	IDWriteLocalizedStrings *	iface,
		const WCHAR *	locale,
		const WCHAR *	string
	)

Definition at line 466 of file main.c.

{
    struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
    size_t i, count = strings->count;
 
    /* Make sure there's no duplicates, unless it's empty. This is used by dlng/slng entries of 'meta' table. */
    if (*locale)
    {
        for (i = 0; i < count; i++)
            if (!wcsicmp(strings->data[i].locale, locale))
                return S_OK;
    }
 
    if (!dwrite_array_reserve((void **)&strings->data, &strings->size, strings->count + 1, sizeof(*strings->data)))
        return E_OUTOFMEMORY;
 
    strings->data[count].locale = wcsdup(locale);
    strings->data[count].string = wcsdup(string);
    if (!strings->data[count].locale || !strings->data[count].string)
    {
        free(strings->data[count].locale);
        free(strings->data[count].string);
        return E_OUTOFMEMORY;
    }
    wcslwr(strings->data[count].locale);
 
    strings->count++;
 
    return S_OK;
}

Referenced by eudc_collection_add_family(), fontcollection_add_replacement(), init_font_data_from_font(), opentype_decode_namerecord(), and opentype_get_font_strings_from_meta().

bidi_computelevels()

HRESULT bidi_computelevels	(	struct bidi_char *	chars,
		unsigned int	count,
		UINT8	baselevel
	)

Definition at line 1070 of file bidi.c.

{
    IsolatedRun *iso_run, *next;
    struct list IsolatingRuns;
    HRESULT hr;
 
    if (TRACE_ON(bidi)) bidi_dump_types("start ", chars, 0, count);
 
    bidi_resolve_explicit(chars, count, baselevel);
 
    if (TRACE_ON(bidi)) bidi_dump_types("after explicit", chars, 0, count);
 
    /* X10/BD13: Compute Isolating runs */
    if (FAILED(hr = bidi_compute_isolating_runs_set(chars, count, baselevel, &IsolatingRuns)))
    {
        WARN("Failed to compute isolating runs set, hr %#lx.\n", hr);
        return hr;
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(iso_run, next, &IsolatingRuns, IsolatedRun, entry)
    {
        if (TRACE_ON(bidi)) iso_dump_types("run", iso_run);
 
        bidi_resolve_weak(iso_run);
        if (TRACE_ON(bidi)) iso_dump_types("after weak", iso_run);
 
        bidi_resolve_neutrals(iso_run);
        if (TRACE_ON(bidi)) iso_dump_types("after neutrals", iso_run);
 
        list_remove(&iso_run->entry);
        free(iso_run);
    }
 
    if (TRACE_ON(bidi)) bidi_dump_types("before implicit", chars, 0, count);
    bidi_resolve_implicit(chars, count);
 
    bidi_resolve_resolved(chars, count, baselevel);
 
    return S_OK;
}

Referenced by dwritetextanalyzer_AnalyzeBidi().

clone_localizedstrings()

HRESULT clone_localizedstrings	(	IDWriteLocalizedStrings *	iface,
		IDWriteLocalizedStrings **	strings
	)

Definition at line 497 of file main.c.

{
    struct localizedstrings *strings, *strings_clone;
    size_t i;
 
    *ret = NULL;
 
    if (!iface)
        return S_FALSE;
 
    strings = impl_from_IDWriteLocalizedStrings(iface);
    if (!(strings_clone = calloc(1, sizeof(*strings_clone))))
        return E_OUTOFMEMORY;
 
    if (!dwrite_array_reserve((void **)&strings_clone->data, &strings_clone->size, strings->count,
            sizeof(*strings_clone->data)))
    {
        free(strings_clone);
        return E_OUTOFMEMORY;
    }
 
    strings_clone->IDWriteLocalizedStrings_iface.lpVtbl = &localizedstringsvtbl;
    strings_clone->refcount = 1;
    strings_clone->count = strings->count;
 
    for (i = 0; i < strings_clone->count; ++i)
    {
        strings_clone->data[i].locale = wcsdup(strings->data[i].locale);
        strings_clone->data[i].string = wcsdup(strings->data[i].string);
    }
 
    *ret = &strings_clone->IDWriteLocalizedStrings_iface;
 
    return S_OK;
}

Referenced by dwritefont_GetFaceNames(), dwritefontface3_GetFaceNames(), dwritefontface3_GetFamilyNames(), dwritefontfamily_GetFamilyNames(), and get_font_info_strings().

compute_glyph_origins()

HRESULT compute_glyph_origins	(	DWRITE_GLYPH_RUN const *	run,
		DWRITE_MEASURING_MODE	measuring_mode,
		D2D1_POINT_2F	baseline_origin,
		DWRITE_MATRIX const *	transform,
		D2D1_POINT_2F *	origins
	)

Definition at line 1726 of file main.c.

{
    struct dwrite_fontface *font_obj;
    unsigned int i;
    float advance;
 
    font_obj = unsafe_impl_from_IDWriteFontFace(run->fontFace);
 
    for (i = 0; i < run->glyphCount; ++i)
    {
        origins[i] = baseline_origin;
 
        if (run->bidiLevel & 1)
        {
            advance = fontface_get_scaled_design_advance(font_obj, measuring_mode, run->fontEmSize,
                    1.0f, transform, run->glyphIndices[i], run->isSideways);
 
            origins[i].x -= advance;
 
            if (run->glyphOffsets)
            {
                origins[i].x -= run->glyphOffsets[i].advanceOffset;
                origins[i].y -= run->glyphOffsets[i].ascenderOffset;
            }
 
            baseline_origin.x -= run->glyphAdvances ? run->glyphAdvances[i] : advance;
        }
        else
        {
            if (run->glyphOffsets)
            {
                origins[i].x += run->glyphOffsets[i].advanceOffset;
                origins[i].y -= run->glyphOffsets[i].ascenderOffset;
            }
 
            baseline_origin.x += run->glyphAdvances ? run->glyphAdvances[i] :
                    fontface_get_scaled_design_advance(font_obj, measuring_mode, run->fontEmSize, 1.0f, transform,
                            run->glyphIndices[i], run->isSideways);
 
        }
    }
 
    return S_OK;
}

Referenced by create_glyphrunanalysis(), dwritefactory4_ComputeGlyphOrigins(), dwritefactory4_ComputeGlyphOrigins_(), dwritefontface_GetGlyphRunOutline(), and layout_get_erun_bbox().

create_colorglyphenum()

HRESULT create_colorglyphenum	(	D2D1_POINT_2F	origin,
		const DWRITE_GLYPH_RUN *	run,
		const DWRITE_GLYPH_RUN_DESCRIPTION *	desc,
		DWRITE_GLYPH_IMAGE_FORMATS	formats,
		DWRITE_MEASURING_MODE	mode,
		const DWRITE_MATRIX *	transform,
		UINT32	palette,
		IDWriteColorGlyphRunEnumerator1 **	enumerator
	)

Referenced by dwritefactory2_TranslateColorGlyphRun(), and dwritefactory4_TranslateColorGlyphRun().

create_font_collection()

HRESULT create_font_collection	(	IDWriteFactory7 *	factory,
		IDWriteFontFileEnumerator *	enumerator,
		BOOL	is_system,
		IDWriteFontCollection3 **	collection
	)

Definition at line 4649 of file font.c.

{
    struct fontfile_enum {
        struct list entry;
        IDWriteFontFile *file;
    };
    struct fontfile_enum *fileenum, *fileenum2;
    struct dwrite_fontcollection *collection;
    struct list scannedfiles;
    BOOL current = FALSE;
    HRESULT hr = S_OK;
    size_t i;
 
    *ret = NULL;
 
    if (!(collection = calloc(1, sizeof(*collection))))
        return E_OUTOFMEMORY;
 
    hr = init_font_collection(collection, factory, DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE, is_system);
    if (FAILED(hr))
    {
        free(collection);
        return hr;
    }
 
    *ret = &collection->IDWriteFontCollection3_iface;
 
    TRACE("building font collection:\n");
 
    list_init(&scannedfiles);
    while (hr == S_OK) {
        DWRITE_FONT_FACE_TYPE face_type;
        DWRITE_FONT_FILE_TYPE file_type;
        BOOL supported, same = FALSE;
        IDWriteFontFileStream *stream;
        IDWriteFontFile *file;
        UINT32 face_count;
 
        current = FALSE;
        hr = IDWriteFontFileEnumerator_MoveNext(enumerator, &current);
        if (FAILED(hr) || !current)
            break;
 
        hr = IDWriteFontFileEnumerator_GetCurrentFontFile(enumerator, &file);
        if (FAILED(hr))
            break;
 
        /* check if we've scanned this file already */
        LIST_FOR_EACH_ENTRY(fileenum, &scannedfiles, struct fontfile_enum, entry) {
            if ((same = is_same_fontfile(fileenum->file, file)))
                break;
        }
 
        if (same) {
            IDWriteFontFile_Release(file);
            continue;
        }
 
        if (FAILED(get_filestream_from_file(file, &stream))) {
            IDWriteFontFile_Release(file);
            continue;
        }
 
        /* Unsupported formats are skipped. */
        hr = opentype_analyze_font(stream, &supported, &file_type, &face_type, &face_count);
        if (FAILED(hr) || !supported || face_count == 0) {
            TRACE("Unsupported font (%p, 0x%08lx, %d, %u)\n", file, hr, supported, face_count);
            IDWriteFontFileStream_Release(stream);
            IDWriteFontFile_Release(file);
            hr = S_OK;
            continue;
        }
 
        /* add to scanned list */
        fileenum = malloc(sizeof(*fileenum));
        fileenum->file = file;
        list_add_tail(&scannedfiles, &fileenum->entry);
 
        for (i = 0; i < face_count; ++i)
        {
            struct dwrite_font_data *font_data;
            struct fontface_desc desc;
            WCHAR familyW[255];
            UINT32 index;
 
            desc.factory = factory;
            desc.face_type = face_type;
            desc.file = file;
            desc.stream = stream;
            desc.index = i;
            desc.simulations = DWRITE_FONT_SIMULATIONS_NONE;
            desc.font_data = NULL;
 
            /* Allocate an initialize new font data structure. */
            hr = init_font_data(&desc, DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE, &font_data);
            if (FAILED(hr))
            {
                /* move to next one */
                hr = S_OK;
                continue;
            }
 
            fontstrings_get_en_string(font_data->family_names, familyW, ARRAY_SIZE(familyW));
 
            /* ignore dot named faces */
            if (familyW[0] == '.')
            {
                WARN("Ignoring face %s\n", debugstr_w(familyW));
                release_font_data(font_data);
                continue;
            }
 
            index = collection_find_family(collection, familyW);
            if (index != ~0u)
                hr = fontfamily_add_font(collection->family_data[index], font_data);
            else {
                struct dwrite_fontfamily_data *family_data;
 
                /* create and init new family */
                hr = init_fontfamily_data(font_data->family_names, &family_data);
                if (hr == S_OK) {
                    /* add font to family, family - to collection */
                    hr = fontfamily_add_font(family_data, font_data);
                    if (hr == S_OK)
                        hr = fontcollection_add_family(collection, family_data);
 
                    if (FAILED(hr))
                        release_fontfamily_data(family_data);
                }
            }
 
            if (FAILED(hr))
            {
                release_font_data(font_data);
                break;
            }
        }
 
        IDWriteFontFileStream_Release(stream);
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(fileenum, fileenum2, &scannedfiles, struct fontfile_enum, entry)
    {
        IDWriteFontFile_Release(fileenum->file);
        list_remove(&fileenum->entry);
        free(fileenum);
    }
 
    for (i = 0; i < collection->count; ++i)
    {
        fontfamily_add_bold_simulated_face(collection->family_data[i]);
        fontfamily_add_oblique_simulated_face(collection->family_data[i]);
    }
 
    if (is_system)
        fontcollection_add_replacements(collection);
 
    return hr;
}

Referenced by dwritefactory_CreateCustomFontCollection(), and get_system_fontcollection().

create_font_collection_from_set()

HRESULT create_font_collection_from_set	(	IDWriteFactory7 *	factory,
		IDWriteFontSet *	set,
		DWRITE_FONT_FAMILY_MODEL	family_model,
		REFGUID	riid,
		void **	ret
	)

Definition at line 4857 of file font.c.

{
    struct dwrite_fontset *set = unsafe_impl_from_IDWriteFontSet(fontset);
    struct dwrite_fontcollection *collection;
    HRESULT hr = S_OK;
    size_t i;
 
    *ret = NULL;
 
    if (!(collection = calloc(1, sizeof(*collection))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = init_font_collection(collection, factory, family_model, FALSE)))
    {
        free(collection);
        return hr;
    }
 
    for (i = 0; i < set->count; ++i)
    {
        const struct dwrite_fontset_entry *entry = set->entries[i];
        IDWriteFontFileStream *stream;
        struct fontface_desc desc;
 
        if (FAILED(get_filestream_from_file(entry->desc.file, &stream)))
        {
            WARN("Failed to get file stream.\n");
            continue;
        }
 
        desc.factory = factory;
        desc.face_type = entry->desc.face_type;
        desc.file = entry->desc.file;
        desc.stream = stream;
        desc.index = entry->desc.face_index;
        desc.simulations = entry->desc.simulations;
        desc.font_data = NULL;
 
        if (FAILED(hr = collection_add_font_entry(collection, &desc)))
            WARN("Failed to add font collection element, hr %#lx.\n", hr);
 
        IDWriteFontFileStream_Release(stream);
    }
 
    if (family_model == DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE)
    {
        for (i = 0; i < collection->count; ++i)
        {
            fontfamily_add_bold_simulated_face(collection->family_data[i]);
            fontfamily_add_oblique_simulated_face(collection->family_data[i]);
        }
    }
 
    hr = IDWriteFontCollection3_QueryInterface(&collection->IDWriteFontCollection3_iface, riid, ret);
    IDWriteFontCollection3_Release(&collection->IDWriteFontCollection3_iface);
 
    return hr;
}

Referenced by dwritefactory3_CreateFontCollectionFromFontSet(), dwritefactory6_CreateFontCollectionFromFontSet(), and get_system_fontcollection().

create_font_file()

HRESULT create_font_file	(	IDWriteFontFileLoader *	loader,
		const void *	reference_key,
		UINT32	key_size,
		IDWriteFontFile **	font_file
	)

Definition at line 5400 of file font.c.

{
    struct dwrite_fontfile *file;
    void *key;
 
    *ret = NULL;
 
    file = calloc(1, sizeof(*file));
    key = malloc(key_size);
    if (!file || !key)
    {
        free(file);
        free(key);
        return E_OUTOFMEMORY;
    }
 
    file->IDWriteFontFile_iface.lpVtbl = &dwritefontfilevtbl;
    file->refcount = 1;
    IDWriteFontFileLoader_AddRef(loader);
    file->loader = loader;
    file->stream = NULL;
    file->reference_key = key;
    memcpy(file->reference_key, reference_key, key_size);
    file->key_size = key_size;
 
    *ret = &file->IDWriteFontFile_iface;
 
    return S_OK;
}

Referenced by dwritefactory_CreateCustomFontFileReference(), and dwritefactory_CreateFontFileReference().

create_font_resource()

HRESULT create_font_resource	(	IDWriteFactory7 *	factory,
		IDWriteFontFile *	file,
		UINT32	face_index,
		IDWriteFontResource **	resource
	)

Definition at line 7583 of file font.c.

{
    struct dwrite_fontresource *resource;
    struct file_stream_desc stream_desc;
    DWRITE_FONT_FILE_TYPE file_type;
    DWRITE_FONT_FACE_TYPE face_type;
    unsigned int face_count;
    BOOL supported = FALSE;
    HRESULT hr;
 
    *ret = NULL;
 
    if (FAILED(hr = IDWriteFontFile_Analyze(file, &supported, &file_type, &face_type, &face_count)))
        return hr;
 
    if (!supported)
        return DWRITE_E_FILEFORMAT;
 
    if (!(resource = calloc(1, sizeof(*resource))))
        return E_OUTOFMEMORY;
 
    resource->IDWriteFontResource_iface.lpVtbl = &fontresourcevtbl;
    resource->refcount = 1;
    resource->face_index = face_index;
    resource->file = file;
    IDWriteFontFile_AddRef(resource->file);
    resource->factory = factory;
    IDWriteFactory7_AddRef(resource->factory);
 
    get_filestream_from_file(file, &stream_desc.stream);
    stream_desc.face_type = face_type;
    stream_desc.face_index = face_index;
 
    opentype_get_font_var_axis(&stream_desc, &resource->axis, &resource->axis_count);
 
    if (stream_desc.stream)
        IDWriteFontFileStream_Release(stream_desc.stream);
 
    *ret = &resource->IDWriteFontResource_iface;
 
    return S_OK;
}

Referenced by dwritefactory6_CreateFontResource().

create_fontface()

HRESULT create_fontface	(	const struct fontface_desc *	desc,
		struct list *	cached_list,
		IDWriteFontFace5 **	fontface
	)

Definition at line 5473 of file font.c.

{
    struct file_stream_desc stream_desc;
    struct dwrite_font_data *font_data;
    struct dwrite_fontface *fontface;
    HRESULT hr;
    int i;
 
    *ret = NULL;
 
    if (!(fontface = calloc(1, sizeof(*fontface))))
        return E_OUTOFMEMORY;
 
    fontface->IDWriteFontFace5_iface.lpVtbl = &dwritefontfacevtbl;
    fontface->IDWriteFontFaceReference_iface.lpVtbl = &dwritefontface_reference_vtbl;
    fontface->refcount = 1;
    fontface->type = desc->face_type;
    fontface->vdmx.exists = TRUE;
    fontface->gasp.exists = TRUE;
    fontface->cpal.exists = TRUE;
    fontface->colr.exists = TRUE;
    fontface->kern.exists = TRUE;
    fontface->index = desc->index;
    fontface->simulations = desc->simulations;
    fontface->factory = desc->factory;
    IDWriteFactory7_AddRef(fontface->factory);
    fontface->file = desc->file;
    IDWriteFontFile_AddRef(fontface->file);
    fontface->stream = desc->stream;
    IDWriteFontFileStream_AddRef(fontface->stream);
    InitializeCriticalSection(&fontface->cs);
    fontface_cache_init(fontface);
 
    stream_desc.stream = fontface->stream;
    stream_desc.face_type = desc->face_type;
    stream_desc.face_index = desc->index;
    opentype_get_font_metrics(&stream_desc, &fontface->metrics, &fontface->caret);
    opentype_get_font_typo_metrics(&stream_desc, &fontface->typo_metrics.ascent, &fontface->typo_metrics.descent);
    if (desc->simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE) {
        /* TODO: test what happens if caret is already slanted */
        if (fontface->caret.slopeRise == 1) {
            fontface->caret.slopeRise = fontface->metrics.designUnitsPerEm;
            fontface->caret.slopeRun = fontface->caret.slopeRise / 3;
        }
    }
    fontface->glyph_image_formats = opentype_get_glyph_image_formats(&fontface->IDWriteFontFace5_iface);
 
    /* Font properties are reused from font object when 'normal' face creation path is used:
       collection -> family -> matching font -> fontface.
 
       If face is created directly from factory we have to go through properties resolution.
    */
    if (desc->font_data)
    {
        font_data = addref_font_data(desc->font_data);
    }
    else
    {
        hr = init_font_data(desc, DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE, &font_data);
        if (FAILED(hr))
        {
            IDWriteFontFace5_Release(&fontface->IDWriteFontFace5_iface);
            return hr;
        }
    }
 
    fontface->weight = font_data->weight;
    fontface->style = font_data->style;
    fontface->stretch = font_data->stretch;
    fontface->panose = font_data->panose;
    fontface->fontsig = font_data->fontsig;
    fontface->lf = font_data->lf;
    fontface->flags |= font_data->flags & (FONT_IS_SYMBOL | FONT_IS_MONOSPACED | FONT_IS_COLORED);
    fontface->names = font_data->names;
    if (fontface->names)
        IDWriteLocalizedStrings_AddRef(fontface->names);
    fontface->family_names = font_data->family_names;
    if (fontface->family_names)
        IDWriteLocalizedStrings_AddRef(fontface->family_names);
    memcpy(fontface->info_strings, font_data->info_strings, sizeof(fontface->info_strings));
    for (i = 0; i < ARRAY_SIZE(fontface->info_strings); ++i)
    {
        if (fontface->info_strings[i])
            IDWriteLocalizedStrings_AddRef(fontface->info_strings[i]);
    }
    fontface->cmap.stream = fontface->stream;
    IDWriteFontFileStream_AddRef(fontface->cmap.stream);
    release_font_data(font_data);
 
    fontface->cached = factory_cache_fontface(fontface->factory, cached_list, &fontface->IDWriteFontFace5_iface);
    fontface->get_font_object = dwrite_fontface_get_font_object;
 
    *ret = &fontface->IDWriteFontFace5_iface;
 
    return S_OK;
}

Referenced by dwritefactory_CreateFontFace(), and get_fontface_from_font().

create_fontfacereference()

HRESULT create_fontfacereference	(	IDWriteFactory7 *	factory,
		IDWriteFontFile *	file,
		UINT32	face_index,
		DWRITE_FONT_SIMULATIONS	simulations,
		DWRITE_FONT_AXIS_VALUE const *	axis_values,
		UINT32	axis_values_count,
		IDWriteFontFaceReference1 **	reference
	)

Definition at line 7082 of file font.c.

{
    struct dwrite_fontfacereference *object;
 
    *ret = NULL;
 
    if (!is_simulation_valid(simulations))
        return E_INVALIDARG;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDWriteFontFaceReference1_iface.lpVtbl = &fontfacereferencevtbl;
    object->refcount = 1;
 
    object->factory = factory;
    IDWriteFactory7_AddRef(object->factory);
    object->file = file;
    IDWriteFontFile_AddRef(object->file);
    object->index = index;
    object->simulations = simulations;
    if (axis_values_count)
    {
        if (!(object->axis_values = malloc(axis_values_count * sizeof(*axis_values))))
        {
            IDWriteFontFaceReference1_Release(&object->IDWriteFontFaceReference1_iface);
            return E_OUTOFMEMORY;
        }
        memcpy(object->axis_values, axis_values, axis_values_count * sizeof(*axis_values));
        object->axis_values_count = axis_values_count;
    }
 
    *ret = &object->IDWriteFontFaceReference1_iface;
 
    return S_OK;
}

Referenced by dwritefactory3_CreateFontFaceReference(), dwritefactory3_CreateFontFaceReference_(), and dwritefactory6_CreateFontFaceReference().

create_fontfallback_builder()

HRESULT create_fontfallback_builder	(	IDWriteFactory7 *	factory,
		IDWriteFontFallbackBuilder **	builder
	)

Definition at line 2929 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *builder;
    HRESULT hr;
 
    *ret = NULL;
 
    if (SUCCEEDED(hr = create_fontfallback_builder_internal(factory, &builder)))
        *ret = &builder->IDWriteFontFallbackBuilder_iface;
 
    return hr;
}

Referenced by dwritefactory2_CreateFontFallbackBuilder().

create_fontset_builder()

HRESULT create_fontset_builder	(	IDWriteFactory7 *	factory,
		IDWriteFontSetBuilder2 **	ret
	)

Definition at line 8391 of file font.c.

{
    struct dwrite_fontset_builder *builder;
 
    *ret = NULL;
 
    if (!(builder = calloc(1, sizeof(*builder))))
        return E_OUTOFMEMORY;
 
    builder->IDWriteFontSetBuilder2_iface.lpVtbl = &fontsetbuildervtbl;
    builder->refcount = 1;
    builder->factory = factory;
    IDWriteFactory7_AddRef(builder->factory);
 
    *ret = &builder->IDWriteFontSetBuilder2_iface;
 
    return S_OK;
}

Referenced by create_system_fontset(), dwritefactory3_CreateFontSetBuilder(), dwritefactory5_CreateFontSetBuilder(), and dwritefactory6_CreateFontSetBuilder().

create_gdiinterop()

HRESULT create_gdiinterop	(	IDWriteFactory7 *	factory,
		IDWriteGdiInterop1 **	interop
	)

Definition at line 1110 of file gdiinterop.c.

{
    struct gdiinterop *interop;
 
    *ret = NULL;
 
    if (!(interop = malloc(sizeof(*interop))))
        return E_OUTOFMEMORY;
 
    interop->IDWriteGdiInterop1_iface.lpVtbl = &gdiinteropvtbl;
    interop->IDWriteFontFileLoader_iface.lpVtbl = &memresourceloadervtbl;
    interop->refcount = 1;
    interop->factory = factory;
    IDWriteFactory7_AddRef(interop->factory);
    IDWriteFactory7_RegisterFontFileLoader(factory, &interop->IDWriteFontFileLoader_iface);
 
    *ret = &interop->IDWriteGdiInterop1_iface;
    return S_OK;
}

Referenced by dwritefactory_GetGdiInterop().

create_glyphrunanalysis()

HRESULT create_glyphrunanalysis	(	const struct glyphrunanalysis_desc *	desc,
		IDWriteGlyphRunAnalysis **	ret
	)

Definition at line 6410 of file font.c.

{
    struct dwrite_glyphrunanalysis *analysis;
    unsigned int i;
 
    *ret = NULL;
 
    /* Check rendering, antialiasing, measuring, and grid fitting modes. */
    if ((UINT32)desc->rendering_mode >= DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED ||
            desc->rendering_mode == DWRITE_RENDERING_MODE1_OUTLINE ||
            desc->rendering_mode == DWRITE_RENDERING_MODE1_DEFAULT)
        return E_INVALIDARG;
 
    if ((UINT32)desc->aa_mode > DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE)
        return E_INVALIDARG;
 
    if ((UINT32)desc->gridfit_mode > DWRITE_GRID_FIT_MODE_ENABLED)
        return E_INVALIDARG;
 
    if ((UINT32)desc->measuring_mode > DWRITE_MEASURING_MODE_GDI_NATURAL)
        return E_INVALIDARG;
 
    if (!(analysis = calloc(1, sizeof(*analysis))))
        return E_OUTOFMEMORY;
 
    analysis->IDWriteGlyphRunAnalysis_iface.lpVtbl = &glyphrunanalysisvtbl;
    analysis->refcount = 1;
    analysis->rendering_mode = desc->rendering_mode;
 
    if (desc->rendering_mode == DWRITE_RENDERING_MODE1_ALIASED
            || desc->aa_mode == DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE)
        analysis->texture_type = DWRITE_TEXTURE_ALIASED_1x1;
    else
        analysis->texture_type = DWRITE_TEXTURE_CLEARTYPE_3x1;
 
    analysis->run = *desc->run;
    IDWriteFontFace_AddRef(analysis->run.fontFace);
    analysis->glyphs = calloc(desc->run->glyphCount, sizeof(*analysis->glyphs));
    analysis->origins = calloc(desc->run->glyphCount, sizeof(*analysis->origins));
 
    if (!analysis->glyphs || !analysis->origins)
    {
        free(analysis->glyphs);
        free(analysis->origins);
 
        analysis->glyphs = NULL;
        analysis->origins = NULL;
 
        IDWriteGlyphRunAnalysis_Release(&analysis->IDWriteGlyphRunAnalysis_iface);
        return E_OUTOFMEMORY;
    }
 
    /* check if transform is usable */
    if (desc->transform && memcmp(desc->transform, &identity, sizeof(*desc->transform))) {
        analysis->m = *desc->transform;
        analysis->flags |= RUNANALYSIS_USE_TRANSFORM;
    }
 
    analysis->run.glyphIndices = analysis->glyphs;
    memcpy(analysis->glyphs, desc->run->glyphIndices, desc->run->glyphCount*sizeof(*desc->run->glyphIndices));
 
    compute_glyph_origins(desc->run, desc->measuring_mode, desc->origin, desc->transform, analysis->origins);
    if (analysis->flags & RUNANALYSIS_USE_TRANSFORM)
    {
        for (i = 0; i < desc->run->glyphCount; ++i)
            transform_point(&analysis->origins[i], &analysis->m);
    }
 
    *ret = &analysis->IDWriteGlyphRunAnalysis_iface;
    return S_OK;
}

Referenced by dwritefactory_CreateGlyphRunAnalysis(), and factory_create_glyphrun_analysis().

create_inmemory_fileloader()

HRESULT create_inmemory_fileloader

(

IDWriteInMemoryFontFileLoader **

loader

)

Definition at line 7358 of file font.c.

{
    struct dwrite_inmemory_fileloader *loader;
 
    *ret = NULL;
 
    if (!(loader = calloc(1, sizeof(*loader))))
        return E_OUTOFMEMORY;
 
    loader->IDWriteInMemoryFontFileLoader_iface.lpVtbl = &inmemoryfontfileloadervtbl;
    loader->refcount = 1;
 
    *ret = &loader->IDWriteInMemoryFontFileLoader_iface;
 
    return S_OK;
}

Referenced by dwritefactory5_CreateInMemoryFontFileLoader().

create_localizedstrings()

HRESULT create_localizedstrings

(

IDWriteLocalizedStrings **

strings

)

Definition at line 449 of file main.c.

{
    struct localizedstrings *object;
 
    *strings = NULL;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDWriteLocalizedStrings_iface.lpVtbl = &localizedstringsvtbl;
    object->refcount = 1;
 
    *strings = &object->IDWriteLocalizedStrings_iface;
 
    return S_OK;
}

Referenced by eudc_collection_add_family(), fontcollection_add_replacement(), init_font_data_from_font(), opentype_get_font_strings_from_id(), and opentype_get_font_strings_from_meta().

create_matching_font()

HRESULT create_matching_font	(	IDWriteFontCollection *	collection,
		const WCHAR *	family,
		DWRITE_FONT_WEIGHT	weight,
		DWRITE_FONT_STYLE	style,
		DWRITE_FONT_STRETCH	stretch,
		REFIID	riid,
		void **	obj
	)

Definition at line 2479 of file analyzer.c.

{
    IDWriteFontFamily *family;
    BOOL exists = FALSE;
    IDWriteFont *font;
    HRESULT hr;
    UINT32 i;
 
    *obj = NULL;
 
    hr = IDWriteFontCollection_FindFamilyName(collection, name, &i, &exists);
    if (FAILED(hr))
        return hr;
 
    if (!exists)
        return E_FAIL;
 
    hr = IDWriteFontCollection_GetFontFamily(collection, i, &family);
    if (FAILED(hr))
        return hr;
 
    hr = IDWriteFontFamily_GetFirstMatchingFont(family, weight, stretch, style, &font);
    IDWriteFontFamily_Release(family);
 
    if (SUCCEEDED(hr))
    {
        hr = IDWriteFont_QueryInterface(font, riid, obj);
        IDWriteFont_Release(font);
    }
 
    return hr;
}

Referenced by fallback_map_characters(), fontfallback_MapCharacters(), and layout_run_get_last_resort_font().

create_numbersubstitution()

HRESULT create_numbersubstitution	(	DWRITE_NUMBER_SUBSTITUTION_METHOD	method,
		const WCHAR *	locale,
		BOOL	ignore_user_override,
		IDWriteNumberSubstitution **	ret
	)

Definition at line 2305 of file analyzer.c.

{
    struct dwrite_numbersubstitution *substitution;
 
    *ret = NULL;
 
    if ((UINT32)method > DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL)
        return E_INVALIDARG;
 
    if (method != DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE && !IsValidLocaleName(locale))
        return E_INVALIDARG;
 
    if (!(substitution = calloc(1, sizeof(*substitution))))
        return E_OUTOFMEMORY;
 
    substitution->IDWriteNumberSubstitution_iface.lpVtbl = &numbersubstitutionvtbl;
    substitution->refcount = 1;
    substitution->ignore_user_override = ignore_user_override;
    substitution->method = method;
    substitution->locale = wcsdup(locale);
    if (locale && !substitution->locale)
    {
        free(substitution);
        return E_OUTOFMEMORY;
    }
 
    *ret = &substitution->IDWriteNumberSubstitution_iface;
    return S_OK;
}

Referenced by dwritefactory_CreateNumberSubstitution().

create_scriptshaping_cache()

struct scriptshaping_cache * create_scriptshaping_cache	(	void *	context,
		const struct shaping_font_ops *	font_ops
	)

Definition at line 43 of file shape.c.

{
    struct scriptshaping_cache *cache;
 
    if (!(cache = calloc(1, sizeof(*cache))))
        return NULL;
 
    cache->font = font_ops;
    cache->context = context;
 
    opentype_layout_scriptshaping_cache_init(cache);
    cache->upem = cache->font->get_font_upem(cache->context);
 
    return cache;
}

Referenced by fontface_get_shaping_cache().

create_system_fontfallback()

HRESULT create_system_fontfallback	(	IDWriteFactory7 *	factory,
		IDWriteFontFallback1 **	fallback
	)

Definition at line 3029 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback;
 
    *ret = NULL;
 
    if (!InitOnceExecuteOnce(&init_system_fallback_once, dwrite_system_fallback_initonce, factory, NULL))
    {
        WARN("Failed to initialize system fallback data.\n");
        return E_FAIL;
    }
 
    if (!(fallback = calloc(1, sizeof(*fallback))))
        return E_OUTOFMEMORY;
 
    fallback->IDWriteFontFallback1_iface.lpVtbl = &fontfallbackvtbl;
    fallback->factory = factory;
    fallback->data.count = ~0u;
    IDWriteFactory_GetSystemFontCollection((IDWriteFactory *)fallback->factory, &fallback->systemcollection, FALSE);
 
    *ret = &fallback->IDWriteFontFallback1_iface;
 
    return S_OK;
}

Referenced by dwritefactory2_GetSystemFontFallback().

create_system_fontset()

HRESULT create_system_fontset	(	IDWriteFactory7 *	factory,
		REFIID	riid,
		void **	obj
	)

Definition at line 1624 of file main.c.

{
    IDWriteFontSetBuilder2 *builder;
    IDWriteFontSet *fontset;
    unsigned int i, j, count;
    WCHAR **paths;
    HRESULT hr;
 
    *obj = NULL;
 
    if (FAILED(hr = create_fontset_builder(factory, &builder))) return hr;
 
    if (SUCCEEDED(hr = create_system_path_list(&paths, &count)))
    {
        /* Sort, skip duplicates. */
 
        qsort(paths, count, sizeof(*paths), create_system_fontset_compare);
 
        for (i = 0, j = 0; i < count; ++i)
        {
            if (i != j && !wcsicmp(paths[i], paths[j])) continue;
 
            if (FAILED(hr = IDWriteFontSetBuilder2_AddFontFile(builder, paths[i])) && hr != DWRITE_E_FILEFORMAT)
                WARN("Failed to add font file, hr %#lx, path %s.\n", hr, debugstr_w(paths[i]));
 
            j = i;
        }
 
        for (i = 0; i < count; ++i)
            free(paths[i]);
        free(paths);
    }
 
    if (SUCCEEDED(hr = IDWriteFontSetBuilder2_CreateFontSet(builder, &fontset)))
    {
        hr = IDWriteFontSet_QueryInterface(fontset, riid, obj);
        IDWriteFontSet_Release(fontset);
    }
 
    IDWriteFontSetBuilder2_Release(builder);
 
    return hr;
}

Referenced by dwritefactory3_GetSystemFontSet(), dwritefactory6_GetSystemFontSet(), dwritefactory7_GetSystemFontSet(), and get_system_fontcollection().

create_text_format()

HRESULT create_text_format	(	const WCHAR *	family_name,
		IDWriteFontCollection *	collection,
		DWRITE_FONT_WEIGHT	weight,
		DWRITE_FONT_STYLE	style,
		DWRITE_FONT_STRETCH	stretch,
		float	size,
		const WCHAR *	locale,
		REFIID	riid,
		void **	out
	)

Definition at line 714 of file format.c.

{
    struct dwrite_textformat *object;
    HRESULT hr;
 
    *out = NULL;
 
    if (size <= 0.0f)
        return E_INVALIDARG;
 
    if ((UINT32)weight > DWRITE_FONT_WEIGHT_ULTRA_BLACK
        || stretch == DWRITE_FONT_STRETCH_UNDEFINED
        || (UINT32)stretch > DWRITE_FONT_STRETCH_ULTRA_EXPANDED
        || (UINT32)style > DWRITE_FONT_STYLE_ITALIC)
    {
        return E_INVALIDARG;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDWriteTextFormat3_iface.lpVtbl = &dwritetextformatvtbl;
    object->refcount = 1;
    object->format.family_name = wcsdup(family_name);
    object->format.family_len = wcslen(family_name);
    object->format.locale = wcsdup(locale);
    object->format.locale_len = wcslen(locale);
    /* Force locale name to lower case, layout will inherit this modified value. */
    wcslwr(object->format.locale);
    object->format.weight = weight;
    object->format.style = style;
    object->format.fontsize = size;
    object->format.tabstop = 4.0f * size;
    object->format.stretch = stretch;
    object->format.last_line_wrapping = TRUE;
    object->format.collection = collection;
    IDWriteFontCollection_AddRef(object->format.collection);
 
    hr = IDWriteTextFormat3_QueryInterface(&object->IDWriteTextFormat3_iface, riid, out);
    IDWriteTextFormat3_Release(&object->IDWriteTextFormat3_iface);
 
    return hr;
}

Referenced by dwritefactory6_CreateTextFormat(), and dwritefactory_CreateTextFormat().

create_textlayout()

HRESULT create_textlayout	(	const struct textlayout_desc *	desc,
		IDWriteTextLayout **	layout
	)

Definition at line 5346 of file layout.c.

{
    struct dwrite_textlayout *object;
    HRESULT hr;
 
    *layout = NULL;
 
    if (desc->max_width < 0.0f || desc->max_height < 0.0f)
        return E_INVALIDARG;
 
    if (!desc->format || !desc->string)
        return E_INVALIDARG;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    hr = init_textlayout(desc, object);
    if (hr == S_OK)
        *layout = (IDWriteTextLayout *)&object->IDWriteTextLayout4_iface;
 
    return hr;
}

Referenced by dwritefactory_CreateGdiCompatibleTextLayout(), and dwritefactory_CreateTextLayout().

create_trimmingsign()

HRESULT create_trimmingsign	(	IDWriteFactory7 *	factory,
		IDWriteTextFormat *	format,
		IDWriteInlineObject **	sign
	)

Definition at line 891 of file format.c.

{
    struct dwrite_trimmingsign *object;
    DWRITE_READING_DIRECTION reading;
    DWRITE_FLOW_DIRECTION flow;
    HRESULT hr;
 
    *sign = NULL;
 
    if (!format)
        return E_INVALIDARG;
 
    /* Validate reading/flow direction here, layout creation won't complain about
       invalid combinations. */
    reading = IDWriteTextFormat_GetReadingDirection(format);
    flow = IDWriteTextFormat_GetFlowDirection(format);
 
    if ((is_reading_direction_horz(reading) && is_flow_direction_horz(flow)) ||
        (is_reading_direction_vert(reading) && is_flow_direction_vert(flow)))
        return DWRITE_E_FLOWDIRECTIONCONFLICTS;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDWriteInlineObject_iface.lpVtbl = &dwritetrimmingsignvtbl;
    object->refcount = 1;
 
    hr = IDWriteFactory7_CreateTextLayout(factory, L"\x2026", 1, format, 0.0f, 0.0f, &object->layout);
    if (FAILED(hr))
    {
        free(object);
        return hr;
    }
 
    IDWriteTextLayout_SetWordWrapping(object->layout, DWRITE_WORD_WRAPPING_NO_WRAP);
    IDWriteTextLayout_SetParagraphAlignment(object->layout, DWRITE_PARAGRAPH_ALIGNMENT_NEAR);
    IDWriteTextLayout_SetTextAlignment(object->layout, DWRITE_TEXT_ALIGNMENT_LEADING);
 
    *sign = &object->IDWriteInlineObject_iface;
 
    return S_OK;
}

Referenced by dwritefactory_CreateEllipsisTrimmingSign().

create_typography()

HRESULT create_typography

(

IDWriteTypography **

ret

)

Definition at line 5461 of file layout.c.

{
    struct dwrite_typography *typography;
 
    *ret = NULL;
 
    if (!(typography = calloc(1, sizeof(*typography))))
        return E_OUTOFMEMORY;
 
    typography->IDWriteTypography_iface.lpVtbl = &dwritetypographyvtbl;
    typography->refcount = 1;
 
    *ret = &typography->IDWriteTypography_iface;
 
    return S_OK;
}

Referenced by dwritefactory_CreateTypography().

debugstr_matrix()

static const char * debugstr_matrix ( const DWRITE_MATRIX *  m )

inlinestatic

Definition at line 76 of file dwrite_private.h.

{
    if (!m) return "(null)";
    return wine_dbg_sprintf("{%.2f,%.2f,%.2f,%.2f,%.2f,%.2f}", m->m11, m->m12, m->m21, m->m22,
        m->dx, m->dy);
}

Referenced by dwritefontface2_GetRecommendedRenderingMode(), dwritefontface3_GetRecommendedRenderingMode(), dwritefontface_GetGdiCompatibleGlyphMetrics(), GdipCloneMatrix(), GdipDrawDriverString(), GdipGetLineTransform(), GdipGetMatrixElements(), GdipGetPathGradientTransform(), GdipGetPathWorldBounds(), GdipGetPathWorldBoundsI(), GdipGetPenTransform(), GdipGetRegionScansCount(), GdipGetTextureTransform(), GdipGetWorldTransform(), GdipInvertMatrix(), GdipIsMatrixEqual(), GdipIsMatrixIdentity(), GdipIsMatrixInvertible(), GdipMeasureDriverString(), GdipMultiplyLineTransform(), GdipMultiplyMatrix(), GdipMultiplyPathGradientTransform(), GdipMultiplyPenTransform(), GdipMultiplyTextureTransform(), GdipMultiplyWorldTransform(), GdipRotateMatrix(), GdipScaleMatrix(), GdipSetLineTransform(), GdipSetMatrixElements(), GdipSetPathGradientTransform(), GdipSetPenTransform(), GdipSetTextureTransform(), GdipSetWorldTransform(), GdipShearMatrix(), GdipTransformMatrixPoints(), GdipTransformMatrixPointsI(), GdipTransformPath(), GdipTransformRegion(), GdipTranslateMatrix(), GdipVectorTransformMatrixPoints(), GdipVectorTransformMatrixPointsI(), GdipWarpPath(), and GdipWidenPath().

debugstr_range()

static const char * debugstr_range ( const DWRITE_TEXT_RANGE *  range )

inlinestatic

Definition at line 71 of file dwrite_private.h.

{
    return wine_dbg_sprintf("%u:%u", range->startPosition, range->length);
}

Referenced by dwritetextlayout1_SetCharacterSpacing(), dwritetextlayout1_SetPairKerning(), dwritetextlayout4_SetFontAxisValues(), dwritetextlayout_SetDrawingEffect(), dwritetextlayout_SetFontCollection(), dwritetextlayout_SetFontFamilyName(), dwritetextlayout_SetFontSize(), dwritetextlayout_SetFontStretch(), dwritetextlayout_SetFontStyle(), dwritetextlayout_SetFontWeight(), dwritetextlayout_SetInlineObject(), dwritetextlayout_SetLocaleName(), dwritetextlayout_SetStrikethrough(), dwritetextlayout_SetTypography(), and dwritetextlayout_SetUnderline().

debugstr_sa_script()

const char * debugstr_sa_script

(

UINT16

script

)

Definition at line 209 of file analyzer.c.

{
    return script < Script_LastId ? debugstr_fourcc(dwritescripts_properties[script].props.isoScriptCode) : "undefined";
}

Referenced by dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(), dwritetextanalyzer_GetGlyphPlacements(), dwritetextanalyzer_GetGlyphs(), and dwritetextlayout_sink_SetScriptAnalysis().

dwrite_array_reserve()

static BOOL dwrite_array_reserve ( void **  elements, size_t *  capacity, size_t  count, size_t  size  )

inlinestatic

Definition at line 83 of file dwrite_private.h.

{
    size_t new_capacity, max_capacity;
    void *new_elements;
 
    if (count <= *capacity)
        return TRUE;
 
    max_capacity = ~(SIZE_T)0 / size;
    if (count > max_capacity)
        return FALSE;
 
    new_capacity = max(4, *capacity);
    while (new_capacity < count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
    if (new_capacity < count)
        new_capacity = max_capacity;
 
    new_elements = realloc(*elements, new_capacity * size);
    if (!new_elements)
        return FALSE;
 
    *elements = new_elements;
    *capacity = new_capacity;
 
    return TRUE;
}

Referenced by add_localizedstring(), clone_localizedstrings(), create_system_path_list(), dwritefontface_GetGlyphRunOutline(), dwritetypography_AddFontFeature(), fallback_locale_add_mapping(), fontcollection_add_family(), fontfallbackbuilder_AddMapping(), fontfamily_add_font(), fontset_builder_add_entry(), inmemoryfontfileloader_CreateInMemoryFontFileReference(), layout_set_line_metrics(), opentype_get_typographic_features(), opentype_layout_add_lookups(), and shape_add_feature_full().

dwrite_cmap_init()

void dwrite_cmap_init	(	struct dwrite_cmap *	cmap,
		IDWriteFontFile *	file,
		unsigned int	face_index,
		DWRITE_FONT_FACE_TYPE	face_type
	)

Definition at line 1818 of file opentype.c.

{
    static const UINT16 encodings[][2] =
    {
        { 3, 0 }, /* MS Symbol encoding is preferred. */
        { 3, 10 },
        { 0, 6 },
        { 0, 4 },
        { 3, 1 },
        { 0, 3 },
        { 0, 2 },
        { 0, 1 },
        { 0, 0 },
    };
    const struct cmap_encoding_record *records, *found_record = NULL;
    unsigned int length, offset, format, count, f, i, num_records;
    struct file_stream_desc stream_desc;
    struct dwrite_fonttable table;
    const UINT16 *pair = NULL;
    HRESULT hr;
 
    if (cmap->data) return;
 
    /* For fontface stream is already available and preset. */
    if (!cmap->stream && FAILED(hr = get_filestream_from_file(file, &cmap->stream)))
    {
        WARN("Failed to get file stream, hr %#lx.\n", hr);
        goto failed;
    }
 
    stream_desc.stream = cmap->stream;
    stream_desc.face_type = face_type;
    stream_desc.face_index = face_index;
 
    opentype_get_font_table(&stream_desc, MS_CMAP_TAG, &table);
    if (!table.exists)
        goto failed;
    cmap->table_context = table.context;
 
    num_records = table_read_be_word(&table, 2);
    records = table_read_ensure(&table, 4, sizeof(*records) * num_records);
 
    for (i = 0; i < ARRAY_SIZE(encodings); ++i)
    {
        pair = encodings[i];
        if ((found_record = bsearch(pair, records, num_records, sizeof(*records), cmap_header_compare)))
            break;
    }
 
    if (!found_record)
    {
        WARN("No suitable cmap table were found.\n");
        goto failed;
    }
 
    /* Symbol encoding. */
    cmap->symbol = pair[0] == 3 && pair[1] == 0;
    offset = GET_BE_DWORD(found_record->offset);
 
    format = table_read_be_word(&table, offset);
 
    switch (format)
    {
        case 0:
            cmap->data = table_read_ensure(&table, offset + 6, 256);
            cmap->get_glyph = opentype_cmap_format0_get_glyph;
            cmap->get_ranges = opentype_cmap_format0_get_ranges;
            break;
        case 4:
            length = table_read_be_word(&table, offset + 2);
            cmap->u.format4.seg_count = count = table_read_be_word(&table, offset + 6) / 2;
            cmap->u.format4.ends = table_read_ensure(&table, offset + 14, count * 2);
            cmap->u.format4.starts = cmap->u.format4.ends + count + 1;
            cmap->u.format4.id_delta = cmap->u.format4.starts + count;
            cmap->u.format4.id_range_offset = cmap->u.format4.id_delta + count;
            cmap->u.format4.glyph_id_array = cmap->data = cmap->u.format4.id_range_offset + count;
            cmap->u.format4.glyph_id_array_len = (length - 16 - 8 * count) / 2;
            cmap->get_glyph = opentype_cmap_format4_get_glyph;
            cmap->get_ranges = opentype_cmap_format4_get_ranges;
            break;
        case 6:
        case 10:
            /* Format 10 uses 4 byte fields. */
            f = format == 6 ? 1 : 2;
            cmap->u.format6_10.first = table_read_be_word(&table, offset + f * 6);
            count = table_read_be_word(&table, offset + f * 8);
            cmap->u.format6_10.last = cmap->u.format6_10.first + count;
            cmap->data = table_read_ensure(&table, offset + f * 10, count * 2);
            cmap->get_glyph = opentype_cmap_format6_10_get_glyph;
            cmap->get_ranges = opentype_cmap_format6_10_get_ranges;
            break;
        case 12:
        case 13:
            cmap->u.format12_13.group_count = count = table_read_be_dword(&table, offset + 12);
            cmap->data = table_read_ensure(&table, offset + 16, count * 3 * 4);
            cmap->get_glyph = format == 12 ? opentype_cmap_format12_get_glyph : opentype_cmap_format13_get_glyph;
            cmap->get_ranges = opentype_cmap_format12_13_get_ranges;
            break;
        default:
            WARN("Unhandled subtable format %u.\n", format);
    }
 
failed:
 
    if (!cmap->data)
    {
        /* Dummy implementation, returns 0 unconditionally. */
        cmap->data = cmap;
        cmap->get_glyph = opentype_cmap_dummy_get_glyph;
        cmap->get_ranges = opentype_cmap_dummy_get_ranges;
    }
}

Referenced by dwritefont1_GetUnicodeRanges(), dwritefont_has_character(), dwritefontface1_GetUnicodeRanges(), and dwritefontface_get_glyph().

dwrite_cmap_release()

void dwrite_cmap_release

(

struct dwrite_cmap *

cmap

)

Definition at line 1932 of file opentype.c.

{
    if (cmap->stream)
    {
        IDWriteFontFileStream_ReleaseFileFragment(cmap->stream, cmap->table_context);
        IDWriteFontFileStream_Release(cmap->stream);
    }
    cmap->data = NULL;
    cmap->stream = NULL;
}

Referenced by dwritefontface_Release(), and release_font_data().

dwrite_fontface_get_glyph_bbox()

void dwrite_fontface_get_glyph_bbox	(	IDWriteFontFace *	fontface,
		struct dwrite_glyphbitmap *	bitmap
	)

Definition at line 158 of file font.c.

{
    struct cache_key key = { .size = bitmap->emsize, .glyph = bitmap->glyph, .mode = DWRITE_MEASURING_MODE_NATURAL };
    struct dwrite_fontface *fontface = unsafe_impl_from_IDWriteFontFace(iface);
    struct get_glyph_bbox_params params;
    struct cache_entry *entry;
 
    params.object = fontface->get_font_object(fontface);
    params.simulations = bitmap->simulations;
    params.glyph = bitmap->glyph;
    params.emsize = bitmap->emsize;
    matrix_2x2_from_dwrite_matrix(&params.m, bitmap->m ? bitmap->m : &identity);
 
    EnterCriticalSection(&fontface->cs);
    /* For now bypass cache for transformed cases. */
    if (bitmap->m && memcmp(&params.m, &identity_2x2, sizeof(params.m)))
    {
        params.bbox = &bitmap->bbox;
        UNIX_CALL(get_glyph_bbox, &params);
    }
    else if ((entry = fontface_get_cache_entry(fontface, 0, &key)))
    {
        if (!entry->has_bbox)
        {
            params.bbox = &entry->bbox;
            UNIX_CALL(get_glyph_bbox, &params);
            entry->has_bbox = 1;
        }
        bitmap->bbox = entry->bbox;
    }
    LeaveCriticalSection(&fontface->cs);
}

Referenced by glyphrunanalysis_get_texturebounds(), glyphrunanalysis_render(), and layout_get_erun_bbox().

dwrite_matrix_multiply()

static void dwrite_matrix_multiply ( DWRITE_MATRIX *  a, const DWRITE_MATRIX *  b  )

inlinestatic

Definition at line 129 of file dwrite_private.h.

{
    DWRITE_MATRIX tmp = *a;
 
    a->m11 = tmp.m11 * b->m11 + tmp.m12 * b->m21;
    a->m12 = tmp.m11 * b->m12 + tmp.m12 * b->m22;
    a->m21 = tmp.m21 * b->m11 + tmp.m22 * b->m21;
    a->m22 = tmp.m21 * b->m12 + tmp.m22 * b->m22;
    a->dx = tmp.dx * b->m11 + tmp.dy * b->m21 + b->dx;
    a->dy = tmp.dy * b->m12 + tmp.dy * b->m22 + b->dx;
}

Referenced by dwritefactory_CreateGlyphRunAnalysis(), and rendertarget_DrawGlyphRun().

factory_cache_fontface()

struct fontfacecached * factory_cache_fontface	(	IDWriteFactory7 *	factory,
		struct list *	fontfaces,
		IDWriteFontFace5 *	fontface
	)

Definition at line 1002 of file main.c.

{
    struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
    struct fontfacecached *cached;
 
    /* new cache entry */
    if (!(cached = malloc(sizeof(*cached))))
        return NULL;
 
    cached->fontface = fontface;
    EnterCriticalSection(&factory->cs);
    list_add_tail(fontfaces, &cached->entry);
    LeaveCriticalSection(&factory->cs);
 
    return cached;
}

Referenced by create_fontface().

factory_detach_fontcollection()

void factory_detach_fontcollection	(	IDWriteFactory7 *	factory,
		IDWriteFontCollection3 *	collection
	)

Definition at line 2092 of file main.c.

{
    struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(factory->system_collections); ++i)
        InterlockedCompareExchangePointer((void **)&factory->system_collections[i], NULL, collection);
    InterlockedCompareExchangePointer((void **)&factory->eudc_collection, NULL, collection);
    IDWriteFactory7_Release(iface);
}

Referenced by dwritefontcollection_Release().

factory_detach_gdiinterop()

void factory_detach_gdiinterop	(	IDWriteFactory7 *	factory,
		IDWriteGdiInterop1 *	interop
	)

Definition at line 2103 of file main.c.

{
    struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
    factory->gdiinterop = NULL;
    IDWriteFactory7_Release(iface);
}

Referenced by gdiinterop_Release().

factory_get_cached_fontface()

HRESULT factory_get_cached_fontface	(	IDWriteFactory7 *	factory,
		IDWriteFontFile *const *	files,
		UINT32	num_files,
		DWRITE_FONT_SIMULATIONS	simulations,
		struct list **	cache,
		REFIID	riid,
		void **	obj
	)

Definition at line 926 of file main.c.

{
    struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
    struct fontfacecached *cached;
    IDWriteFontFileLoader *loader;
    struct list *fontfaces;
    UINT32 key_size;
    const void *key;
    HRESULT hr;
 
    *obj = NULL;
    *cached_list = NULL;
 
    hr = IDWriteFontFile_GetReferenceKey(*font_files, &key, &key_size);
    if (FAILED(hr))
        return hr;
 
    hr = IDWriteFontFile_GetLoader(*font_files, &loader);
    if (FAILED(hr))
        return hr;
 
    if (loader == factory->localfontfileloader) {
        fontfaces = &factory->localfontfaces;
        IDWriteFontFileLoader_Release(loader);
    }
    else {
        struct fileloader *fileloader = factory_get_file_loader(factory, loader);
        IDWriteFontFileLoader_Release(loader);
        if (!fileloader)
            return E_INVALIDARG;
        fontfaces = &fileloader->fontfaces;
    }
 
    *cached_list = fontfaces;
 
    EnterCriticalSection(&factory->cs);
 
    /* search through cache list */
    LIST_FOR_EACH_ENTRY(cached, fontfaces, struct fontfacecached, entry) {
        UINT32 cached_key_size, count = 1, cached_face_index;
        DWRITE_FONT_SIMULATIONS cached_simulations;
        const void *cached_key;
        IDWriteFontFile *file;
 
        cached_face_index = IDWriteFontFace5_GetIndex(cached->fontface);
        cached_simulations = IDWriteFontFace5_GetSimulations(cached->fontface);
 
        /* skip earlier */
        if (cached_face_index != index || cached_simulations != simulations)
            continue;
 
        hr = IDWriteFontFace5_GetFiles(cached->fontface, &count, &file);
        if (FAILED(hr))
            break;
 
        hr = IDWriteFontFile_GetReferenceKey(file, &cached_key, &cached_key_size);
        IDWriteFontFile_Release(file);
        if (FAILED(hr))
            break;
 
        if (cached_key_size == key_size && !memcmp(cached_key, key, key_size))
        {
            if (FAILED(hr = IDWriteFontFace5_QueryInterface(cached->fontface, riid, obj)))
                WARN("Failed to get %s from fontface, hr %#lx.\n", debugstr_guid(riid), hr);
 
            TRACE("returning cached fontface %p\n", cached->fontface);
            break;
        }
    }
 
    LeaveCriticalSection(&factory->cs);
 
    return *obj ? S_OK : S_FALSE;
}

Referenced by dwritefactory_CreateFontFace(), and get_fontface_from_font().

factory_lock()

void factory_lock

(

IDWriteFactory7 *

factory

)

Definition at line 914 of file main.c.

{
    struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
    EnterCriticalSection(&factory->cs);
}

Referenced by dwritefontface_Release().

factory_unlock()

void factory_unlock

(

IDWriteFactory7 *

factory

)

Definition at line 920 of file main.c.

{
    struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
    LeaveCriticalSection(&factory->cs);
}

Referenced by dwritefontface_Release().

fontface_detach_from_cache()

void fontface_detach_from_cache

(

IDWriteFontFace5 *

fontface

)

Definition at line 764 of file font.c.

{
    struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
    fontface->cached = NULL;
}

Referenced by release_fontface_cache().

fontface_get_scaled_design_advance()

float fontface_get_scaled_design_advance	(	struct dwrite_fontface *	fontface,
		DWRITE_MEASURING_MODE	measuring_mode,
		float	emsize,
		float	ppdip,
		const DWRITE_MATRIX *	transform,
		UINT16	glyph,
		BOOL	is_sideways
	)

Definition at line 6384 of file font.c.

{
    unsigned int upem = fontface->metrics.designUnitsPerEm;
    int advance;
 
    if (is_sideways)
        FIXME("Sideways mode is not supported.\n");
 
    EnterCriticalSection(&fontface->cs);
    advance = fontface_get_design_advance(fontface, measuring_mode, emsize, ppdip, transform, glyph, is_sideways);
    LeaveCriticalSection(&fontface->cs);
 
    switch (measuring_mode)
    {
        case DWRITE_MEASURING_MODE_NATURAL:
            return (float)advance * emsize / (float)upem;
        case DWRITE_MEASURING_MODE_GDI_NATURAL:
        case DWRITE_MEASURING_MODE_GDI_CLASSIC:
            return ppdip > 0.0f ? floorf(advance * emsize * ppdip / upem + 0.5f) / ppdip : 0.0f;
        default:
            WARN("Unknown measuring mode %u.\n", measuring_mode);
            return 0.0f;
    }
}

Referenced by compute_glyph_origins(), create_colorglyphenum(), dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(), and dwritetextanalyzer_GetGlyphPlacements().

fontface_get_shaping_cache()

struct scriptshaping_cache * fontface_get_shaping_cache

(

struct dwrite_fontface *

fontface

)

Definition at line 559 of file font.c.

{
    if (fontface->shaping_cache)
        return fontface->shaping_cache;
 
    return fontface->shaping_cache = create_scriptshaping_cache(fontface, &dwrite_font_ops);
}

Referenced by dwritetextanalyzer2_CheckTypographicFeature(), dwritetextanalyzer2_GetTypographicFeatures(), dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(), dwritetextanalyzer_GetGlyphPlacements(), dwritetextanalyzer_GetGlyphs(), opentype_get_vertical_glyph_variants(), and opentype_has_vertical_variants().

format_get_font_axisvalues()

HRESULT format_get_font_axisvalues	(	struct dwrite_textformat_data *	format,
		DWRITE_FONT_AXIS_VALUE *	axis_values,
		unsigned int	num_values
	)

Definition at line 159 of file format.c.

{
    if (!format->axis_values_count)
    {
        if (num_values) memset(axis_values, 0, num_values * sizeof(*axis_values));
        return S_OK;
    }
 
    if (num_values < format->axis_values_count)
        return E_NOT_SUFFICIENT_BUFFER;
 
    memcpy(axis_values, format->axis_values, min(num_values, format->axis_values_count) * sizeof(*axis_values));
 
    return S_OK;
}

Referenced by dwritetextformat3_GetFontAxisValues(), and dwritetextformat3_layout_GetFontAxisValues().

format_get_fontfallback()

HRESULT format_get_fontfallback	(	const struct dwrite_textformat_data *	format,
		IDWriteFontFallback **	fallback
	)

Definition at line 176 of file format.c.

{
    *fallback = format->fallback;
    if (*fallback)
        IDWriteFontFallback_AddRef(*fallback);
    return S_OK;
}

Referenced by dwritetextformat1_GetFontFallback(), and dwritetextlayout2_GetFontFallback().

format_set_flowdirection()

HRESULT format_set_flowdirection	(	struct dwrite_textformat_data *	format,
		DWRITE_FLOW_DIRECTION	direction,
		BOOL *	changed
	)

Definition at line 95 of file format.c.

{
    if ((UINT32)direction > DWRITE_FLOW_DIRECTION_RIGHT_TO_LEFT)
        return E_INVALIDARG;
    if (changed) *changed = format->flow != direction;
    format->flow = direction;
    return S_OK;
}

Referenced by dwritetextformat_layout_SetFlowDirection(), and dwritetextformat_SetFlowDirection().

format_set_font_axisvalues()

HRESULT format_set_font_axisvalues	(	struct dwrite_textformat_data *	format,
		DWRITE_FONT_AXIS_VALUE const *	axis_values,
		unsigned int	num_values
	)

Definition at line 141 of file format.c.

{
    free(format->axis_values);
    format->axis_values = NULL;
    format->axis_values_count = 0;
 
    if (num_values)
    {
        if (!(format->axis_values = calloc(num_values, sizeof(*axis_values))))
            return E_OUTOFMEMORY;
        memcpy(format->axis_values, axis_values, num_values * sizeof(*axis_values));
        format->axis_values_count = num_values;
    }
 
    return S_OK;
}

Referenced by dwritetextformat3_layout_SetFontAxisValues(), and dwritetextformat3_SetFontAxisValues().

format_set_fontfallback()

HRESULT format_set_fontfallback	(	struct dwrite_textformat_data *	format,
		IDWriteFontFallback *	fallback
	)

Definition at line 184 of file format.c.

{
    if (format->fallback)
        IDWriteFontFallback_Release(format->fallback);
    format->fallback = fallback;
    if (fallback)
        IDWriteFontFallback_AddRef(fallback);
    return S_OK;
}

Referenced by dwritetextformat1_SetFontFallback(), and dwritetextlayout2_SetFontFallback().

format_set_linespacing()

HRESULT format_set_linespacing	(	struct dwrite_textformat_data *	format,
		DWRITE_LINE_SPACING const *	spacing,
		BOOL *	changed
	)

Definition at line 128 of file format.c.

{
    if (spacing->height < 0.0f || spacing->leadingBefore < 0.0f || spacing->leadingBefore > 1.0f ||
        (UINT32)spacing->method > DWRITE_LINE_SPACING_METHOD_PROPORTIONAL)
        return E_INVALIDARG;
 
    if (changed)
        *changed = memcmp(spacing, &format->spacing, sizeof(*spacing));
 
    format->spacing = *spacing;
    return S_OK;
}

Referenced by dwritetextformat2_SetLineSpacing(), dwritetextformat_SetLineSpacing(), and dwritetextlayout3_SetLineSpacing().

format_set_optical_alignment()

HRESULT format_set_optical_alignment	(	struct dwrite_textformat_data *	format,
		DWRITE_OPTICAL_ALIGNMENT	alignment
	)

Definition at line 194 of file format.c.

{
    if ((UINT32)alignment > DWRITE_OPTICAL_ALIGNMENT_NO_SIDE_BEARINGS)
        return E_INVALIDARG;
    format->optical_alignment = alignment;
    return S_OK;
}

Referenced by dwritetextformat1_layout_SetOpticalAlignment(), and dwritetextformat1_SetOpticalAlignment().

format_set_paralignment()

HRESULT format_set_paralignment	(	struct dwrite_textformat_data *	format,
		DWRITE_PARAGRAPH_ALIGNMENT	alignment,
		BOOL *	changed
	)

Definition at line 68 of file format.c.

{
    if ((UINT32)alignment > DWRITE_PARAGRAPH_ALIGNMENT_CENTER)
        return E_INVALIDARG;
    if (changed) *changed = format->paralign != alignment;
    format->paralign = alignment;
    return S_OK;
}

Referenced by dwritetextformat_layout_SetParagraphAlignment(), and dwritetextformat_SetParagraphAlignment().

format_set_readingdirection()

HRESULT format_set_readingdirection	(	struct dwrite_textformat_data *	format,
		DWRITE_READING_DIRECTION	direction,
		BOOL *	changed
	)

Definition at line 77 of file format.c.

{
    if ((UINT32)direction > DWRITE_READING_DIRECTION_BOTTOM_TO_TOP)
        return E_INVALIDARG;
    if (changed) *changed = format->readingdir != direction;
    format->readingdir = direction;
    return S_OK;
}

Referenced by dwritetextformat_layout_SetReadingDirection(), and dwritetextformat_SetReadingDirection().

format_set_textalignment()

HRESULT format_set_textalignment	(	struct dwrite_textformat_data *	format,
		DWRITE_TEXT_ALIGNMENT	alignment,
		BOOL *	changed
	)

Definition at line 58 of file format.c.

{
    if ((UINT32)alignment > DWRITE_TEXT_ALIGNMENT_JUSTIFIED)
        return E_INVALIDARG;
    if (changed) *changed = format->textalignment != alignment;
    format->textalignment = alignment;
    return S_OK;
}

Referenced by dwritetextformat_layout_SetTextAlignment(), and dwritetextformat_SetTextAlignment().

format_set_trimming()

HRESULT format_set_trimming	(	struct dwrite_textformat_data *	format,
		DWRITE_TRIMMING const *	trimming,
		IDWriteInlineObject *	trimming_sign,
		BOOL *	changed
	)

Definition at line 104 of file format.c.

{
    if (changed)
        *changed = FALSE;
 
    if ((UINT32)trimming->granularity > DWRITE_TRIMMING_GRANULARITY_WORD)
        return E_INVALIDARG;
 
    if (changed) {
        *changed = !!memcmp(&format->trimming, trimming, sizeof(*trimming));
        if (format->trimmingsign != trimming_sign)
            *changed = TRUE;
    }
 
    format->trimming = *trimming;
    if (format->trimmingsign)
        IDWriteInlineObject_Release(format->trimmingsign);
    format->trimmingsign = trimming_sign;
    if (format->trimmingsign)
        IDWriteInlineObject_AddRef(format->trimmingsign);
    return S_OK;
}

Referenced by dwritetextformat_layout_SetTrimming(), and dwritetextformat_SetTrimming().

format_set_vertical_orientation()

HRESULT format_set_vertical_orientation	(	struct dwrite_textformat_data *	format,
		DWRITE_VERTICAL_GLYPH_ORIENTATION	orientation,
		BOOL *	changed
	)

Definition at line 202 of file format.c.

{
    if ((UINT32)orientation > DWRITE_VERTICAL_GLYPH_ORIENTATION_STACKED)
        return E_INVALIDARG;
 
    if (changed)
        *changed = format->vertical_orientation != orientation;
 
    format->vertical_orientation = orientation;
    return S_OK;
}

Referenced by dwritetextformat1_SetVerticalGlyphOrientation(), and layout_set_vertical_orientation().

format_set_wordwrapping()

HRESULT format_set_wordwrapping	(	struct dwrite_textformat_data *	format,
		DWRITE_WORD_WRAPPING	wrapping,
		BOOL *	changed
	)

Definition at line 86 of file format.c.

{
    if ((UINT32)wrapping > DWRITE_WORD_WRAPPING_CHARACTER)
        return E_INVALIDARG;
    if (changed) *changed = format->wrapping != wrapping;
    format->wrapping = wrapping;
    return S_OK;
}

Referenced by dwritetextformat_layout_SetWordWrapping(), and dwritetextformat_SetWordWrapping().

get_eudc_fontcollection()

HRESULT get_eudc_fontcollection	(	IDWriteFactory7 *	factory,
		IDWriteFontCollection3 **	collection
	)

Definition at line 5223 of file font.c.

{
    struct dwrite_fontcollection *collection;
    WCHAR eudckeypathW[16];
    HKEY eudckey;
    UINT32 index;
    BOOL exists;
    LONG retval;
    HRESULT hr;
    size_t i;
 
    TRACE("building EUDC font collection for factory %p, ACP %u\n", factory, GetACP());
 
    *ret = NULL;
 
    if (!(collection = calloc(1, sizeof(*collection))))
        return E_OUTOFMEMORY;
 
    hr = init_font_collection(collection, factory, DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE, FALSE);
    if (FAILED(hr))
    {
        free(collection);
        return hr;
    }
 
    *ret = &collection->IDWriteFontCollection3_iface;
 
    /* return empty collection if EUDC fonts are not configured */
    swprintf(eudckeypathW, ARRAY_SIZE(eudckeypathW), L"EUDC\\%u", GetACP());
    if (RegOpenKeyExW(HKEY_CURRENT_USER, eudckeypathW, 0, GENERIC_READ, &eudckey))
        return S_OK;
 
    retval = ERROR_SUCCESS;
    index = 0;
    while (retval != ERROR_NO_MORE_ITEMS) {
        WCHAR keynameW[64], pathW[MAX_PATH];
        DWORD type, path_len, name_len;
 
        path_len = ARRAY_SIZE(pathW);
        name_len = ARRAY_SIZE(keynameW);
        retval = RegEnumValueW(eudckey, index++, keynameW, &name_len, NULL, &type, (BYTE*)pathW, &path_len);
        if (retval || type != REG_SZ)
            continue;
 
        hr = eudc_collection_add_family(factory, collection, keynameW, pathW);
        if (hr != S_OK)
            WARN("failed to add family %s, path %s\n", debugstr_w(keynameW), debugstr_w(pathW));
    }
    RegCloseKey(eudckey);
 
    /* try to add global default if not defined for specific codepage */
    exists = FALSE;
    hr = IDWriteFontCollection3_FindFamilyName(&collection->IDWriteFontCollection3_iface, L"",
        &index, &exists);
    if (FAILED(hr) || !exists)
    {
        hr = eudc_collection_add_family(factory, collection, L"", L"EUDC.TTE");
        if (hr != S_OK)
            WARN("failed to add global default EUDC font, 0x%08lx\n", hr);
    }
 
    /* EUDC collection offers simulated faces too */
    for (i = 0; i < collection->count; ++i)
    {
        fontfamily_add_bold_simulated_face(collection->family_data[i]);
        fontfamily_add_oblique_simulated_face(collection->family_data[i]);
    }
 
    return S_OK;
}

Referenced by dwritefactory1_GetEudcFontCollection().

get_family_names_from_stream()

HRESULT get_family_names_from_stream	(	IDWriteFontFileStream *	,
		UINT32	,
		DWRITE_FONT_FACE_TYPE	,
		IDWriteLocalizedStrings **
	)

get_filestream_from_file()

HRESULT get_filestream_from_file	(	IDWriteFontFile *	file,
		IDWriteFontFileStream **	stream
	)

Definition at line 3563 of file font.c.

{
    IDWriteFontFileLoader *loader;
    const void *key;
    UINT32 key_size;
    HRESULT hr;
 
    *stream = NULL;
 
    hr = IDWriteFontFile_GetReferenceKey(file, &key, &key_size);
    if (FAILED(hr))
        return hr;
 
    hr = IDWriteFontFile_GetLoader(file, &loader);
    if (FAILED(hr))
        return hr;
 
    hr = IDWriteFontFileLoader_CreateStreamFromKey(loader, key, key_size, stream);
    IDWriteFontFileLoader_Release(loader);
    if (FAILED(hr))
        return hr;
 
    return hr;
}

Referenced by create_font_collection(), create_font_collection_from_set(), create_font_resource(), dwrite_cmap_init(), dwritefactory_CreateFontFace(), eudc_collection_add_family(), fontset_entry_get_property(), get_font_info_strings(), and get_fontface_from_font().

get_fontface_table()

const void * get_fontface_table	(	IDWriteFontFace5 *	fontface,
		UINT32	tag,
		struct dwrite_fonttable *	table
	)

Definition at line 666 of file font.c.

{
    HRESULT hr;
 
    if (table->data || !table->exists)
        return table->data;
 
    table->exists = FALSE;
    hr = IDWriteFontFace5_TryGetFontTable(fontface, tag, (const void **)&table->data, &table->size, &table->context,
        &table->exists);
    if (FAILED(hr) || !table->exists) {
        TRACE("Font does not have %s table\n", debugstr_fourcc(tag));
        return NULL;
    }
 
    return table->data;
}

Referenced by create_colorglyphenum(), get_fontface_cpal(), get_fontface_gasp(), get_fontface_vdmx(), opentype_get_cblc_formats(), and opentype_get_sbix_formats().

get_fontsig_from_font()

HRESULT get_fontsig_from_font	(	IDWriteFont *	iface,
		FONTSIGNATURE *	fontsig
	)

Definition at line 2566 of file font.c.

{
    struct dwrite_font *font = unsafe_impl_from_IDWriteFont(iface);
    *fontsig = font->data->fontsig;
    return S_OK;
}

Referenced by gdiinterop1_GetFontSignature().

get_fontsig_from_fontface()

HRESULT get_fontsig_from_fontface	(	IDWriteFontFace *	iface,
		FONTSIGNATURE *	fontsig
	)

Definition at line 2573 of file font.c.

{
    struct dwrite_fontface *fontface = unsafe_impl_from_IDWriteFontFace(iface);
    *fontsig = fontface->fontsig;
    return S_OK;
}

Referenced by gdiinterop1_GetFontSignature_().

get_local_fontfile_loader()

IDWriteFontFileLoader * get_local_fontfile_loader

(

void

)

Definition at line 6000 of file font.c.

{
    return (IDWriteFontFileLoader *)&local_fontfile_loader.IDWriteLocalFontFileLoader_iface;
}

Referenced by init_dwritefactory().

get_local_refkey()

HRESULT get_local_refkey	(	const WCHAR *	path,
		const FILETIME *	writetime,
		void **	key,
		UINT32 *	size
	)

Definition at line 6005 of file font.c.

{
    struct local_refkey *refkey;
 
    if (!path)
        return E_INVALIDARG;
 
    *size = FIELD_OFFSET(struct local_refkey, name) + (wcslen(path)+1)*sizeof(WCHAR);
    *key = NULL;
 
    if (!(refkey = malloc(*size)))
        return E_OUTOFMEMORY;
 
    if (writetime)
        refkey->writetime = *writetime;
    else {
        WIN32_FILE_ATTRIBUTE_DATA info;
 
        if (GetFileAttributesExW(path, GetFileExInfoStandard, &info))
            refkey->writetime = info.ftLastWriteTime;
        else
            memset(&refkey->writetime, 0, sizeof(refkey->writetime));
    }
    wcscpy(refkey->name, path);
 
    *key = refkey;
 
    return S_OK;
}

Referenced by dwritefactory_CreateFontFileReference().

get_localizedstrings_count()

unsigned int get_localizedstrings_count

(

IDWriteLocalizedStrings *

strings

)

Definition at line 563 of file main.c.

{
    struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
    return strings->count;
}

Referenced by localizedstrings_GetCount(), and opentype_get_font_strings_from_id().

get_logfont_from_font()

void get_logfont_from_font	(	IDWriteFont *	iface,
		LOGFONTW *	lf
	)

Definition at line 2554 of file font.c.

{
    struct dwrite_font *font = unsafe_impl_from_IDWriteFont(iface);
    *lf = font->data->lf;
}

Referenced by gdiinterop_ConvertFontToLOGFONT().

get_logfont_from_fontface()

void get_logfont_from_fontface	(	IDWriteFontFace *	iface,
		LOGFONTW *	lf
	)

Definition at line 2560 of file font.c.

{
    struct dwrite_fontface *fontface = unsafe_impl_from_IDWriteFontFace(iface);
    *lf = fontface->lf;
}

Referenced by gdiinterop_ConvertFontFaceToLOGFONT().

get_system_fontcollection()

HRESULT get_system_fontcollection	(	IDWriteFactory7 *	factory,
		DWRITE_FONT_FAMILY_MODEL	family_model,
		IDWriteFontCollection **	collection
	)

Definition at line 5109 of file font.c.

{
    IDWriteFontFileEnumerator *enumerator;
    IDWriteFontSet *fontset;
    HRESULT hr;
 
    *collection = NULL;
 
    if (family_model == DWRITE_FONT_FAMILY_MODEL_TYPOGRAPHIC)
    {
        if (SUCCEEDED(hr = create_system_fontset(factory, &IID_IDWriteFontSet, (void **)&fontset)))
        {
            hr = create_font_collection_from_set(factory, fontset, family_model,
                    &IID_IDWriteFontCollection, (void **)collection);
            IDWriteFontSet_Release(fontset);
        }
    }
    else
    {
        if (SUCCEEDED(hr = create_system_fontfile_enumerator(factory, &enumerator)))
        {
            TRACE("Building system font collection for factory %p.\n", factory);
            hr = create_font_collection(factory, enumerator, TRUE, (IDWriteFontCollection3 **)collection);
            IDWriteFontFileEnumerator_Release(enumerator);
        }
    }
 
    return hr;
}

Referenced by factory_get_system_collection().

get_table_entry_16()

static unsigned short get_table_entry_16 ( const unsigned short *  table, WCHAR  ch  )

inlinestatic

Definition at line 113 of file dwrite_private.h.

{
    return table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
}

Referenced by bidi_compute_bracket_pairs(), computeBracketPairs(), ContextualShape_Arabic(), ContextualShape_Syriac(), mirror_char(), unicode_get_mirrored_char(), and unicode_lex().

get_table_entry_32()

static unsigned short get_table_entry_32 ( const unsigned short *  table, UINT  ch  )

inlinestatic

Definition at line 118 of file dwrite_private.h.

{
    return table[table[table[table[ch >> 12] + ((ch >> 8) & 0x0f)] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
}

Referenced by analyze_linebreaks(), arabic_get_joining_type(), BREAK_line(), classify(), get_char_bidi_class(), get_char_script(), and lb_is_newline_char().

get_text_analyzer()

IDWriteTextAnalyzer2 * get_text_analyzer

(

void

)

Definition at line 2241 of file analyzer.c.

{
    return &textanalyzer;
}

Referenced by dwritefactory_CreateTextAnalyzer(), layout_compute(), layout_itemize(), and layout_shape_run().

heap_strdupnW()

static LPWSTR heap_strdupnW ( const WCHAR *  str, UINT32  len  )

inlinestatic

Definition at line 54 of file dwrite_private.h.

{
    WCHAR *ret = NULL;
 
    if (len)
    {
        ret = malloc((len+1)*sizeof(WCHAR));
        if(ret)
        {
            memcpy(ret, str, len*sizeof(WCHAR));
            ret[len] = 0;
        }
    }
 
    return ret;
}

Referenced by init_textlayout(), and opentype_decode_namerecord().

init_local_fontfile_loader()

void init_local_fontfile_loader

(

void

)

Definition at line 5991 of file font.c.

{
    local_fontfile_loader.IDWriteLocalFontFileLoader_iface.lpVtbl = &localfontfileloadervtbl;
    local_fontfile_loader.refcount = 1;
    list_init(&local_fontfile_loader.streams);
    InitializeCriticalSectionEx(&local_fontfile_loader.cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    local_fontfile_loader.cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": localfileloader.lock");
}

Referenced by DllMain().

is_face_type_supported()

BOOL is_face_type_supported

(

DWRITE_FONT_FACE_TYPE

type

)

Definition at line 1337 of file opentype.c.

{
    return (type == DWRITE_FONT_FACE_TYPE_CFF) ||
           (type == DWRITE_FONT_FACE_TYPE_TRUETYPE) ||
           (type == DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION) ||
           (type == DWRITE_FONT_FACE_TYPE_RAW_CFF);
}

Referenced by dwritefactory_CreateFontFace(), and opentype_analyze_font().

is_simulation_valid()

static BOOL is_simulation_valid ( DWRITE_FONT_SIMULATIONS  simulations )

inlinestatic

Definition at line 123 of file dwrite_private.h.

{
    return (simulations & ~(DWRITE_FONT_SIMULATIONS_NONE | DWRITE_FONT_SIMULATIONS_BOLD |
        DWRITE_FONT_SIMULATIONS_OBLIQUE)) == 0;
}

Referenced by create_fontfacereference(), and dwritefactory_CreateFontFace().

is_system_collection()

BOOL is_system_collection

(

IDWriteFontCollection *

collection

)

Definition at line 3201 of file font.c.

{
    void *obj;
    return IDWriteFontCollection_QueryInterface(collection, &IID_issystemcollection, &obj) == S_OK;
}

Referenced by gdiinterop_ConvertFontToLOGFONT().

lb_is_newline_char()

BOOL lb_is_newline_char

(

WCHAR

ch

)

Definition at line 851 of file analyzer.c.

{
    short c = get_table_entry_32(wine_linebreak_table, ch);
    return c == b_LF || c == b_NL || c == b_CR || c == b_BK;
}

Referenced by init_cluster_metrics(), and layout_add_line().

localizedstrings_contains()

BOOL localizedstrings_contains	(	IDWriteLocalizedStrings *	strings,
		const WCHAR *	str
	)

Definition at line 569 of file main.c.

{
    struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
    unsigned int i;
 
    for (i = 0; i < strings->count; ++i)
    {
        if (!wcsicmp(strings->data[i].string, str)) return TRUE;
    }
 
    return FALSE;
}

Referenced by fontset_entry_is_matching().

opentype_analyze_container_type()

DWRITE_CONTAINER_TYPE opentype_analyze_container_type	(	void const *	data,
		UINT32	data_size
	)

Definition at line 3217 of file opentype.c.

{
    DWORD signature;
 
    if (data_size < sizeof(DWORD))
        return DWRITE_CONTAINER_TYPE_UNKNOWN;
 
    /* Both WOFF and WOFF2 start with 4 bytes signature. */
    signature = *(DWORD *)data;
 
    switch (signature)
    {
    case MS_WOFF_TAG:
        return DWRITE_CONTAINER_TYPE_WOFF;
    case MS_WOF2_TAG:
        return DWRITE_CONTAINER_TYPE_WOFF2;
    default:
        return DWRITE_CONTAINER_TYPE_UNKNOWN;
    }
}

Referenced by dwritefactory5_AnalyzeContainerType().

opentype_analyze_font()

HRESULT opentype_analyze_font	(	IDWriteFontFileStream *	stream,
		BOOL *	supported,
		DWRITE_FONT_FILE_TYPE *	file_type,
		DWRITE_FONT_FACE_TYPE *	face_type,
		UINT32 *	face_count
	)

Definition at line 1492 of file opentype.c.

{
    static dwrite_fontfile_analyzer fontfile_analyzers[] = {
        opentype_ttf_analyzer,
        opentype_otf_analyzer,
        opentype_ttc_analyzer,
        opentype_type1_analyzer,
        NULL
    };
    dwrite_fontfile_analyzer *analyzer = fontfile_analyzers;
    DWRITE_FONT_FACE_TYPE face;
    HRESULT hr;
 
    if (!face_type)
        face_type = &face;
 
    *file_type = DWRITE_FONT_FILE_TYPE_UNKNOWN;
    *face_type = DWRITE_FONT_FACE_TYPE_UNKNOWN;
    *face_count = 0;
 
    while (*analyzer) {
        hr = (*analyzer)(stream, face_count, file_type, face_type);
        if (FAILED(hr))
            return hr;
 
        if (hr == S_OK)
            break;
 
        analyzer++;
    }
 
    *supported = is_face_type_supported(*face_type);
    return S_OK;
}

Referenced by create_font_collection(), dwritefactory_CreateFontFace(), dwritefontfile_Analyze(), and eudc_collection_add_family().

opentype_cmap_get_glyph()

UINT16 opentype_cmap_get_glyph	(	const struct dwrite_cmap *	cmap,
		unsigned int	ch
	)

Definition at line 1792 of file opentype.c.

{
    UINT16 glyph;
 
    if (!cmap->get_glyph) return 0;
    glyph = cmap->get_glyph(cmap, ch);
    if (!glyph && cmap->symbol && ch <= 0xff)
        glyph = cmap->get_glyph(cmap, ch + 0xf000);
    return glyph;
}

Referenced by dwritefont_has_character(), and dwritefontface_get_glyph().

opentype_cmap_get_unicode_ranges()

HRESULT opentype_cmap_get_unicode_ranges	(	const struct dwrite_cmap *	cmap,
		unsigned int	max_count,
		DWRITE_UNICODE_RANGE *	ranges,
		unsigned int *	count
	)

Definition at line 1943 of file opentype.c.

{
    if (!cmap->data)
        return E_FAIL;
 
    *count = cmap->get_ranges(cmap, max_count, ranges);
 
    return *count > max_count ? E_NOT_SUFFICIENT_BUFFER : S_OK;
}

Referenced by dwritefont1_GetUnicodeRanges(), and dwritefontface1_GetUnicodeRanges().

opentype_colr_next_glyph()

void opentype_colr_next_glyph	(	const struct dwrite_fonttable *	table,
		struct dwrite_colorglyph *	color_glyph
	)

Definition at line 3041 of file opentype.c.

{
    const struct colr_layer_record *layer;
    const struct colr_header *header;
 
    /* iterated all the way through */
    if (glyph->layer == glyph->num_layers)
        return;
 
    if (!(header = table_read_ensure(colr, 0, sizeof(*header))))
        return;
 
    glyph->layer++;
 
    if ((layer = table_read_ensure(colr, GET_BE_DWORD(header->offset_layer_records),
            (glyph->first_layer + glyph->layer) * sizeof(*layer))))
    {
        layer += glyph->first_layer + glyph->layer;
        glyph->glyph = GET_BE_WORD(layer->glyph);
        glyph->palette_index = GET_BE_WORD(layer->palette_index);
    }
}

Referenced by colorglyphenum_build_color_run().

opentype_get_colr_glyph()

HRESULT opentype_get_colr_glyph	(	const struct dwrite_fonttable *	table,
		UINT16	glyph,
		struct dwrite_colorglyph *	color_glyph
	)

Definition at line 3000 of file opentype.c.

{
    unsigned int num_baseglyph_records, offset_baseglyph_records;
    const struct colr_baseglyph_record *record;
    const struct colr_layer_record *layer;
    const struct colr_header *header;
 
    memset(ret, 0, sizeof(*ret));
    ret->glyph = glyph;
    ret->palette_index = 0xffff;
 
    header = table_read_ensure(colr, 0, sizeof(*header));
    if (!header)
        return S_FALSE;
 
    num_baseglyph_records = GET_BE_WORD(header->num_baseglyph_records);
    offset_baseglyph_records = GET_BE_DWORD(header->offset_baseglyph_records);
    if (!table_read_ensure(colr, offset_baseglyph_records, num_baseglyph_records * sizeof(*record)))
    {
        return S_FALSE;
    }
 
    record = bsearch(&glyph, colr->data + offset_baseglyph_records, num_baseglyph_records,
            sizeof(*record), colr_compare_gid);
    if (!record)
        return S_FALSE;
 
    ret->first_layer = GET_BE_WORD(record->first_layer_index);
    ret->num_layers = GET_BE_WORD(record->num_layers);
 
    if ((layer = table_read_ensure(colr, GET_BE_DWORD(header->offset_layer_records),
            (ret->first_layer + ret->layer) * sizeof(*layer))))
    {
        layer += ret->first_layer + ret->layer;
        ret->glyph = GET_BE_WORD(layer->glyph);
        ret->palette_index = GET_BE_WORD(layer->palette_index);
    }
 
    return S_OK;
}

Referenced by create_colorglyphenum().

opentype_get_cpal_entries()

HRESULT opentype_get_cpal_entries	(	const struct dwrite_fonttable *	table,
		unsigned int	palette,
		unsigned int	first_entry_index,
		unsigned int	entry_count,
		DWRITE_COLOR_F *	entries
	)

Definition at line 2937 of file opentype.c.

{
    unsigned int num_palettes, num_palette_entries, i;
    const struct cpal_color_record *records;
    const struct cpal_header_0 *header;
    struct d3d_color
    {
        float r;
        float g;
        float b;
        float a;
    } *colors = (void *)entries;
 
    header = table_read_ensure(cpal, 0, sizeof(*header));
 
    if (!cpal->exists || !header)
        return DWRITE_E_NOCOLOR;
 
    num_palettes = GET_BE_WORD(header->num_palettes);
    if (palette >= num_palettes)
        return DWRITE_E_NOCOLOR;
 
    header = table_read_ensure(cpal, 0, FIELD_OFFSET(struct cpal_header_0, color_record_indices[palette]));
    if (!header)
        return DWRITE_E_NOCOLOR;
 
    num_palette_entries = GET_BE_WORD(header->num_palette_entries);
    if (first_entry_index + entry_count > num_palette_entries)
        return E_INVALIDARG;
 
    records = table_read_ensure(cpal, GET_BE_DWORD(header->offset_first_color_record),
            sizeof(*records) * GET_BE_WORD(header->num_color_records));
    if (!records)
        return DWRITE_E_NOCOLOR;
 
    first_entry_index += GET_BE_WORD(header->color_record_indices[palette]);
 
    for (i = 0; i < entry_count; ++i)
    {
        colors[i].r = records[first_entry_index + i].red   / 255.0f;
        colors[i].g = records[first_entry_index + i].green / 255.0f;
        colors[i].b = records[first_entry_index + i].blue  / 255.0f;
        colors[i].a = records[first_entry_index + i].alpha / 255.0f;
    }
 
    return S_OK;
}

Referenced by dwritefontface2_GetPaletteEntries().

opentype_get_cpal_palettecount()

unsigned int opentype_get_cpal_palettecount

(

const struct dwrite_fonttable *

table

)

Definition at line 2927 of file opentype.c.

{
    return table_read_be_word(cpal, FIELD_OFFSET(struct cpal_header_0, num_palettes));
}

Referenced by dwritefontface2_GetColorPaletteCount().

opentype_get_cpal_paletteentrycount()

unsigned int opentype_get_cpal_paletteentrycount

(

const struct dwrite_fonttable *

table

)

Definition at line 2932 of file opentype.c.

{
    return table_read_be_word(cpal, FIELD_OFFSET(struct cpal_header_0, num_palette_entries));
}

Referenced by dwritefontface2_GetPaletteEntryCount().

opentype_get_font_facename()

HRESULT opentype_get_font_facename	(	struct file_stream_desc *	stream_desc,
		WCHAR *	lfname,
		IDWriteLocalizedStrings **	names
	)

Definition at line 2690 of file opentype.c.

{
    struct dwrite_fonttable os2, name;
    IDWriteLocalizedStrings *lfnames;
    UINT16 fsselection;
    HRESULT hr;
 
    opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
    opentype_get_font_table(stream_desc, MS_NAME_TAG, &name);
 
    *names = NULL;
 
    /* if Preferred Family doesn't conform to WWS model try WWS name */
    fsselection = os2.data ? table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, fsSelection)) : 0;
    if (os2.data && !(fsselection & OS2_FSSELECTION_WWS))
        hr = opentype_get_font_strings_from_id(&name, OPENTYPE_STRING_WWS_SUBFAMILY_NAME, names);
    else
        hr = E_FAIL;
 
    if (FAILED(hr))
        hr = opentype_get_font_strings_from_id(&name, OPENTYPE_STRING_TYPOGRAPHIC_SUBFAMILY_NAME, names);
    if (FAILED(hr))
        hr = opentype_get_font_strings_from_id(&name, OPENTYPE_STRING_SUBFAMILY_NAME, names);
 
    /* User locale is preferred, with fallback to en-us. */
    *lfname = 0;
    if (SUCCEEDED(opentype_get_font_strings_from_id(&name, OPENTYPE_STRING_FAMILY_NAME, &lfnames)))
    {
        WCHAR localeW[LOCALE_NAME_MAX_LENGTH];
        UINT32 index;
        BOOL exists;
 
        exists = FALSE;
        if (GetSystemDefaultLocaleName(localeW, ARRAY_SIZE(localeW)))
            IDWriteLocalizedStrings_FindLocaleName(lfnames, localeW, &index, &exists);
 
        if (!exists)
            IDWriteLocalizedStrings_FindLocaleName(lfnames, L"en-us", &index, &exists);
 
        if (exists) {
            UINT32 length = 0;
            WCHAR *nameW;
 
            IDWriteLocalizedStrings_GetStringLength(lfnames, index, &length);
            nameW = malloc((length + 1) * sizeof(WCHAR));
            if (nameW)
            {
                *nameW = 0;
                IDWriteLocalizedStrings_GetString(lfnames, index, nameW, length + 1);
                lstrcpynW(lfname, nameW, LF_FACESIZE);
                free(nameW);
            }
        }
 
        IDWriteLocalizedStrings_Release(lfnames);
    }
 
    if (os2.context)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
    if (name.context)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name.context);
 
    return hr;
}

Referenced by init_font_data().

opentype_get_font_familyname()

HRESULT opentype_get_font_familyname	(	const struct file_stream_desc *	desc,
		DWRITE_FONT_FAMILY_MODEL	family_model,
		IDWriteLocalizedStrings **	names
	)

Definition at line 2629 of file opentype.c.

{
    static const unsigned int wws_candidates[] =
    {
        OPENTYPE_STRING_WWS_FAMILY_NAME,
        OPENTYPE_STRING_TYPOGRAPHIC_FAMILY_NAME,
        OPENTYPE_STRING_FAMILY_NAME,
        ~0u,
    };
    static const unsigned int typographic_candidates[] =
    {
        OPENTYPE_STRING_TYPOGRAPHIC_FAMILY_NAME,
        OPENTYPE_STRING_WWS_FAMILY_NAME,
        OPENTYPE_STRING_FAMILY_NAME,
        ~0u,
    };
    struct dwrite_fonttable os2, name;
    const unsigned int *id;
    BOOL try_wws_name;
    HRESULT hr;
 
    opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
    opentype_get_font_table(stream_desc, MS_NAME_TAG, &name);
 
    *names = NULL;
 
    if (family_model == DWRITE_FONT_FAMILY_MODEL_TYPOGRAPHIC)
    {
        id = typographic_candidates;
    }
    else
    {
        /* FamilyName locating order is WWS Family Name -> Preferred Family Name -> Family Name. If font claims to
           have 'Preferred Family Name' in WWS format, then WWS name is not used. */
 
        opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
        /* If Preferred Family doesn't conform to WWS model try WWS name. */
        try_wws_name = os2.data && !(table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, fsSelection)) & OS2_FSSELECTION_WWS);
        if (os2.context)
            IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
 
        id = wws_candidates;
        if (!try_wws_name) id++;
    }
 
    while (*id != ~0u)
    {
        if (SUCCEEDED(hr = opentype_get_font_strings_from_id(&name, *id, names)))
            break;
        id++;
    }
 
    if (name.context)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name.context);
 
    return hr;
}

Referenced by init_font_data().

opentype_get_font_info_strings()

HRESULT opentype_get_font_info_strings	(	const struct file_stream_desc *	stream_desc,
		DWRITE_INFORMATIONAL_STRING_ID	id,
		IDWriteLocalizedStrings **	strings
	)

Definition at line 2608 of file opentype.c.

{
    struct dwrite_fonttable name;
 
    switch (id)
    {
        case DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG:
        case DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG:
            opentype_get_font_strings_from_meta(stream_desc, id, strings);
            break;
        default:
            opentype_get_font_table(stream_desc, MS_NAME_TAG, &name);
            opentype_get_font_strings_from_id(&name, dwriteid_to_opentypeid[id], strings);
            if (name.context)
                IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name.context);
    }
 
    return S_OK;
}

Referenced by fontset_entry_get_property(), and get_font_info_strings().

opentype_get_font_metrics()

void opentype_get_font_metrics	(	struct file_stream_desc *	stream_desc,
		DWRITE_FONT_METRICS1 *	metrics,
		DWRITE_CARET_METRICS *	caret
	)

Definition at line 1973 of file opentype.c.

{
    struct dwrite_fonttable os2, head, post, hhea;
 
    memset(metrics, 0, sizeof(*metrics));
 
    opentype_get_font_table(stream_desc, MS_OS2_TAG,  &os2);
    opentype_get_font_table(stream_desc, MS_HEAD_TAG, &head);
    opentype_get_font_table(stream_desc, MS_POST_TAG, &post);
    opentype_get_font_table(stream_desc, MS_HHEA_TAG, &hhea);
 
    if (head.data)
    {
        metrics->designUnitsPerEm = table_read_be_word(&head, FIELD_OFFSET(struct tt_head, unitsPerEm));
        metrics->glyphBoxLeft = table_read_be_word(&head, FIELD_OFFSET(struct tt_head, xMin));
        metrics->glyphBoxTop = table_read_be_word(&head, FIELD_OFFSET(struct tt_head, yMax));
        metrics->glyphBoxRight = table_read_be_word(&head, FIELD_OFFSET(struct tt_head, xMax));
        metrics->glyphBoxBottom = table_read_be_word(&head, FIELD_OFFSET(struct tt_head, yMin));
    }
 
    if (caret)
    {
        if (hhea.data)
        {
            caret->slopeRise = table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, caretSlopeRise));
            caret->slopeRun = table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, caretSlopeRun));
            caret->offset = table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, caretOffset));
        }
        else
            memset(caret, 0, sizeof(*caret));
    }
 
    if (os2.data)
    {
        USHORT version = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, version));
 
        metrics->ascent = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, usWinAscent));
        /* Some fonts have usWinDescent value stored as signed short, which could be wrongly
           interpreted as large unsigned value. */
        metrics->descent = abs((SHORT)table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, usWinDescent)));
 
        /* Line gap is estimated using two sets of ascender/descender values and 'hhea' line gap. */
        if (hhea.data)
        {
            SHORT descender = (SHORT)table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, descender));
            INT32 linegap;
 
            linegap = table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, ascender)) + abs(descender) +
                    table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, linegap)) - metrics->ascent - metrics->descent;
            metrics->lineGap = linegap > 0 ? linegap : 0;
        }
 
        metrics->strikethroughPosition  = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, yStrikeoutPosition));
        metrics->strikethroughThickness = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, yStrikeoutSize));
        metrics->subscriptPositionX = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySubscriptXOffset));
        /* Y offset is stored as positive offset below baseline */
        metrics->subscriptPositionY = -table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySubscriptYOffset));
        metrics->subscriptSizeX = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySubscriptXSize));
        metrics->subscriptSizeY = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySubscriptYSize));
        metrics->superscriptPositionX = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySuperscriptXOffset));
        metrics->superscriptPositionY = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySuperscriptYOffset));
        metrics->superscriptSizeX = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySuperscriptXSize));
        metrics->superscriptSizeY = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, ySuperscriptYSize));
 
        /* version 2 fields */
        if (version >= 2)
        {
            metrics->capHeight = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sCapHeight));
            metrics->xHeight   = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sxHeight));
        }
 
        if (table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, fsSelection)) & OS2_FSSELECTION_USE_TYPO_METRICS)
        {
            SHORT descent = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sTypoDescender));
            metrics->ascent = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sTypoAscender));
            metrics->descent = descent < 0 ? -descent : 0;
            metrics->lineGap = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sTypoLineGap));
            metrics->hasTypographicMetrics = TRUE;
        }
    }
    else
    {
        metrics->strikethroughPosition = metrics->designUnitsPerEm / 3;
        if (hhea.data)
        {
            metrics->ascent = table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, ascender));
            metrics->descent = abs((SHORT)table_read_be_word(&hhea, FIELD_OFFSET(struct tt_hhea, descender)));
        }
    }
 
    if (post.data)
    {
        metrics->underlinePosition = table_read_be_word(&post, FIELD_OFFSET(struct tt_post, underlinePosition));
        metrics->underlineThickness = table_read_be_word(&post, FIELD_OFFSET(struct tt_post, underlineThickness));
    }
 
    if (metrics->underlineThickness == 0)
        metrics->underlineThickness = metrics->designUnitsPerEm / 14;
    if (metrics->strikethroughThickness == 0)
        metrics->strikethroughThickness = metrics->underlineThickness;
 
    /* estimate missing metrics */
    if (metrics->xHeight == 0)
        metrics->xHeight = metrics->designUnitsPerEm / 2;
    if (metrics->capHeight == 0)
        metrics->capHeight = metrics->designUnitsPerEm * 7 / 10;
 
    if (os2.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
    if (head.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, head.context);
    if (post.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, post.context);
    if (hhea.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, hhea.context);
}

Referenced by create_fontface(), and init_font_data().

opentype_get_font_properties()

void opentype_get_font_properties	(	const struct file_stream_desc *	stream_desc,
		struct dwrite_font_props *	props
	)

Definition at line 2090 of file opentype.c.

{
    struct dwrite_fonttable os2, head, post, colr, cpal;
    BOOL is_symbol, is_monospaced;
 
    opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
    opentype_get_font_table(stream_desc, MS_HEAD_TAG, &head);
 
    memset(props, 0, sizeof(*props));
 
    /* Default stretch, weight and style to normal */
    props->stretch = DWRITE_FONT_STRETCH_NORMAL;
    props->weight = DWRITE_FONT_WEIGHT_NORMAL;
    props->style = DWRITE_FONT_STYLE_NORMAL;
 
    /* DWRITE_FONT_STRETCH enumeration values directly match font data values */
    if (os2.data)
    {
        USHORT version = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, version));
        USHORT fsSelection = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, fsSelection));
        USHORT usWeightClass = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, usWeightClass));
        USHORT usWidthClass = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, usWidthClass));
        const void *panose;
 
        if (usWidthClass > DWRITE_FONT_STRETCH_UNDEFINED && usWidthClass <= DWRITE_FONT_STRETCH_ULTRA_EXPANDED)
            props->stretch = usWidthClass;
 
        if (usWeightClass >= 1 && usWeightClass <= 9)
            usWeightClass *= 100;
 
        if (usWeightClass > DWRITE_FONT_WEIGHT_ULTRA_BLACK)
            props->weight = DWRITE_FONT_WEIGHT_ULTRA_BLACK;
        else if (usWeightClass > 0)
            props->weight = usWeightClass;
 
        if (version >= 4 && (fsSelection & OS2_FSSELECTION_OBLIQUE))
            props->style = DWRITE_FONT_STYLE_OBLIQUE;
        else if (fsSelection & OS2_FSSELECTION_ITALIC)
            props->style = DWRITE_FONT_STYLE_ITALIC;
        props->lf.lfItalic = !!(fsSelection & OS2_FSSELECTION_ITALIC);
 
        if ((panose = table_read_ensure(&os2, FIELD_OFFSET(struct tt_os2, panose), sizeof(props->panose))))
            memcpy(&props->panose, panose, sizeof(props->panose));
 
        /* FONTSIGNATURE */
        props->fontsig.fsUsb[0] = table_read_be_dword(&os2, FIELD_OFFSET(struct tt_os2, ulUnicodeRange1));
        props->fontsig.fsUsb[1] = table_read_be_dword(&os2, FIELD_OFFSET(struct tt_os2, ulUnicodeRange2));
        props->fontsig.fsUsb[2] = table_read_be_dword(&os2, FIELD_OFFSET(struct tt_os2, ulUnicodeRange3));
        props->fontsig.fsUsb[3] = table_read_be_dword(&os2, FIELD_OFFSET(struct tt_os2, ulUnicodeRange4));
 
        if (version)
        {
            props->fontsig.fsCsb[0] = table_read_be_dword(&os2, FIELD_OFFSET(struct tt_os2, ulCodePageRange1));
            props->fontsig.fsCsb[1] = table_read_be_dword(&os2, FIELD_OFFSET(struct tt_os2, ulCodePageRange2));
        }
    }
    else if (head.data)
    {
        USHORT macStyle = table_read_be_word(&head, FIELD_OFFSET(struct tt_head, macStyle));
 
        if (macStyle & TT_HEAD_MACSTYLE_CONDENSED)
            props->stretch = DWRITE_FONT_STRETCH_CONDENSED;
        else if (macStyle & TT_HEAD_MACSTYLE_EXTENDED)
            props->stretch = DWRITE_FONT_STRETCH_EXPANDED;
 
        if (macStyle & TT_HEAD_MACSTYLE_BOLD)
            props->weight = DWRITE_FONT_WEIGHT_BOLD;
 
        if (macStyle & TT_HEAD_MACSTYLE_ITALIC) {
            props->style = DWRITE_FONT_STYLE_ITALIC;
            props->lf.lfItalic = 1;
        }
    }
 
    props->lf.lfWeight = props->weight;
 
    /* FONT_IS_SYMBOL */
    if (!(is_symbol = props->panose.familyKind == DWRITE_PANOSE_FAMILY_SYMBOL))
    {
        struct dwrite_fonttable cmap;
        int i, offset, num_tables;
 
        opentype_get_font_table(stream_desc, MS_CMAP_TAG, &cmap);
 
        if (cmap.data)
        {
            num_tables = table_read_be_word(&cmap, FIELD_OFFSET(struct cmap_header, num_tables));
            offset = FIELD_OFFSET(struct cmap_header, tables);
 
            for (i = 0; !is_symbol && i < num_tables; ++i)
            {
                WORD platform, encoding;
 
                platform = table_read_be_word(&cmap, offset + i * sizeof(struct cmap_encoding_record) +
                        FIELD_OFFSET(struct cmap_encoding_record, platformID));
                encoding = table_read_be_word(&cmap, offset + i * sizeof(struct cmap_encoding_record) +
                        FIELD_OFFSET(struct cmap_encoding_record, encodingID));
 
                is_symbol = platform == OPENTYPE_CMAP_TABLE_PLATFORM_WIN &&
                        encoding == OPENTYPE_CMAP_TABLE_ENCODING_SYMBOL;
            }
 
            IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, cmap.context);
        }
    }
    if (is_symbol)
        props->flags |= FONT_IS_SYMBOL;
 
    /* FONT_IS_MONOSPACED, slant angle */
    opentype_get_font_table(stream_desc, MS_POST_TAG, &post);
    is_monospaced = props->panose.text.proportion == DWRITE_PANOSE_PROPORTION_MONOSPACED;
    if (post.data)
    {
        if (!is_monospaced)
            is_monospaced = !!table_read_dword(&post, FIELD_OFFSET(struct tt_post, fixed_pitch));
        props->slant_angle = table_read_be_fixed(&post, FIELD_OFFSET(struct tt_post, italicAngle));
    }
    if (post.context)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, post.context);
 
    if (is_monospaced)
        props->flags |= FONT_IS_MONOSPACED;
 
    /* FONT_IS_COLORED */
    opentype_get_font_table(stream_desc, MS_COLR_TAG, &colr);
    if (colr.data)
    {
        opentype_get_font_table(stream_desc, MS_CPAL_TAG, &cpal);
        if (cpal.data)
        {
            props->flags |= FONT_IS_COLORED;
            IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, cpal.context);
        }
 
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, colr.context);
    }
 
    TRACE("stretch %d, weight %d, style %d\n", props->stretch, props->weight, props->style);
 
    if (os2.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
    if (head.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, head.context);
}

Referenced by init_font_data(), and opentype_get_font_var_axis().

opentype_get_font_typo_metrics()

void opentype_get_font_typo_metrics	(	struct file_stream_desc *	stream_desc,
		unsigned int *	ascent,
		unsigned int *	descent
	)

Definition at line 1954 of file opentype.c.

{
    struct dwrite_fonttable os2;
 
    opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
 
    *ascent = *descent = 0;
 
    if (os2.size >= FIELD_OFFSET(struct tt_os2, sTypoLineGap))
    {
        SHORT value = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sTypoDescender));
        *ascent = table_read_be_word(&os2, FIELD_OFFSET(struct tt_os2, sTypoAscender));
        *descent = value < 0 ? -value : 0;
    }
 
    if (os2.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
}

Referenced by create_fontface().

opentype_get_font_var_axis()

HRESULT opentype_get_font_var_axis	(	const struct file_stream_desc *	stream_desc,
		struct dwrite_var_axis **	axis,
		unsigned int *	axis_count
	)

Definition at line 6693 of file opentype.c.

{
    static const float width_axis_values[] =
    {
        0.0f, /* DWRITE_FONT_STRETCH_UNDEFINED */
        50.0f, /* DWRITE_FONT_STRETCH_ULTRA_CONDENSED */
        62.5f, /* DWRITE_FONT_STRETCH_EXTRA_CONDENSED */
        75.0f, /* DWRITE_FONT_STRETCH_CONDENSED */
        87.5f, /* DWRITE_FONT_STRETCH_SEMI_CONDENSED */
        100.0f, /* DWRITE_FONT_STRETCH_NORMAL */
        112.5f, /* DWRITE_FONT_STRETCH_SEMI_EXPANDED */
        125.0f, /* DWRITE_FONT_STRETCH_EXPANDED */
        150.0f, /* DWRITE_FONT_STRETCH_EXTRA_EXPANDED */
        200.0f, /* DWRITE_FONT_STRETCH_ULTRA_EXPANDED */
    };
    BOOL has_wght = FALSE, has_wdth = FALSE, has_slnt = FALSE, has_ital = FALSE;
    const struct var_axis_record *records;
    const struct fvar_header *header;
    unsigned int i, count, tag, size;
    struct dwrite_font_props props;
    struct dwrite_fonttable fvar;
    HRESULT hr = S_OK;
 
    *axis = NULL;
    *axis_count = 0;
 
    opentype_get_font_table(stream_desc, MS_FVAR_TAG, &fvar);
 
    if (!(header = table_read_ensure(&fvar, 0, sizeof(*header)))) goto done;
    if (!(GET_BE_WORD(header->major_version) == 1 && GET_BE_WORD(header->minor_version) == 0))
    {
        WARN("Unexpected fvar version.\n");
        goto done;
    }
 
    count = GET_BE_WORD(header->axis_count);
    size = GET_BE_WORD(header->axis_size);
 
    if (!count || size != sizeof(*records)) goto done;
    if (!(records = table_read_ensure(&fvar, GET_BE_WORD(header->axes_array_offset), size * count))) goto done;
 
    if (!(*axis = calloc(count + 4, sizeof(**axis))))
    {
        hr = E_OUTOFMEMORY;
        goto done;
    }
 
    for (i = 0; i < count; ++i)
    {
        (*axis)[i].tag = tag = records[i].tag;
        (*axis)[i].default_value = GET_BE_FIXED(records[i].default_value);
        (*axis)[i].min_value = GET_BE_FIXED(records[i].min_value);
        (*axis)[i].max_value = GET_BE_FIXED(records[i].max_value);
        if (GET_BE_WORD(records[i].flags & 0x1))
            (*axis)[i].attributes |= DWRITE_FONT_AXIS_ATTRIBUTES_HIDDEN;
        /* FIXME: set DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE */
 
        if (tag == DWRITE_FONT_AXIS_TAG_WEIGHT) has_wght = TRUE;
        if (tag == DWRITE_FONT_AXIS_TAG_WIDTH) has_wdth = TRUE;
        if (tag == DWRITE_FONT_AXIS_TAG_SLANT) has_slnt = TRUE;
        if (tag == DWRITE_FONT_AXIS_TAG_ITALIC) has_ital = TRUE;
    }
 
    if (!has_wght || !has_wdth || !has_slnt || !has_ital)
    {
        opentype_get_font_properties(stream_desc, &props);
        if (!has_wght) opentype_font_var_add_static_axis(axis, &count, DWRITE_FONT_AXIS_TAG_WEIGHT, props.weight);
        if (!has_ital) opentype_font_var_add_static_axis(axis, &count, DWRITE_FONT_AXIS_TAG_ITALIC,
                props.style == DWRITE_FONT_STYLE_ITALIC ? 1.0f : 0.0f);
        if (!has_wdth) opentype_font_var_add_static_axis(axis, &count, DWRITE_FONT_AXIS_TAG_WIDTH,
                width_axis_values[props.stretch]);
        if (!has_slnt) opentype_font_var_add_static_axis(axis, &count, DWRITE_FONT_AXIS_TAG_SLANT, props.slant_angle);
    }
 
    *axis_count = count;
 
done:
    if (fvar.context)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, fvar.context);
 
    return hr;
}

Referenced by create_font_resource().

opentype_get_gasp_flags()

unsigned int opentype_get_gasp_flags	(	const struct dwrite_fonttable *	gasp,
		float	emsize
	)

Definition at line 2895 of file opentype.c.

{
    unsigned int version, num_ranges, i;
    const struct gasp_header *table;
    WORD flags = 0;
 
    if (!gasp->exists)
        return 0;
 
    num_ranges = table_read_be_word(gasp, FIELD_OFFSET(struct gasp_header, num_ranges));
 
    table = table_read_ensure(gasp, 0, FIELD_OFFSET(struct gasp_header, ranges[num_ranges]));
    if (!table)
        return 0;
 
    version = GET_BE_WORD(table->version);
    if (version > 1)
    {
        ERR("Unsupported gasp table format version %u.\n", version);
        goto done;
    }
 
    for (i = 0; i < num_ranges; ++i)
    {
        flags = GET_BE_WORD(table->ranges[i].flags);
        if (emsize <= GET_BE_WORD(table->ranges[i].max_ppem)) break;
    }
 
done:
    return flags;
}

Referenced by dwritefontface2_GetRecommendedRenderingMode(), dwritefontface3_GetRecommendedRenderingMode(), and dwritefontface_GetRecommendedRenderingMode().

opentype_get_glyph_image_formats()

UINT32 opentype_get_glyph_image_formats

(

IDWriteFontFace5 *

fontface

)

Definition at line 3191 of file opentype.c.

{
    UINT32 ret = DWRITE_GLYPH_IMAGE_FORMATS_NONE;
 
    if (opentype_has_font_table(fontface, MS_GLYF_TAG))
        ret |= DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE;
 
    if (opentype_has_font_table(fontface, MS_CFF__TAG) ||
            opentype_has_font_table(fontface, MS_CFF2_TAG))
        ret |= DWRITE_GLYPH_IMAGE_FORMATS_CFF;
 
    if (opentype_has_font_table(fontface, MS_COLR_TAG))
        ret |= DWRITE_GLYPH_IMAGE_FORMATS_COLR;
 
    if (opentype_has_font_table(fontface, MS_SVG__TAG))
        ret |= DWRITE_GLYPH_IMAGE_FORMATS_SVG;
 
    if (opentype_has_font_table(fontface, MS_SBIX_TAG))
        ret |= opentype_get_sbix_formats(fontface);
 
    if (opentype_has_font_table(fontface, MS_CBLC_TAG))
        ret |= opentype_get_cblc_formats(fontface);
 
    return ret;
}

Referenced by create_fontface().

opentype_get_kerning_pairs()

HRESULT opentype_get_kerning_pairs	(	struct dwrite_fontface *	fontface,
		unsigned int	count,
		const UINT16 *	glyphs,
		INT32 *	values
	)

Definition at line 6624 of file opentype.c.

{
    const struct kern_subtable_header *subtable;
    unsigned int i, s, offset, pair_count, subtable_count;
    struct kern_format0_compare_key key;
    const struct kern_header *header;
    const WORD *data;
 
    if (!opentype_has_kerning_pairs(fontface))
    {
        memset(values, 0, count * sizeof(*values));
        return S_OK;
    }
 
    subtable_count = table_read_be_word(&fontface->kern, 2);
    subtable_count = min(subtable_count, 32);
 
    for (i = 0; i < count - 1; ++i)
    {
        offset = sizeof(*header);
 
        key.left = glyphs[i];
        key.right = glyphs[i + 1];
        values[i] = 0;
 
        for (s = 0; s < subtable_count; ++s)
        {
            if (!(subtable = table_read_ensure(&fontface->kern, offset, sizeof(*subtable))))
                break;
 
            if (subtable->version == 0 && GET_BE_WORD(subtable->coverage) & 1)
            {
                if ((data = table_read_ensure(&fontface->kern, offset, GET_BE_WORD(subtable->length))))
                {
                    /* Skip subtable header */
                    data += 3;
                    pair_count = GET_BE_WORD(*data);
                    data += 4;
                    /* Move to pair data */
                    if ((data = table_read_ensure(&fontface->kern, offset + 7 * sizeof(*data),
                            pair_count * 3 * sizeof(*data))))
                    {
                        if ((data = bsearch(&key, data, pair_count, 3 * sizeof(*data), kern_format0_compare)))
                        {
                            values[i] = (short)GET_BE_WORD(data[2]);
                            break;
                        }
                    }
                }
            }
 
            offset += GET_BE_WORD(subtable->length);
        }
    }
    values[count - 1] = 0;
 
    return S_OK;
}

Referenced by dwritefontface1_GetKerningPairAdjustments().

opentype_get_typographic_features()

void opentype_get_typographic_features	(	struct ot_gsubgpos_table *	table,
		unsigned int	script_index,
		unsigned int	language_index,
		struct tag_array *	tags
	)

Definition at line 2789 of file opentype.c.

{
    unsigned int i, total_feature_count, script_feature_count;
    const struct ot_feature_list *feature_list;
    const struct ot_langsys *langsys = NULL;
 
    langsys = opentype_get_langsys(table, script_index, language_index, &script_feature_count);
 
    total_feature_count = table_read_be_word(&table->table, table->feature_list);
    if (!total_feature_count)
        return;
 
    feature_list = table_read_ensure(&table->table, table->feature_list,
            FIELD_OFFSET(struct ot_feature_list, features[total_feature_count]));
    if (!feature_list)
        return;
 
    for (i = 0; i < script_feature_count; ++i)
    {
        unsigned int feature_index = GET_BE_WORD(langsys->feature_index[i]);
        if (feature_index >= total_feature_count)
            continue;
 
        if (!dwrite_array_reserve((void **)&t->tags, &t->capacity, t->count + 1, sizeof(*t->tags)))
            return;
 
        t->tags[t->count++] = feature_list->features[feature_index].tag;
    }
}

Referenced by shape_get_typographic_features().

opentype_get_vdmx_size()

BOOL opentype_get_vdmx_size	(	const struct dwrite_fonttable *	table,
		INT	ppem,
		UINT16 *	ascent,
		UINT16 *	descent
	)

Definition at line 2846 of file opentype.c.

{
    unsigned int num_ratios, num_recs, group_offset, i;
    const struct vdmx_header *header;
    const struct vdmx_group *group;
 
    if (!vdmx->exists)
        return FALSE;
 
    num_ratios = table_read_be_word(vdmx, FIELD_OFFSET(struct vdmx_header, num_ratios));
    num_recs = table_read_be_word(vdmx, FIELD_OFFSET(struct vdmx_header, num_recs));
 
    header = table_read_ensure(vdmx, 0, sizeof(*header) + num_ratios * sizeof(struct vdmx_ratio) +
            num_recs * sizeof(*group));
 
    if (!header)
        return FALSE;
 
    group_offset = find_vdmx_group(header);
    if (!group_offset)
        return FALSE;
 
    num_recs = table_read_be_word(vdmx, group_offset);
    group = table_read_ensure(vdmx, group_offset, FIELD_OFFSET(struct vdmx_group, entries[num_recs]));
 
    if (!group)
        return FALSE;
 
    if (emsize < group->startsz || emsize >= group->endsz)
        return FALSE;
 
    for (i = 0; i < num_recs; ++i)
    {
        WORD ppem = GET_BE_WORD(group->entries[i].yPelHeight);
        if (ppem > emsize) {
            FIXME("interpolate %d\n", emsize);
            return FALSE;
        }
 
        if (ppem == emsize) {
            *ascent = (SHORT)GET_BE_WORD(group->entries[i].yMax);
            *descent = -(SHORT)GET_BE_WORD(group->entries[i].yMin);
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by dwritefontface1_GetGdiCompatibleMetrics().

opentype_get_vertical_glyph_variants()

HRESULT opentype_get_vertical_glyph_variants	(	struct dwrite_fontface *	fontface,
		unsigned int	glyph_count,
		const UINT16 *	nominal_glyphs,
		UINT16 *	glyphs
	)

Definition at line 6498 of file opentype.c.

{
    struct shaping_features features = { 0 };
    struct shaping_feature vert_feature = { 0 };
    struct scriptshaping_context context = { 0 };
    struct lookups lookups = { 0 };
    unsigned int i;
 
    memcpy(glyphs, nominal_glyphs, glyph_count * sizeof(*glyphs));
 
    if (!opentype_has_vertical_variants(fontface))
        return S_OK;
 
    context.cache = fontface_get_shaping_cache(fontface);
    context.u.subst.glyphs = glyphs;
    context.u.subst.glyph_props = calloc(glyph_count, sizeof(*context.u.subst.glyph_props));
    context.u.subst.max_glyph_count = glyph_count;
    context.u.subst.capacity = glyph_count;
    context.glyph_infos = calloc(glyph_count, sizeof(*context.glyph_infos));
    context.table = &context.cache->gsub;
 
    vert_feature.tag = DWRITE_MAKE_OPENTYPE_TAG('v','e','r','t');
    vert_feature.flags = FEATURE_GLOBAL | FEATURE_GLOBAL_SEARCH;
    vert_feature.max_value = 1;
    vert_feature.default_value = 1;
 
    features.features = &vert_feature;
    features.count = features.capacity = 1;
 
    opentype_layout_collect_lookups(&context, ~0u, ~0u, &features, context.table, &lookups);
    opentype_layout_set_glyph_masks(&context, &features);
 
    for (i = 0; i < lookups.count; ++i)
    {
        const struct lookup *lookup = &lookups.lookups[i];
 
        context.cur = 0;
        while (context.cur < context.glyph_count)
        {
            BOOL ret = FALSE;
 
            if (lookup_is_glyph_match(&context, context.cur, lookup->flags))
                ret = opentype_layout_apply_gsub_lookup(&context, lookup);
 
            if (!ret)
                context.cur++;
        }
    }
 
    free(context.u.subst.glyph_props);
    free(context.glyph_infos);
    free(lookups.lookups);
 
    return S_OK;
}

Referenced by dwritefontface1_GetVerticalGlyphVariants().

opentype_has_kerning_pairs()

BOOL opentype_has_kerning_pairs

(

struct dwrite_fontface *

fontface

)

Definition at line 6555 of file opentype.c.

{
    const struct kern_subtable_header *subtable;
    struct file_stream_desc stream_desc;
    const struct kern_header *header;
    unsigned int offset, count, i;
 
    if (fontface->flags & (FONTFACE_KERNING_PAIRS | FONTFACE_NO_KERNING_PAIRS))
        return !!(fontface->flags & FONTFACE_KERNING_PAIRS);
 
    fontface->flags |= FONTFACE_NO_KERNING_PAIRS;
 
    stream_desc.stream = fontface->stream;
    stream_desc.face_type = fontface->type;
    stream_desc.face_index = fontface->index;
 
    opentype_get_font_table(&stream_desc, MS_KERN_TAG, &fontface->kern);
    if (fontface->kern.exists)
    {
        if ((header = table_read_ensure(&fontface->kern, 0, sizeof(*header))))
        {
            count = GET_BE_WORD(header->table_count);
            offset = sizeof(*header);
 
            /* FreeType limits table count this way. */
            count = min(count, 32);
 
            /* Check for presence of format 0 subtable with horizontal coverage. */
            for (i = 0; i < count; ++i)
            {
                if (!(subtable = table_read_ensure(&fontface->kern, offset, sizeof(*subtable))))
                    break;
 
                if (subtable->version == 0 && GET_BE_WORD(subtable->coverage) & 1)
                {
                    fontface->flags &= ~FONTFACE_NO_KERNING_PAIRS;
                    fontface->flags |= FONTFACE_KERNING_PAIRS;
                    break;
                }
 
                offset += GET_BE_WORD(subtable->length);
            }
        }
    }
 
    if (fontface->flags & FONTFACE_NO_KERNING_PAIRS && fontface->kern.data)
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc.stream, fontface->kern.context);
 
    return !!(fontface->flags & FONTFACE_KERNING_PAIRS);
}

Referenced by dwritefontface1_HasKerningPairs(), and opentype_get_kerning_pairs().

opentype_has_vertical_variants()

BOOL opentype_has_vertical_variants

(

struct dwrite_fontface *

fontface

)

Definition at line 6436 of file opentype.c.

{
    unsigned int i, j, count = 0, lookup_type, subtable_offset;
    struct shaping_features features = { 0 };
    struct shaping_feature vert_feature = { 0 };
    struct scriptshaping_context context = { 0 };
    struct lookups lookups = { 0 };
    UINT16 format;
 
    if (fontface->flags & (FONTFACE_VERTICAL_VARIANTS | FONTFACE_NO_VERTICAL_VARIANTS))
        return !!(fontface->flags & FONTFACE_VERTICAL_VARIANTS);
 
    context.cache = fontface_get_shaping_cache(fontface);
    context.table = &context.cache->gsub;
 
    vert_feature.tag = DWRITE_MAKE_OPENTYPE_TAG('v','e','r','t');
    vert_feature.flags = FEATURE_GLOBAL | FEATURE_GLOBAL_SEARCH;
    vert_feature.max_value = 1;
    vert_feature.default_value = 1;
 
    features.features = &vert_feature;
    features.count = features.capacity = 1;
 
    opentype_layout_collect_lookups(&context, ~0u, ~0u, &features, context.table, &lookups);
 
    for (i = 0; i < lookups.count && !count; ++i)
    {
        const struct dwrite_fonttable *table = &context.table->table;
        const struct lookup *lookup = &lookups.lookups[i];
 
        for (j = 0; j < lookup->subtable_count && !count; ++j)
        {
            subtable_offset = opentype_layout_get_gsubgpos_subtable(&context, lookup, j, &lookup_type);
 
            if (lookup_type != GSUB_LOOKUP_SINGLE_SUBST)
                continue;
 
            format = table_read_be_word(table, subtable_offset);
 
            if (format == 1)
            {
                count = 1;
            }
            else if (format == 2)
            {
                count = table_read_be_word(table, subtable_offset + FIELD_OFFSET(struct ot_gsub_singlesubst_format2, count));
            }
            else
                WARN("Unrecognized single substitution format %u.\n", format);
        }
    }
 
    free(lookups.lookups);
 
    if (count)
        fontface->flags |= FONTFACE_VERTICAL_VARIANTS;
    else
        fontface->flags |= FONTFACE_NO_VERTICAL_VARIANTS;
 
    return !!(fontface->flags & FONTFACE_VERTICAL_VARIANTS);
}

Referenced by dwritefontface1_HasVerticalGlyphVariants(), and opentype_get_vertical_glyph_variants().

opentype_layout_apply_gpos_features()

void opentype_layout_apply_gpos_features	(	struct scriptshaping_context *	context,
		unsigned int	script_index,
		unsigned int	language_index,
		struct shaping_features *	features
	)

Definition at line 4932 of file opentype.c.

{
    struct lookups lookups = { 0 };
    unsigned int i;
    BOOL ret;
 
    context->nesting_level_left = SHAPE_MAX_NESTING_LEVEL;
    context->u.buffer.apply_context_lookup = opentype_layout_apply_gpos_context_lookup;
    opentype_layout_collect_lookups(context, script_index, language_index, features, &context->cache->gpos, &lookups);
 
    for (i = 0; i < context->glyph_count; ++i)
        opentype_set_glyph_props(context, i);
    opentype_layout_set_glyph_masks(context, features);
 
    for (i = 0; i < lookups.count; ++i)
    {
        const struct lookup *lookup = &lookups.lookups[i];
 
        context->cur = 0;
        context->lookup_mask = lookup->mask;
        context->auto_zwnj = lookup->auto_zwnj;
        context->auto_zwj = lookup->auto_zwj;
 
        while (context->cur < context->glyph_count)
        {
            ret = FALSE;
 
            if ((context->glyph_infos[context->cur].mask & lookup->mask) &&
                    lookup_is_glyph_match(context, context->cur, lookup->flags))
            {
                ret = opentype_layout_apply_gpos_lookup(context, lookup);
            }
 
            if (!ret)
                context->cur++;
        }
    }
 
    free(lookups.lookups);
 
    if (context->has_gpos_attachment)
    {
        for (i = 0; i < context->glyph_count; ++i)
            opentype_propagate_attachment_offsets(context, i);
    }
}

Referenced by shape_get_positions().

opentype_layout_apply_gsub_features()

void opentype_layout_apply_gsub_features	(	struct scriptshaping_context *	context,
		unsigned int	script_index,
		unsigned int	language_index,
		struct shaping_features *	features
	)

Definition at line 6116 of file opentype.c.

{
    struct lookups lookups = { 0 };
    unsigned int i = 0, j, start_idx;
    BOOL ret;
 
    context->nesting_level_left = SHAPE_MAX_NESTING_LEVEL;
    context->u.buffer.apply_context_lookup = opentype_layout_apply_gsub_context_lookup;
    opentype_layout_collect_lookups(context, script_index, language_index, features, context->table, &lookups);
 
    opentype_get_nominal_glyphs(context, features);
    opentype_layout_set_glyph_masks(context, features);
 
    for (j = 0; j <= features->stage; ++j)
    {
        for (; i < features->stages[j].last_lookup; ++i)
        {
            const struct lookup *lookup = &lookups.lookups[i];
 
            context->lookup_mask = lookup->mask;
            context->auto_zwnj = lookup->auto_zwnj;
            context->auto_zwj = lookup->auto_zwj;
 
            if (!opentype_is_gsub_lookup_reversed(context, lookup))
            {
                context->cur = 0;
                while (context->cur < context->glyph_count)
                {
                    ret = FALSE;
 
                    if ((context->glyph_infos[context->cur].mask & lookup->mask) &&
                            lookup_is_glyph_match(context, context->cur, lookup->flags))
                    {
                        ret = opentype_layout_apply_gsub_lookup(context, lookup);
                    }
 
                    if (!ret)
                        context->cur++;
                }
            }
            else
            {
                context->cur = context->glyph_count - 1;
 
                for (;;)
                {
                    if ((context->glyph_infos[context->cur].mask & lookup->mask) &&
                            lookup_is_glyph_match(context, context->cur, lookup->flags))
                    {
                        opentype_layout_apply_gsub_lookup(context, lookup);
                    }
 
                    if (context->cur == 0) break;
                    --context->cur;
                }
            }
        }
 
        if (features->stages[j].func)
            features->stages[j].func(context, features);
    }
 
    /* For every glyph range of [<last>.isClusterStart, <next>.isClusterStart) set corresponding
       text span to start_idx. */
    start_idx = 0;
    for (i = 1; i < context->glyph_count; ++i)
    {
        if (context->u.buffer.glyph_props[i].isClusterStart)
        {
            unsigned int start_text, end_text;
 
            start_text = context->glyph_infos[start_idx].start_text_idx;
            end_text = context->glyph_infos[i].start_text_idx;
 
            for (j = start_text; j < end_text; ++j)
                context->u.buffer.clustermap[j] = start_idx;
 
            start_idx = i;
        }
    }
 
    /* Fill the tail. */
    for (j = context->glyph_infos[start_idx].start_text_idx; j < context->length; ++j)
        context->u.buffer.clustermap[j] = start_idx;
 
    free(lookups.lookups);
}

Referenced by shape_get_glyphs().

opentype_layout_check_feature()

BOOL opentype_layout_check_feature	(	struct scriptshaping_context *	context,
		unsigned int	script_index,
		unsigned int	language_index,
		struct shaping_feature *	feature,
		unsigned int	glyph_count,
		const UINT16 *	glyphs,
		UINT8 *	feature_applies
	)

Definition at line 6391 of file opentype.c.

{
    p_lookup_is_glyph_covered_func func_is_covered;
    struct shaping_features features = { 0 };
    struct lookups lookups = { 0 };
    BOOL ret = FALSE, is_covered;
    unsigned int i, j, applies;
 
    features.features = feature;
    features.count = 1;
 
    for (i = 0; i < context->glyph_count; ++i)
        opentype_set_glyph_props(context, i);
 
    opentype_layout_collect_lookups(context, script_index, language_index, &features, context->table, &lookups);
 
    func_is_covered = opentype_layout_is_subst_context(context) ? opentype_layout_gsub_lookup_is_glyph_covered :
            opentype_layout_gpos_lookup_is_glyph_covered;
 
    for (i = 0; i < lookups.count; ++i)
    {
        struct lookup *lookup = &lookups.lookups[i];
 
        applies = 0;
        for (j = 0; j < context->glyph_count; ++j)
        {
            if (lookup_is_glyph_match(context, j, lookup->flags))
            {
                if ((is_covered = func_is_covered(context, glyphs[i], lookup)))
                    ++applies;
                feature_applies[j] |= is_covered;
            }
        }
 
        if ((ret = (applies == context->glyph_count)))
            break;
    }
 
    free(lookups.lookups);
 
    return ret;
}

Referenced by shape_check_typographic_feature().

opentype_layout_find_language()

unsigned int opentype_layout_find_language	(	const struct scriptshaping_cache *	cache,
		unsigned int	kind,
		DWORD	tag,
		unsigned int	script_index,
		unsigned int *	language_index
	)

Definition at line 3309 of file opentype.c.

{
    const struct ot_gsubgpos_table *table = kind == MS_GSUB_TAG ? &cache->gsub : &cache->gpos;
    UINT16 table_offset, lang_count;
    unsigned int i;
 
    *language_index = ~0u;
 
    table_offset = table_read_be_word(&table->table, table->script_list + FIELD_OFFSET(struct ot_script_list, scripts) +
            script_index * sizeof(struct ot_script_record) + FIELD_OFFSET(struct ot_script_record, script));
    if (!table_offset)
        return 0;
 
    lang_count = table_read_be_word(&table->table, table->script_list + table_offset +
            FIELD_OFFSET(struct ot_script, langsys_count));
    for (i = 0; i < lang_count; i++)
    {
        unsigned int tag = table_read_dword(&table->table, table->script_list + table_offset +
                FIELD_OFFSET(struct ot_script, langsys) + i * sizeof(struct ot_langsys_record));
 
        if (tag == language)
        {
            *language_index = i;
            return language;
        }
    }
 
    /* Try 'defaultLangSys' if it's set. */
    if (table_read_be_word(&table->table, table->script_list + table_offset))
        return ~0u;
 
    return 0;
}

Referenced by shape_select_language().

opentype_layout_find_script()

unsigned int opentype_layout_find_script	(	const struct scriptshaping_cache *	cache,
		unsigned int	kind,
		DWORD	tag,
		unsigned int *	script_index
	)

Definition at line 3279 of file opentype.c.

{
    const struct ot_gsubgpos_table *table = kind == MS_GSUB_TAG ? &cache->gsub : &cache->gpos;
    UINT16 script_count;
    unsigned int i;
 
    *script_index = ~0u;
 
    script_count = table_read_be_word(&table->table, table->script_list);
    if (!script_count)
        return 0;
 
    for (i = 0; i < script_count; i++)
    {
        unsigned int tag = table_read_dword(&table->table, table->script_list + FIELD_OFFSET(struct ot_script_list, scripts) +
                i * sizeof(struct ot_script_record));
        if (!tag)
            continue;
 
        if (tag == script)
        {
            *script_index = i;
            return script;
        }
    }
 
    return 0;
}

Referenced by shape_select_script().

opentype_layout_scriptshaping_cache_init()

void opentype_layout_scriptshaping_cache_init

(

struct scriptshaping_cache *

cache

)

Definition at line 3238 of file opentype.c.

{
    cache->font->grab_font_table(cache->context, MS_GSUB_TAG, &cache->gsub.table.data, &cache->gsub.table.size,
            &cache->gsub.table.context);
 
    if (cache->gsub.table.data)
    {
        cache->gsub.script_list = table_read_be_word(&cache->gsub.table, FIELD_OFFSET(struct gpos_gsub_header, script_list));
        cache->gsub.feature_list = table_read_be_word(&cache->gsub.table, FIELD_OFFSET(struct gpos_gsub_header, feature_list));
        cache->gsub.lookup_list = table_read_be_word(&cache->gsub.table, FIELD_OFFSET(struct gpos_gsub_header, lookup_list));
    }
 
    cache->font->grab_font_table(cache->context, MS_GPOS_TAG, &cache->gpos.table.data, &cache->gpos.table.size,
            &cache->gpos.table.context);
 
    if (cache->gpos.table.data)
    {
        cache->gpos.script_list = table_read_be_word(&cache->gpos.table,
                FIELD_OFFSET(struct gpos_gsub_header, script_list));
        cache->gpos.feature_list = table_read_be_word(&cache->gpos.table,
                FIELD_OFFSET(struct gpos_gsub_header, feature_list));
        cache->gpos.lookup_list = table_read_be_word(&cache->gpos.table,
                FIELD_OFFSET(struct gpos_gsub_header, lookup_list));
    }
 
    cache->font->grab_font_table(cache->context, MS_GDEF_TAG, &cache->gdef.table.data, &cache->gdef.table.size,
            &cache->gdef.table.context);
 
    if (cache->gdef.table.data)
    {
        unsigned int version = table_read_be_dword(&cache->gdef.table, 0);
 
        cache->gdef.classdef = table_read_be_word(&cache->gdef.table, FIELD_OFFSET(struct gdef_header, classdef));
        cache->gdef.markattachclassdef = table_read_be_word(&cache->gdef.table,
                FIELD_OFFSET(struct gdef_header, markattach_classdef));
        if (version >= 0x00010002)
            cache->gdef.markglyphsetdef = table_read_be_word(&cache->gdef.table,
                    FIELD_OFFSET(struct gdef_header, markglyphsetdef));
    }
}

Referenced by create_scriptshaping_cache().

opentype_layout_unsafe_to_break()

void opentype_layout_unsafe_to_break	(	struct scriptshaping_context *	context,
		unsigned int	start,
		unsigned int	end
	)

Definition at line 5233 of file opentype.c.

{
    unsigned int i;
 
    while (start && !context->u.buffer.glyph_props[start].isClusterStart)
        --start;
 
    while (--end && !context->u.buffer.glyph_props[end].isClusterStart)
        ;
 
    if (start == end)
    {
        context->u.buffer.text_props[context->glyph_infos[start].start_text_idx].canBreakShapingAfter = 0;
        return;
    }
 
    for (i = context->glyph_infos[start].start_text_idx; i < context->glyph_infos[end].start_text_idx; ++i)
    {
        context->u.buffer.text_props[i].canBreakShapingAfter = 0;
    }
}

Referenced by arabic_setup_masks(), and opentype_layout_apply_ligature().

opentype_try_get_font_table()

HRESULT opentype_try_get_font_table	(	const struct file_stream_desc *	stream_desc,
		UINT32	tag,
		const void **	data,
		void **	context,
		UINT32 *	size,
		BOOL *	exists
	)

Definition at line 1528 of file opentype.c.

{
    void *table_directory_context, *sfnt_context;
    const struct ot_table_record *table_record = NULL;
    const struct ot_table_dir *table_dir = NULL;
    UINT32 table_offset = 0;
    UINT16 table_count;
    HRESULT hr;
 
    if (found) *found = FALSE;
    if (table_size) *table_size = 0;
 
    *table_data = NULL;
    *table_context = NULL;
 
    if (stream_desc->face_type == DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION)
    {
        const struct ttc_header *ttc_header;
        void * ttc_context;
 
        hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void **)&ttc_header, 0,
                sizeof(*ttc_header), &ttc_context);
        if (SUCCEEDED(hr))
        {
            if (stream_desc->face_index >= GET_BE_DWORD(ttc_header->num_fonts))
                hr = E_INVALIDARG;
            else
            {
                table_offset = GET_BE_DWORD(ttc_header->offsets[stream_desc->face_index]);
                hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void **)&table_dir, table_offset,
                        sizeof(*table_dir), &sfnt_context);
            }
            IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, ttc_context);
        }
    }
    else
        hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void **)&table_dir, 0,
                sizeof(*table_dir), &sfnt_context);
 
    if (FAILED(hr))
        return hr;
 
    table_count = GET_BE_WORD(table_dir->numTables);
    table_offset += sizeof(*table_dir);
 
    IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, sfnt_context);
 
    hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void **)&table_record, table_offset,
            table_count * sizeof(*table_record), &table_directory_context);
    if (hr == S_OK)
    {
        UINT16 i;
 
        for (i = 0; i < table_count; ++i)
        {
            if (table_record->tag == tag)
            {
                UINT32 offset = GET_BE_DWORD(table_record->offset);
                UINT32 length = GET_BE_DWORD(table_record->length);
 
                if (found)
                    *found = TRUE;
                if (table_size)
                    *table_size = length;
                hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, table_data, offset,
                        length, table_context);
                break;
            }
            table_record++;
        }
 
        IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, table_directory_context);
    }
 
    return hr;
}

Referenced by dwritefontface_TryGetFontTable(), and opentype_get_font_table().

release_format_data()

void release_format_data

(

struct dwrite_textformat_data *

data

)

Definition at line 40 of file format.c.

{
    if (data->collection)
        IDWriteFontCollection_Release(data->collection);
    if (data->fallback)
        IDWriteFontFallback_Release(data->fallback);
    if (data->trimmingsign)
        IDWriteInlineObject_Release(data->trimmingsign);
    free(data->family_name);
    free(data->locale);
    free(data->axis_values);
}

Referenced by dwritetextformat_Release(), and dwritetextlayout_Release().

release_scriptshaping_cache()

void release_scriptshaping_cache

(

struct scriptshaping_cache *

cache

)

Definition at line 59 of file shape.c.

{
    if (!cache)
        return;
 
    cache->font->release_font_table(cache->context, cache->gdef.table.context);
    cache->font->release_font_table(cache->context, cache->gsub.table.context);
    cache->font->release_font_table(cache->context, cache->gpos.table.context);
    free(cache);
}

Referenced by dwritefontface_Release().

release_system_fallback_data()

void release_system_fallback_data

(

void

)

Definition at line 3024 of file analyzer.c.

{
    release_fallback_data(&system_fallback);
}

Referenced by DllMain().

release_system_fontfallback()

void release_system_fontfallback

(

IDWriteFontFallback1 *

fallback

)

Definition at line 2575 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback = impl_from_IDWriteFontFallback1(iface);
    IDWriteFontCollection_Release(fallback->systemcollection);
    free(fallback);
}

Referenced by release_dwritefactory().

set_en_localizedstring()

void set_en_localizedstring	(	IDWriteLocalizedStrings *	iface,
		const WCHAR *	string
	)

Definition at line 533 of file main.c.

{
    struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
    UINT32 i;
 
    for (i = 0; i < strings->count; i++)
    {
        if (!wcsicmp(strings->data[i].locale, L"en-US"))
        {
            free(strings->data[i].string);
            strings->data[i].string = wcsdup(string);
            break;
        }
    }
}

Referenced by init_font_data().

shape_add_feature_full()

void shape_add_feature_full	(	struct shaping_features *	features,
		unsigned int	tag,
		unsigned int	flags,
		unsigned int	value
	)

Definition at line 117 of file shape.c.

{
    unsigned int i = features->count;
 
    if (!dwrite_array_reserve((void **)&features->features, &features->capacity, features->count + 1,
            sizeof(*features->features)))
        return;
 
    features->features[i].tag = tag;
    features->features[i].flags = flags;
    features->features[i].max_value = value;
    features->features[i].default_value = flags & FEATURE_GLOBAL ? value : 0;
    features->features[i].stage = features->stage;
    features->count++;
}

Referenced by arabic_collect_features(), shape_add_feature(), shape_enable_feature(), shape_get_glyphs(), shape_get_positions(), and shape_merge_features().

shape_check_typographic_feature()

HRESULT shape_check_typographic_feature	(	struct scriptshaping_context *	context,
		const unsigned int *	scripts,
		unsigned int	tag,
		unsigned int	glyph_count,
		const UINT16 *	glyphs,
		UINT8 *	feature_applies
	)

Definition at line 415 of file shape.c.

{
    static const unsigned int tables[] = { MS_GSUB_TAG, MS_GPOS_TAG };
    struct shaping_feature feature = { .tag = tag };
    unsigned int script_index, language_index;
    unsigned int i;
 
    memset(feature_applies, 0, glyph_count * sizeof(*feature_applies));
 
    for (i = 0; i < ARRAY_SIZE(tables); ++i)
    {
        shape_get_script_lang_index(context, scripts, tables[i], &script_index, &language_index);
        context->table = tables[i] == MS_GSUB_TAG ? &context->cache->gsub : &context->cache->gpos;
        /* Skip second table if feature applies to all. */
        if (opentype_layout_check_feature(context, script_index, language_index, &feature, glyph_count,
                glyphs, feature_applies))
        {
            break;
        }
    }
 
    return S_OK;
}

Referenced by dwritetextanalyzer2_CheckTypographicFeature().

shape_enable_feature()

void shape_enable_feature	(	struct shaping_features *	features,
		unsigned int	tag,
		unsigned int	flags
	)

Definition at line 138 of file shape.c.

{
    shape_add_feature_full(features, tag, FEATURE_GLOBAL | flags, 1);
}

Referenced by arabic_collect_features(), and shape_get_glyphs().

shape_get_feature_1_mask()

unsigned int shape_get_feature_1_mask	(	const struct shaping_features *	features,
		unsigned int	tag
	)

Definition at line 4822 of file opentype.c.

{
    unsigned int shift, mask = shaping_features_get_mask(features, tag, &shift);
    return (1 << shift) & mask;
}

Referenced by arabic_setup_masks().

shape_get_glyphs()

HRESULT shape_get_glyphs	(	struct scriptshaping_context *	context,
		const unsigned int *	scripts
	)

Definition at line 308 of file shape.c.

{
    static const unsigned int common_features[] =
    {
        DWRITE_MAKE_OPENTYPE_TAG('c','c','m','p'),
        DWRITE_MAKE_OPENTYPE_TAG('l','o','c','l'),
        DWRITE_MAKE_OPENTYPE_TAG('r','l','i','g'),
    };
    static const unsigned int horizontal_features[] =
    {
        DWRITE_MAKE_OPENTYPE_TAG('c','a','l','t'),
        DWRITE_MAKE_OPENTYPE_TAG('c','l','i','g'),
        DWRITE_MAKE_OPENTYPE_TAG('l','i','g','a'),
        DWRITE_MAKE_OPENTYPE_TAG('r','c','l','t'),
    };
    unsigned int script_index, language_index;
    struct shaping_features features = { 0 };
    unsigned int i;
 
    shape_set_shaper(context);
 
    if (!context->is_sideways)
    {
        if (context->is_rtl)
        {
            shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('r','t','l','a'), 0);
            shape_add_feature_full(&features, DWRITE_MAKE_OPENTYPE_TAG('r','t','l','m'), 0, 1);
        }
        else
        {
            shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('l','t','r','a'), 0);
            shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('l','t','r','m'), 0);
        }
    }
 
    if (context->shaper->collect_features)
        context->shaper->collect_features(context, &features);
 
    for (i = 0; i < ARRAY_SIZE(common_features); ++i)
        shape_add_feature(&features, common_features[i]);
 
    /* Horizontal features */
    if (!context->is_sideways)
    {
        for (i = 0; i < ARRAY_SIZE(horizontal_features); ++i)
            shape_add_feature(&features, horizontal_features[i]);
    }
    else
        shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('v','e','r','t'), FEATURE_GLOBAL_SEARCH);
 
    shape_merge_features(context, &features);
 
    /* Resolve script tag to actually supported script. */
    shape_get_script_lang_index(context, scripts, MS_GSUB_TAG, &script_index, &language_index);
    opentype_layout_apply_gsub_features(context, script_index, language_index, &features);
 
    free(features.features);
 
    return (context->glyph_count <= context->u.subst.max_glyph_count) ? S_OK : E_NOT_SUFFICIENT_BUFFER;
}

Referenced by dwritetextanalyzer_GetGlyphs().

shape_get_positions()

HRESULT shape_get_positions	(	struct scriptshaping_context *	context,
		const unsigned int *	scripts
	)

Definition at line 233 of file shape.c.

{
    static const struct shaping_feature common_features[] =
    {
        { DWRITE_MAKE_OPENTYPE_TAG('a','b','v','m') },
        { DWRITE_MAKE_OPENTYPE_TAG('b','l','w','m') },
        { DWRITE_MAKE_OPENTYPE_TAG('m','a','r','k'), FEATURE_MANUAL_JOINERS },
        { DWRITE_MAKE_OPENTYPE_TAG('m','k','m','k'), FEATURE_MANUAL_JOINERS },
    };
    static const unsigned int horizontal_features[] =
    {
        DWRITE_MAKE_OPENTYPE_TAG('c','u','r','s'),
        DWRITE_MAKE_OPENTYPE_TAG('d','i','s','t'),
        DWRITE_MAKE_OPENTYPE_TAG('k','e','r','n'),
    };
    struct scriptshaping_cache *cache = context->cache;
    unsigned int script_index, language_index, script, i;
    struct shaping_features features = { 0 };
 
    shape_set_shaper(context);
 
    for (i = 0; i < ARRAY_SIZE(common_features); ++i)
        shape_add_feature_full(&features, common_features[i].tag, FEATURE_GLOBAL | common_features[i].flags, 1);
 
    /* Horizontal features */
    if (!context->is_sideways)
    {
        for (i = 0; i < ARRAY_SIZE(horizontal_features); ++i)
            shape_add_feature(&features, horizontal_features[i]);
    }
 
    shape_merge_features(context, &features);
 
    /* Resolve script tag to actually supported script. */
    if (cache->gpos.table.data)
    {
        if ((script = shape_select_script(cache, MS_GPOS_TAG, scripts, &script_index)))
        {
            DWORD language = context->language_tag;
 
            if ((language = shape_select_language(cache, MS_GPOS_TAG, script_index, language, &language_index)))
            {
                TRACE("script %s, language %s.\n", debugstr_fourcc(script), language != ~0u ?
                        debugstr_fourcc(language) : "deflangsys");
                opentype_layout_apply_gpos_features(context, script_index, language_index, &features);
            }
        }
    }
 
    for (i = 0; i < context->glyph_count; ++i)
        if (context->u.pos.glyph_props[i].isZeroWidthSpace)
            context->advances[i] = 0.0f;
 
    free(features.features);
 
    return S_OK;
}

Referenced by dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(), and dwritetextanalyzer_GetGlyphPlacements().

shape_get_typographic_features()

HRESULT shape_get_typographic_features	(	struct scriptshaping_context *	context,
		const unsigned int *	scripts,
		unsigned int	max_tagcount,
		unsigned int *	actual_tagcount,
		DWRITE_FONT_FEATURE_TAG *	tags
	)

Definition at line 375 of file shape.c.

{
    unsigned int i, j, script_index, language_index;
    struct tag_array t = { 0 };
 
    /* Collect from both tables, sort and remove duplicates. */
 
    shape_get_script_lang_index(context, scripts, MS_GSUB_TAG, &script_index, &language_index);
    opentype_get_typographic_features(&context->cache->gsub, script_index, language_index, &t);
 
    shape_get_script_lang_index(context, scripts, MS_GPOS_TAG, &script_index, &language_index);
    opentype_get_typographic_features(&context->cache->gpos, script_index, language_index, &t);
 
    if (t.count == 0)
    {
        *actual_tagcount = 0;
        return S_OK;
    }
 
    /* Sort and remove duplicates. */
    qsort(t.tags, t.count, sizeof(*t.tags), tag_array_sorting_compare);
 
    for (i = 1, j = 0; i < t.count; ++i)
    {
        if (t.tags[i] != t.tags[j])
            t.tags[++j] = t.tags[i];
    }
    t.count = j + 1;
 
    if (t.count <= max_tagcount)
        memcpy(tags, t.tags, t.count * sizeof(*t.tags));
 
    *actual_tagcount = t.count;
 
    free(t.tags);
 
    return t.count <= max_tagcount ? S_OK : E_NOT_SUFFICIENT_BUFFER;
}

Referenced by dwritetextanalyzer2_GetTypographicFeatures().

shape_start_next_stage()

void shape_start_next_stage	(	struct shaping_features *	features,
		stage_func	func
	)

Definition at line 144 of file shape.c.

{
    features->stages[features->stage].func = func;
    features->stage++;
}

Referenced by arabic_collect_features().

sort_localizedstrings()

void sort_localizedstrings

(

IDWriteLocalizedStrings *

iface

)

Definition at line 556 of file main.c.

{
    struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 
    qsort(strings->data, strings->count, sizeof(*strings->data), localizedstrings_sorting_compare);
}

Referenced by opentype_get_font_strings_from_id().

unsafe_impl_from_IDWriteFontFace()

struct dwrite_fontface * unsafe_impl_from_IDWriteFontFace

(

IDWriteFontFace *

iface

)

Definition at line 2536 of file font.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (IDWriteFontFaceVtbl*)&dwritefontfacevtbl);
    return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace5_iface);
}

Referenced by compute_glyph_origins(), create_colorglyphenum(), dwrite_fontface_get_glyph_bbox(), dwritefontface5_Equals(), dwritetextanalyzer1_GetBaseline(), dwritetextanalyzer2_CheckTypographicFeature(), dwritetextanalyzer2_GetTypographicFeatures(), dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(), dwritetextanalyzer_GetGlyphPlacements(), dwritetextanalyzer_GetGlyphs(), get_fontsig_from_fontface(), get_logfont_from_fontface(), and glyphrunanalysis_render().

unsafe_impl_from_IDWriteTextFormat()

struct dwrite_textformat * unsafe_impl_from_IDWriteTextFormat

(

IDWriteTextFormat *

iface

)

Definition at line 708 of file format.c.

{
    return (iface->lpVtbl == (IDWriteTextFormatVtbl *)&dwritetextformatvtbl) ?
        CONTAINING_RECORD(iface, struct dwrite_textformat, IDWriteTextFormat3_iface) : NULL;
}

Referenced by layout_format_from_textformat().

Variable Documentation

arabic_shaper

const struct shaper arabic_shaper

extern

Definition at line 185 of file arabic.c.

Referenced by shape_set_shaper().

dwrite_module

HMODULE dwrite_module

extern

Definition at line 38 of file main.c.

Referenced by DllMain().

identity

const DWRITE_MATRIX identity

static

Initial value:

=
{
    1.0f, 0.0f,
    0.0f, 1.0f,
    0.0f, 0.0f
}

Definition at line 41 of file dwrite_private.h.

Referenced by dwritefactory_CreateGlyphRunAnalysis().

identity_2x2

const MATRIX_2X2 identity_2x2

static

Initial value:

=
{
    1.0f, 0.0f,
    0.0f, 1.0f,
}

Definition at line 48 of file dwrite_private.h.

Referenced by dwrite_fontface_get_glyph_bbox(), and dwrite_fontface_get_glyph_bitmap().