analyzer.c File Reference

#include <math.h>
#include "dwrite_private.h"
#include "scripts.h"

Include dependency graph for analyzer.c:

Go to the source code of this file.

Classes
struct	dwritescript_properties
struct	fallback_description
struct	text_source_context
struct	fallback_mapping
struct	fallback_locale
struct	fallback_data
struct	dwrite_fontfallback
struct	dwrite_fontfallback_builder
struct	dwrite_numbersubstitution
struct	break_index
struct	linebreaking_state

Macros
#define	COBJMACROS
#define	NATIVE_DIGITS_LEN   11
#define	_OT(a, b, c, d)   DWRITE_MAKE_OPENTYPE_TAG(a,b,c,d)

Enumerations
enum	BreakConditionLocation { BreakConditionBefore , BreakConditionAfter }
enum	linebreaking_classes {   b_BK = 1 , b_CR , b_LF , b_CM ,   b_SG , b_GL , b_CB , b_SP ,   b_ZW , b_NL , b_WJ , b_JL ,   b_JV , b_JT , b_H2 , b_H3 ,   b_XX , b_OP , b_CL , b_CP ,   b_QU , b_NS , b_EX , b_SY ,   b_IS , b_PR , b_PO , b_NU ,   b_AL , b_ID , b_IN , b_HY ,   b_BB , b_BA , b_SA , b_AI ,   b_B2 , b_HL , b_CJ , b_RI ,   b_EB , b_EM , b_ZWJ }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dwrite)
const char *	debugstr_sa_script (UINT16 script)
static unsigned int	text_source_get_char_length (const struct text_source_context *context)
static void	text_source_read_more (struct text_source_context *context)
static void	text_source_get_u32_char (struct text_source_context *context)
static HRESULT	text_source_context_init (struct text_source_context *context, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length)
static BOOL	text_source_get_next_u32_char (struct text_source_context *context)
static void	fallback_locale_list_destroy (struct list *locales)
static HRESULT	fallback_locale_add_mapping (struct fallback_locale *locale, size_t index)
static struct fallback_locale *	font_fallback_get_locale (const struct list *locales, const WCHAR *locale_name)
static void	release_fallback_mapping (struct fallback_mapping *mapping)
static void	release_fallback_data (struct fallback_data *data)
static BOOL	fallback_mapping_contains_character (const struct fallback_mapping *mapping, UINT32 ch)
static const struct fallback_mapping *	find_fallback_mapping (const struct fallback_data *fallback, const struct fallback_locale *locale, UINT32 ch)
static struct dwrite_numbersubstitution *	impl_from_IDWriteNumberSubstitution (IDWriteNumberSubstitution *iface)
static struct dwrite_numbersubstitution *	unsafe_impl_from_IDWriteNumberSubstitution (IDWriteNumberSubstitution *iface)
static struct dwrite_fontfallback *	impl_from_IDWriteFontFallback1 (IDWriteFontFallback1 *iface)
static struct dwrite_fontfallback_builder *	impl_from_IDWriteFontFallbackBuilder (IDWriteFontFallbackBuilder *iface)
static UINT16	get_char_script (UINT32 c)
static DWRITE_SCRIPT_ANALYSIS	get_char_sa (UINT32 c)
static HRESULT	analyze_script (struct text_source_context *context, IDWriteTextAnalysisSink *sink)
static BOOL	has_strong_condition (DWRITE_BREAK_CONDITION old_condition, DWRITE_BREAK_CONDITION new_condition)
static void	set_break_condition (UINT32 pos, enum BreakConditionLocation location, DWRITE_BREAK_CONDITION condition, struct linebreaking_state *state)
BOOL	lb_is_newline_char (WCHAR ch)
static HRESULT	analyze_linebreaks (IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, DWRITE_LINE_BREAKPOINT *breakpoints)
static HRESULT WINAPI	dwritetextanalyzer_QueryInterface (IDWriteTextAnalyzer2 *iface, REFIID riid, void **obj)
static ULONG WINAPI	dwritetextanalyzer_AddRef (IDWriteTextAnalyzer2 *iface)
static ULONG WINAPI	dwritetextanalyzer_Release (IDWriteTextAnalyzer2 *iface)
static HRESULT WINAPI	dwritetextanalyzer_AnalyzeScript (IDWriteTextAnalyzer2 *iface, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, IDWriteTextAnalysisSink *sink)
static unsigned int	get_bidi_char_length (const struct bidi_char *c)
static UINT8	get_char_bidi_class (UINT32 ch)
static HRESULT WINAPI	dwritetextanalyzer_AnalyzeBidi (IDWriteTextAnalyzer2 *iface, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, IDWriteTextAnalysisSink *sink)
static HRESULT WINAPI	dwritetextanalyzer_AnalyzeNumberSubstitution (IDWriteTextAnalyzer2 *iface, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, IDWriteTextAnalysisSink *sink)
static HRESULT WINAPI	dwritetextanalyzer_AnalyzeLineBreakpoints (IDWriteTextAnalyzer2 *iface, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, IDWriteTextAnalysisSink *sink)
static UINT32	get_opentype_language (const WCHAR *locale)
static void	get_number_substitutes (IDWriteNumberSubstitution *substitution, BOOL is_rtl, WCHAR *digits)
static void	analyzer_dump_user_features (DWRITE_TYPOGRAPHIC_FEATURES const **features, UINT32 const *feature_range_lengths, UINT32 feature_ranges)
static HRESULT WINAPI	dwritetextanalyzer_GetGlyphs (IDWriteTextAnalyzer2 *iface, WCHAR const *text, UINT32 length, IDWriteFontFace *fontface, BOOL is_sideways, BOOL is_rtl, DWRITE_SCRIPT_ANALYSIS const *analysis, WCHAR const *locale, IDWriteNumberSubstitution *substitution, DWRITE_TYPOGRAPHIC_FEATURES const **features, UINT32 const *feature_range_lengths, UINT32 feature_ranges, UINT32 max_glyph_count, UINT16 *clustermap, DWRITE_SHAPING_TEXT_PROPERTIES *text_props, UINT16 *glyphs, DWRITE_SHAPING_GLYPH_PROPERTIES *glyph_props, UINT32 *actual_glyph_count)
static HRESULT WINAPI	dwritetextanalyzer_GetGlyphPlacements (IDWriteTextAnalyzer2 *iface, WCHAR const *text, UINT16 const *clustermap, DWRITE_SHAPING_TEXT_PROPERTIES *text_props, UINT32 text_len, UINT16 const *glyphs, DWRITE_SHAPING_GLYPH_PROPERTIES const *glyph_props, UINT32 glyph_count, IDWriteFontFace *fontface, float emSize, BOOL is_sideways, BOOL is_rtl, DWRITE_SCRIPT_ANALYSIS const *analysis, WCHAR const *locale, DWRITE_TYPOGRAPHIC_FEATURES const **features, UINT32 const *feature_range_lengths, UINT32 feature_ranges, float *advances, DWRITE_GLYPH_OFFSET *offsets)
static HRESULT WINAPI	dwritetextanalyzer_GetGdiCompatibleGlyphPlacements (IDWriteTextAnalyzer2 *iface, WCHAR const *text, UINT16 const *clustermap, DWRITE_SHAPING_TEXT_PROPERTIES *text_props, UINT32 text_len, UINT16 const *glyphs, DWRITE_SHAPING_GLYPH_PROPERTIES const *glyph_props, UINT32 glyph_count, IDWriteFontFace *fontface, float emSize, float ppdip, DWRITE_MATRIX const *transform, BOOL use_gdi_natural, BOOL is_sideways, BOOL is_rtl, DWRITE_SCRIPT_ANALYSIS const *analysis, WCHAR const *locale, DWRITE_TYPOGRAPHIC_FEATURES const **features, UINT32 const *feature_range_lengths, UINT32 feature_ranges, float *advances, DWRITE_GLYPH_OFFSET *offsets)
static HRESULT	apply_cluster_spacing (float leading_spacing, float trailing_spacing, float min_advance_width, unsigned int start, unsigned int end, float const *advances, DWRITE_GLYPH_OFFSET const *offsets, DWRITE_SHAPING_GLYPH_PROPERTIES const *glyph_props, float *modified_advances, DWRITE_GLYPH_OFFSET *modified_offsets)
static UINT32	get_cluster_length (UINT16 const *clustermap, UINT32 start, UINT32 text_len)
static HRESULT WINAPI	dwritetextanalyzer1_ApplyCharacterSpacing (IDWriteTextAnalyzer2 *iface, FLOAT leading_spacing, FLOAT trailing_spacing, FLOAT min_advance_width, UINT32 len, UINT32 glyph_count, UINT16 const *clustermap, FLOAT const *advances, DWRITE_GLYPH_OFFSET const *offsets, DWRITE_SHAPING_GLYPH_PROPERTIES const *props, FLOAT *modified_advances, DWRITE_GLYPH_OFFSET *modified_offsets)
static HRESULT WINAPI	dwritetextanalyzer1_GetBaseline (IDWriteTextAnalyzer2 *iface, IDWriteFontFace *fontface, DWRITE_BASELINE baseline, BOOL vertical, BOOL is_simulation_allowed, DWRITE_SCRIPT_ANALYSIS sa, const WCHAR *localeName, INT32 *baseline_coord, BOOL *exists)
static HRESULT WINAPI	dwritetextanalyzer1_AnalyzeVerticalGlyphOrientation (IDWriteTextAnalyzer2 *iface, IDWriteTextAnalysisSource1 *source, UINT32 text_pos, UINT32 len, IDWriteTextAnalysisSink1 *sink)
static HRESULT WINAPI	dwritetextanalyzer1_GetGlyphOrientationTransform (IDWriteTextAnalyzer2 *iface, DWRITE_GLYPH_ORIENTATION_ANGLE angle, BOOL is_sideways, DWRITE_MATRIX *transform)
static HRESULT WINAPI	dwritetextanalyzer1_GetScriptProperties (IDWriteTextAnalyzer2 *iface, DWRITE_SCRIPT_ANALYSIS sa, DWRITE_SCRIPT_PROPERTIES *props)
static BOOL	is_char_from_simple_script (WCHAR c)
static HRESULT WINAPI	dwritetextanalyzer1_GetTextComplexity (IDWriteTextAnalyzer2 *iface, const WCHAR *text, UINT32 len, IDWriteFontFace *face, BOOL *is_simple, UINT32 *len_read, UINT16 *indices)
static HRESULT WINAPI	dwritetextanalyzer1_GetJustificationOpportunities (IDWriteTextAnalyzer2 *iface, IDWriteFontFace *face, FLOAT font_em_size, DWRITE_SCRIPT_ANALYSIS sa, UINT32 length, UINT32 glyph_count, const WCHAR *text, const UINT16 *clustermap, const DWRITE_SHAPING_GLYPH_PROPERTIES *prop, DWRITE_JUSTIFICATION_OPPORTUNITY *jo)
static HRESULT WINAPI	dwritetextanalyzer1_JustifyGlyphAdvances (IDWriteTextAnalyzer2 *iface, FLOAT width, UINT32 glyph_count, const DWRITE_JUSTIFICATION_OPPORTUNITY *jo, const FLOAT *advances, const DWRITE_GLYPH_OFFSET *offsets, FLOAT *justifiedadvances, DWRITE_GLYPH_OFFSET *justifiedoffsets)
static HRESULT WINAPI	dwritetextanalyzer1_GetJustifiedGlyphs (IDWriteTextAnalyzer2 *iface, IDWriteFontFace *face, FLOAT font_em_size, DWRITE_SCRIPT_ANALYSIS sa, UINT32 length, UINT32 glyph_count, UINT32 max_glyphcount, const UINT16 *clustermap, const UINT16 *indices, const FLOAT *advances, const FLOAT *justifiedadvances, const DWRITE_GLYPH_OFFSET *justifiedoffsets, const DWRITE_SHAPING_GLYPH_PROPERTIES *prop, UINT32 *actual_count, UINT16 *modified_clustermap, UINT16 *modified_indices, FLOAT *modified_advances, DWRITE_GLYPH_OFFSET *modified_offsets)
static HRESULT WINAPI	dwritetextanalyzer2_GetGlyphOrientationTransform (IDWriteTextAnalyzer2 *iface, DWRITE_GLYPH_ORIENTATION_ANGLE angle, BOOL is_sideways, FLOAT originX, FLOAT originY, DWRITE_MATRIX *m)
static HRESULT WINAPI	dwritetextanalyzer2_GetTypographicFeatures (IDWriteTextAnalyzer2 *iface, IDWriteFontFace *fontface, DWRITE_SCRIPT_ANALYSIS sa, const WCHAR *locale, UINT32 max_tagcount, UINT32 *actual_tagcount, DWRITE_FONT_FEATURE_TAG *tags)
static HRESULT WINAPI	dwritetextanalyzer2_CheckTypographicFeature (IDWriteTextAnalyzer2 *iface, IDWriteFontFace *fontface, DWRITE_SCRIPT_ANALYSIS sa, const WCHAR *locale, DWRITE_FONT_FEATURE_TAG feature, UINT32 glyph_count, const UINT16 *glyphs, UINT8 *feature_applies)
IDWriteTextAnalyzer2 *	get_text_analyzer (void)
static HRESULT WINAPI	dwritenumbersubstitution_QueryInterface (IDWriteNumberSubstitution *iface, REFIID riid, void **obj)
static ULONG WINAPI	dwritenumbersubstitution_AddRef (IDWriteNumberSubstitution *iface)
static ULONG WINAPI	dwritenumbersubstitution_Release (IDWriteNumberSubstitution *iface)
HRESULT	create_numbersubstitution (DWRITE_NUMBER_SUBSTITUTION_METHOD method, const WCHAR *locale, BOOL ignore_user_override, IDWriteNumberSubstitution **ret)
static HRESULT WINAPI	fontfallback_QueryInterface (IDWriteFontFallback1 *iface, REFIID riid, void **obj)
static ULONG WINAPI	fontfallback_AddRef (IDWriteFontFallback1 *iface)
static ULONG WINAPI	fontfallback_Release (IDWriteFontFallback1 *iface)
static BOOL	fallback_is_uvs (const struct text_source_context *context)
static UINT32	fallback_font_get_supported_length (IDWriteFont3 *font, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length)
static HRESULT	fallback_map_characters (const struct dwrite_fontfallback *fallback, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 text_length, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style, DWRITE_FONT_STRETCH stretch, IDWriteFont **ret_font, UINT32 *ret_length, float *scale)
HRESULT	create_matching_font (IDWriteFontCollection *collection, const WCHAR *name, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style, DWRITE_FONT_STRETCH stretch, REFIID riid, void **obj)
static HRESULT WINAPI	fontfallback_MapCharacters (IDWriteFontFallback1 *iface, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, IDWriteFontCollection *basecollection, const WCHAR *basefamily, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style, DWRITE_FONT_STRETCH stretch, UINT32 *mapped_length, IDWriteFont **ret_font, float *scale)
static HRESULT WINAPI	fontfallback1_MapCharacters (IDWriteFontFallback1 *iface, IDWriteTextAnalysisSource *source, UINT32 position, UINT32 length, IDWriteFontCollection *basecollection, const WCHAR *basefamily, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 values_count, UINT32 *mapped_length, FLOAT *scale, IDWriteFontFace5 **ret_fontface)
void	release_system_fontfallback (IDWriteFontFallback1 *iface)
static ULONG WINAPI	customfontfallback_AddRef (IDWriteFontFallback1 *iface)
static ULONG WINAPI	customfontfallback_Release (IDWriteFontFallback1 *iface)
static HRESULT WINAPI	fontfallbackbuilder_QueryInterface (IDWriteFontFallbackBuilder *iface, REFIID riid, void **obj)
static ULONG WINAPI	fontfallbackbuilder_AddRef (IDWriteFontFallbackBuilder *iface)
static ULONG WINAPI	fontfallbackbuilder_Release (IDWriteFontFallbackBuilder *iface)
static struct fallback_locale *	fallback_builder_add_locale (struct dwrite_fontfallback_builder *builder, const WCHAR *locale_name)
static HRESULT WINAPI	fontfallbackbuilder_AddMapping (IDWriteFontFallbackBuilder *iface, const DWRITE_UNICODE_RANGE *ranges, UINT32 ranges_count, WCHAR const **families, UINT32 families_count, IDWriteFontCollection *collection, WCHAR const *locale_name, WCHAR const *base_family, float scale)
static HRESULT WINAPI	fontfallbackbuilder_AddMappings (IDWriteFontFallbackBuilder *iface, IDWriteFontFallback *fallback)
static HRESULT	fallbackbuilder_init_fallback_data (const struct dwrite_fontfallback_builder *builder, struct fallback_data *data)
static HRESULT	fallbackbuilder_create_fallback (struct dwrite_fontfallback_builder *builder, struct dwrite_fontfallback **ret)
static HRESULT WINAPI	fontfallbackbuilder_CreateFontFallback (IDWriteFontFallbackBuilder *iface, IDWriteFontFallback **ret)
static HRESULT	create_fontfallback_builder_internal (IDWriteFactory7 *factory, struct dwrite_fontfallback_builder **ret)
HRESULT	create_fontfallback_builder (IDWriteFactory7 *factory, IDWriteFontFallbackBuilder **ret)
static void	system_fallback_parse_ranges (const char *str, DWRITE_UNICODE_RANGE *ranges, unsigned int max_count, unsigned int *ret)
static void	system_fallback_parse_families (WCHAR *str, WCHAR **families, unsigned int max_count, unsigned int *ret)
static BOOL WINAPI	dwrite_system_fallback_initonce (INIT_ONCE *once, void *param, void **context)
void	release_system_fallback_data (void)
HRESULT	create_system_fontfallback (IDWriteFactory7 *factory, IDWriteFontFallback1 **ret)

Variables
const unsigned short	wine_linebreak_table []
const unsigned short	wine_scripts_table []
const unsigned short	bidi_direction_table []
static const struct dwritescript_properties	dwritescripts_properties [Script_LastId+1]
static const struct fallback_description	system_fallback_config []
static struct fallback_data	system_fallback
static const IDWriteTextAnalyzer2Vtbl	textanalyzervtbl
static IDWriteTextAnalyzer2	textanalyzer = { &textanalyzervtbl }
static const IDWriteNumberSubstitutionVtbl	numbersubstitutionvtbl
static const IDWriteFontFallback1Vtbl	fontfallbackvtbl
static const IDWriteFontFallback1Vtbl	customfontfallbackvtbl
static const IDWriteFontFallbackBuilderVtbl	fontfallbackbuildervtbl
static INIT_ONCE	init_system_fallback_once = INIT_ONCE_STATIC_INIT

Macro Definition Documentation

_OT

#define _OT	(		a,
			b,
			c,
			d
	)		DWRITE_MAKE_OPENTYPE_TAG(a,b,c,d)

Definition at line 45 of file analyzer.c.

COBJMACROS

#define COBJMACROS

Definition at line 22 of file analyzer.c.

NATIVE_DIGITS_LEN

#define NATIVE_DIGITS_LEN   11

Definition at line 36 of file analyzer.c.

Enumeration Type Documentation

BreakConditionLocation

enum BreakConditionLocation

Enumerator
BreakConditionBefore
BreakConditionAfter

Definition at line 751 of file analyzer.c.

                            {
    BreakConditionBefore,
    BreakConditionAfter
};

linebreaking_classes

enum linebreaking_classes

Enumerator
b_BK
b_CR
b_LF
b_CM
b_SG
b_GL
b_CB
b_SP
b_ZW
b_NL
b_WJ
b_JL
b_JV
b_JT
b_H2
b_H3
b_XX
b_OP
b_CL
b_CP
b_QU
b_NS
b_EX
b_SY
b_IS
b_PR
b_PO
b_NU
b_AL
b_ID
b_IN
b_HY
b_BB
b_BA
b_SA
b_AI
b_B2
b_HL
b_CJ
b_RI
b_EB
b_EM
b_ZWJ

Definition at line 756 of file analyzer.c.

                          {
    b_BK = 1,
    b_CR,
    b_LF,
    b_CM,
    b_SG,
    b_GL,
    b_CB,
    b_SP,
    b_ZW,
    b_NL,
    b_WJ,
    b_JL,
    b_JV,
    b_JT,
    b_H2,
    b_H3,
    b_XX,
    b_OP,
    b_CL,
    b_CP,
    b_QU,
    b_NS,
    b_EX,
    b_SY,
    b_IS,
    b_PR,
    b_PO,
    b_NU,
    b_AL,
    b_ID,
    b_IN,
    b_HY,
    b_BB,
    b_BA,
    b_SA,
    b_AI,
    b_B2,
    b_HL,
    b_CJ,
    b_RI,
    b_EB,
    b_EM,
    b_ZWJ,
};

Function Documentation

analyze_linebreaks()

static HRESULT analyze_linebreaks ( IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, DWRITE_LINE_BREAKPOINT *  breakpoints  )

static

Definition at line 857 of file analyzer.c.

{
    struct text_source_context context;
    struct linebreaking_state state;
    struct break_index *breaks;
    unsigned int count, index;
    short *break_class;
    int i = 0, j;
    HRESULT hr;
 
    if (FAILED(hr = text_source_context_init(&context, source, position, length))) return hr;
 
    if (!(breaks = calloc(length, sizeof(*breaks))))
        return E_OUTOFMEMORY;
 
    if (!(break_class = calloc(length, sizeof(*break_class))))
    {
        free(breaks);
        return E_OUTOFMEMORY;
    }
 
    count = index = 0;
    while (!text_source_get_next_u32_char(&context))
    {
        break_class[count] = get_table_entry_32(wine_linebreak_table, context.ch);
        breaks[count].length = text_source_get_char_length(&context);
        breaks[count].index = index;
 
        /* LB1 - resolve some classes. TODO: use external algorithms for these classes. */
        switch (break_class[count])
        {
            case b_AI:
            case b_SA:
            case b_SG:
            case b_XX:
                break_class[count] = b_AL;
                break;
            case b_CJ:
                break_class[count] = b_NS;
                break;
        }
 
        breakpoints[index].breakConditionBefore = DWRITE_BREAK_CONDITION_NEUTRAL;
        breakpoints[index].breakConditionAfter  = DWRITE_BREAK_CONDITION_NEUTRAL;
        breakpoints[index].isWhitespace = context.ch < 0xffff ? !!iswspace(context.ch) : 0;
        breakpoints[index].isSoftHyphen = context.ch == 0x00ad /* Unicode Soft Hyphen */;
        breakpoints[index].padding = 0;
        ++index;
 
        if (breaks[count].length > 1)
        {
            breakpoints[index] = breakpoints[index - 1];
            /* Never break in surrogate pairs. */
            breakpoints[index - 1].breakConditionAfter = DWRITE_BREAK_CONDITION_MAY_NOT_BREAK;
            breakpoints[index].breakConditionBefore = DWRITE_BREAK_CONDITION_MAY_NOT_BREAK;
            ++index;
        }
 
        ++count;
    }
 
    state.breakpoints = breakpoints;
    state.breaks = breaks;
    state.count = count;
 
    /* LB2 - never break at the start */
    set_break_condition(0, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
    /* LB3 - always break at the end. */
    set_break_condition(count - 1, BreakConditionAfter, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
 
    /* LB4 - LB6 - mandatory breaks. */
    for (i = 0; i < count; i++)
    {
        switch (break_class[i])
        {
            /* LB4 - LB6 */
            case b_CR:
                /* LB5 - don't break CR x LF */
                if (i < count-1 && break_class[i+1] == b_LF)
                {
                    set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                    break;
                }
            case b_LF:
            case b_NL:
            case b_BK:
                /* LB4 - LB5 - always break after hard breaks */
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MUST_BREAK, &state);
                /* LB6 - do not break before hard breaks */
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
        }
    }
 
    /* LB7 - LB8 - explicit breaks and non-breaks */
    for (i = 0; i < count; i++)
    {
        switch (break_class[i])
        {
            /* LB7 - do not break before spaces or zero-width space */
            case b_SP:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            case b_ZW:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
                /* LB8 - break before character after zero-width space, skip spaces in-between */
                j = i;
                while (j < count-1 && break_class[j+1] == b_SP)
                    j++;
                if (j < count-1 && break_class[j+1] != b_ZW)
                    set_break_condition(j, BreakConditionAfter, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
                break;
            /* LB8a - do not break after ZWJ */
            case b_ZWJ:
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
        }
    }
 
    /* LB9 - LB10 - combining marks */
    for (i = 0; i < count; i++)
    {
        if (break_class[i] == b_CM || break_class[i] == b_ZWJ)
        {
            if (i > 0)
            {
                switch (break_class[i-1])
                {
                    case b_SP:
                    case b_BK:
                    case b_CR:
                    case b_LF:
                    case b_NL:
                    case b_ZW:
                        break_class[i] = b_AL;
                        break;
                    default:
                    {
                        break_class[i] = break_class[i-1];
                        set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                    }
                }
            }
            else break_class[i] = b_AL;
        }
    }
 
    for (i = 0; i < count; i++)
    {
        switch (break_class[i])
        {
            /* LB11 - don't break before and after word joiner */
            case b_WJ:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB12 - don't break after glue */
            case b_GL:
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
            /* LB12a */
                if (i > 0)
                {
                    if (break_class[i-1] != b_SP && break_class[i-1] != b_BA && break_class[i-1] != b_HY)
                        set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                }
                break;
            /* LB13 */
            case b_CL:
            case b_CP:
            case b_EX:
            case b_IS:
            case b_SY:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB14 - do not break after OP, even after spaces */
            case b_OP:
                j = i;
                while (j < count-1 && break_class[j+1] == b_SP)
                    j++;
                set_break_condition(j, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB15 - do not break within QU-OP, even with intervening spaces */
            case b_QU:
                j = i;
                while (j < count-1 && break_class[j+1] == b_SP)
                    j++;
                if (j < count - 1 && break_class[j+1] == b_OP)
                    set_break_condition(j, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB16 */
            case b_NS:
                j = i-1;
                while(j > 0 && break_class[j] == b_SP)
                    j--;
                if (break_class[j] == b_CL || break_class[j] == b_CP)
                    for (j++; j <= i; j++)
                        set_break_condition(j, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB17 - do not break within B2, even with intervening spaces */
            case b_B2:
                j = i;
                while (j < count && break_class[j+1] == b_SP)
                    j++;
                if (j < count - 1 && break_class[j+1] == b_B2)
                    set_break_condition(j, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
        }
    }
 
    for (i = 0; i < count; i++)
    {
        switch(break_class[i])
        {
            /* LB18 - break is allowed after space */
            case b_SP:
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
                break;
            /* LB19 - don't break before or after quotation mark */
            case b_QU:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB20 */
            case b_CB:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
                if (i < count - 1 && break_class[i+1] != b_QU)
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
                break;
            /* LB21 */
            case b_BA:
            case b_HY:
            case b_NS:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            case b_BB:
                if (i < count - 1 && break_class[i+1] != b_CB)
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB21a, LB21b */
            case b_HL:
                /* LB21a */
                if (i < count-1)
                    switch (break_class[i+1])
                    {
                    case b_HY:
                    case b_BA:
                        set_break_condition(i+1, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                    }
                /* LB21b */
                if (i > 0 && break_class[i-1] == b_SY)
                    set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
            /* LB22 */
            case b_IN:
                set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                break;
        }
 
        if (i < count-1)
        {
            /* LB23 - do not break between digits and letters */
            if ((break_class[i] == b_AL && break_class[i+1] == b_NU) ||
                (break_class[i] == b_HL && break_class[i+1] == b_NU) ||
                (break_class[i] == b_NU && break_class[i+1] == b_AL) ||
                (break_class[i] == b_NU && break_class[i+1] == b_HL))
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB23a - do not break between numeric prefixes and ideographs, or between ideographs and numeric postfixes */
            if ((break_class[i] == b_PR && break_class[i+1] == b_ID) ||
                (break_class[i] == b_PR && break_class[i+1] == b_EB) ||
                (break_class[i] == b_PR && break_class[i+1] == b_EM) ||
                (break_class[i] == b_ID && break_class[i+1] == b_PO) ||
                (break_class[i] == b_EM && break_class[i+1] == b_PO) ||
                (break_class[i] == b_EB && break_class[i+1] == b_PO))
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB24 - do not break between numeric prefix/postfix and letters, or letters and prefix/postfix */
            if ((break_class[i] == b_PR && break_class[i+1] == b_AL) ||
                (break_class[i] == b_PR && break_class[i+1] == b_HL) ||
                (break_class[i] == b_PO && break_class[i+1] == b_AL) ||
                (break_class[i] == b_PO && break_class[i+1] == b_HL) ||
                (break_class[i] == b_AL && break_class[i+1] == b_PR) ||
                (break_class[i] == b_HL && break_class[i+1] == b_PR) ||
                (break_class[i] == b_AL && break_class[i+1] == b_PO) ||
                (break_class[i] == b_HL && break_class[i+1] == b_PO))
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB25 */
            if ((break_class[i] == b_CL && break_class[i+1] == b_PO) ||
                (break_class[i] == b_CP && break_class[i+1] == b_PO) ||
                (break_class[i] == b_CL && break_class[i+1] == b_PR) ||
                (break_class[i] == b_CP && break_class[i+1] == b_PR) ||
                (break_class[i] == b_NU && break_class[i+1] == b_PO) ||
                (break_class[i] == b_NU && break_class[i+1] == b_PR) ||
                (break_class[i] == b_PO && break_class[i+1] == b_OP) ||
                (break_class[i] == b_PO && break_class[i+1] == b_NU) ||
                (break_class[i] == b_PR && break_class[i+1] == b_OP) ||
                (break_class[i] == b_PR && break_class[i+1] == b_NU) ||
                (break_class[i] == b_HY && break_class[i+1] == b_NU) ||
                (break_class[i] == b_IS && break_class[i+1] == b_NU) ||
                (break_class[i] == b_NU && break_class[i+1] == b_NU) ||
                (break_class[i] == b_SY && break_class[i+1] == b_NU))
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB26 */
            if (break_class[i] == b_JL)
            {
                switch (break_class[i+1])
                {
                    case b_JL:
                    case b_JV:
                    case b_H2:
                    case b_H3:
                        set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                }
            }
            if ((break_class[i] == b_JV || break_class[i] == b_H2) &&
                (break_class[i+1] == b_JV || break_class[i+1] == b_JT))
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
            if ((break_class[i] == b_JT || break_class[i] == b_H3) &&
                 break_class[i+1] == b_JT)
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB27 */
            switch (break_class[i])
            {
                case b_JL:
                case b_JV:
                case b_JT:
                case b_H2:
                case b_H3:
                    if (break_class[i+1] == b_IN || break_class[i+1] == b_PO)
                        set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
            }
            if (break_class[i] == b_PR)
            {
                switch (break_class[i+1])
                {
                    case b_JL:
                    case b_JV:
                    case b_JT:
                    case b_H2:
                    case b_H3:
                        set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
                }
            }
 
            /* LB28 */
            if ((break_class[i] == b_AL && break_class[i+1] == b_AL) ||
                (break_class[i] == b_AL && break_class[i+1] == b_HL) ||
                (break_class[i] == b_HL && break_class[i+1] == b_AL) ||
                (break_class[i] == b_HL && break_class[i+1] == b_HL))
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB29 */
            if ((break_class[i] == b_IS && break_class[i+1] == b_AL) ||
                (break_class[i] == b_IS && break_class[i+1] == b_HL))
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB30 */
            if ((break_class[i] == b_AL || break_class[i] == b_HL || break_class[i] == b_NU) &&
                 break_class[i+1] == b_OP)
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
            if (break_class[i] == b_CP &&
               (break_class[i+1] == b_AL || break_class[i+1] == b_HL || break_class[i+1] == b_NU))
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
 
            /* LB30a - break between two RIs if and only if there are an even number of RIs preceding position of the break */
            if (break_class[i] == b_RI && break_class[i+1] == b_RI) {
                unsigned int c = 0;
 
                j = i + 1;
                while (j > 0 && break_class[--j] == b_RI)
                    c++;
 
                if ((c & 1) == 0)
                    set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
            }
 
            /* LB30b - do not break between an emoji base and an emoji modifier */
            if (break_class[i] == b_EB && break_class[i+1] == b_EM)
                set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_MAY_NOT_BREAK, &state);
        }
    }
 
    /* LB31 - allow breaks everywhere else. */
    for (i = 0; i < count; i++)
    {
        set_break_condition(i, BreakConditionBefore, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
        set_break_condition(i, BreakConditionAfter, DWRITE_BREAK_CONDITION_CAN_BREAK, &state);
    }
 
    free(break_class);
    free(breaks);
 
    return S_OK;
}

Referenced by dwritetextanalyzer_AnalyzeLineBreakpoints().

analyze_script()

static HRESULT analyze_script ( struct text_source_context *  context, IDWriteTextAnalysisSink *  sink  )

static

Definition at line 688 of file analyzer.c.

{
    DWRITE_SCRIPT_ANALYSIS sa;
    UINT32 pos, length;
    HRESULT hr;
 
    text_source_get_next_u32_char(context);
 
    sa = get_char_sa(context->ch);
 
    pos = context->position;
    length = text_source_get_char_length(context);
 
    while (!text_source_get_next_u32_char(context))
    {
        DWRITE_SCRIPT_ANALYSIS cur_sa = get_char_sa(context->ch);
 
        /* Unknown type is ignored when preceded or followed by another script */
        switch (sa.script) {
        case Script_Unknown:
            sa.script = cur_sa.script;
            break;
        case Script_Common:
            if (cur_sa.script == Script_Unknown)
                cur_sa.script = sa.script;
            else if ((cur_sa.script != Script_Common) && sa.shapes == DWRITE_SCRIPT_SHAPES_DEFAULT)
                sa.script = cur_sa.script;
            break;
        default:
            if ((cur_sa.script == Script_Common && cur_sa.shapes == DWRITE_SCRIPT_SHAPES_DEFAULT) || cur_sa.script == Script_Unknown)
                cur_sa.script = sa.script;
        }
 
        /* this is a length of a sequence to be reported next */
        if (sa.script == cur_sa.script && sa.shapes == cur_sa.shapes)
            length += text_source_get_char_length(context);
        else
        {
            hr = IDWriteTextAnalysisSink_SetScriptAnalysis(sink, pos, length, &sa);
            if (FAILED(hr)) return hr;
            pos += length;
            length = text_source_get_char_length(context);
            sa = cur_sa;
        }
    }
 
    /* one char length case or normal completion call */
    return IDWriteTextAnalysisSink_SetScriptAnalysis(sink, pos, length, &sa);
}

Referenced by dwritetextanalyzer_AnalyzeScript().

analyzer_dump_user_features()

static void analyzer_dump_user_features ( DWRITE_TYPOGRAPHIC_FEATURES const **  features, UINT32 const *  feature_range_lengths, UINT32  feature_ranges  )

static

Definition at line 1500 of file analyzer.c.

{
    UINT32 i, j, start;
 
    if (!TRACE_ON(dwrite) || !features)
        return;
 
    for (i = 0, start = 0; i < feature_ranges; start += feature_range_lengths[i++]) {
        TRACE("feature range [%u,%u)\n", start, start + feature_range_lengths[i]);
        for (j = 0; j < features[i]->featureCount; j++)
            TRACE("feature %s, parameter %u\n", debugstr_fourcc(features[i]->features[j].nameTag),
                    features[i]->features[j].parameter);
    }
}

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

apply_cluster_spacing()

static HRESULT apply_cluster_spacing ( float  leading_spacing, float  trailing_spacing, float  min_advance_width, unsigned int  start, unsigned int  end, float const *  advances, DWRITE_GLYPH_OFFSET const *  offsets, DWRITE_SHAPING_GLYPH_PROPERTIES const *  glyph_props, float *  modified_advances, DWRITE_GLYPH_OFFSET *  modified_offsets  )

static

Definition at line 1737 of file analyzer.c.

{
    BOOL reduced = leading_spacing < 0.0f || trailing_spacing < 0.0f;
    unsigned int first_spacing, last_spacing, i;
    float advance, origin = 0.0f, *deltas;
    BOOL is_spacing_cluster = FALSE;
 
    if (modified_advances != advances)
        memcpy(&modified_advances[start], &advances[start], (end - start + 1) * sizeof(*advances));
    if (modified_offsets != offsets)
        memcpy(&modified_offsets[start], &offsets[start], (end - start + 1) * sizeof(*offsets));
 
    for (first_spacing = start; first_spacing <= end; ++first_spacing)
    {
        if ((is_spacing_cluster = !glyph_props[first_spacing].isZeroWidthSpace))
            break;
    }
 
    /* Nothing to adjust if there is no spacing glyphs. */
    if (!is_spacing_cluster)
        return S_OK;
 
    for (last_spacing = end; last_spacing >= start; --last_spacing)
    {
        if (!glyph_props[last_spacing].isZeroWidthSpace)
            break;
    }
 
    if (!(deltas = calloc(end - start + 1, sizeof(*deltas))))
        return E_OUTOFMEMORY;
 
    /* Cluster advance, note that properties are ignored. */
    origin = offsets[start].advanceOffset;
    for (i = start, advance = 0.0f; i <= end; ++i)
    {
        float cur = advance + offsets[i].advanceOffset;
 
        deltas[i - start] = cur - origin;
 
        advance += advances[i];
        origin = cur;
    }
 
    /* Negative spacing. */
    if (leading_spacing < 0.0f)
    {
        advance += leading_spacing;
        modified_advances[first_spacing] += leading_spacing;
        modified_offsets[first_spacing].advanceOffset += leading_spacing;
    }
 
    if (trailing_spacing < 0.0f)
    {
        advance += trailing_spacing;
        modified_advances[last_spacing] += trailing_spacing;
    }
 
    /* Minimal advance. */
    advance = min_advance_width - advance;
    if (advance > 0.0f) {
        /* Additional spacing is only applied to leading and trailing spacing glyphs. */
        float half = advance / 2.0f;
 
        if (!reduced)
        {
            modified_advances[first_spacing] += half;
            modified_advances[last_spacing] += half;
            modified_offsets[first_spacing].advanceOffset += half;
        }
        else if (leading_spacing < 0.0f && trailing_spacing < 0.0f)
        {
            modified_advances[first_spacing] += half;
            modified_advances[last_spacing] += half;
            modified_offsets[first_spacing].advanceOffset += half;
        }
        else if (leading_spacing < 0.0f)
        {
            modified_advances[first_spacing] += advance;
            modified_offsets[first_spacing].advanceOffset += advance;
        }
        else
            modified_advances[last_spacing] += advance;
    }
 
    /* Positive spacing. */
    if (leading_spacing > 0.0f)
    {
        modified_advances[first_spacing] += leading_spacing;
        modified_offsets[first_spacing].advanceOffset += leading_spacing;
    }
 
    if (trailing_spacing > 0.0f)
        modified_advances[last_spacing] += trailing_spacing;
 
    /* Update offsets to preserve original relative positions within cluster. */
    for (i = first_spacing; i > start; --i)
    {
        unsigned int cur = i - 1;
        modified_offsets[cur].advanceOffset = modified_advances[cur] + modified_offsets[i].advanceOffset -
                deltas[i - start];
    }
 
    for (i = first_spacing + 1; i <= end; ++i)
    {
        modified_offsets[i].advanceOffset = deltas[i - start] + modified_offsets[i - 1].advanceOffset -
                modified_advances[i - 1];
    }
 
    free(deltas);
 
    return S_OK;
}

Referenced by dwritetextanalyzer1_ApplyCharacterSpacing().

create_fontfallback_builder()

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

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_fontfallback_builder_internal()

static HRESULT create_fontfallback_builder_internal ( IDWriteFactory7 *  factory, struct dwrite_fontfallback_builder **  ret  )

static

Definition at line 2909 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *builder;
 
    *ret = NULL;
 
    if (!(builder = calloc(1, sizeof(*builder))))
        return E_OUTOFMEMORY;
 
    builder->IDWriteFontFallbackBuilder_iface.lpVtbl = &fontfallbackbuildervtbl;
    builder->refcount = 1;
    builder->factory = factory;
    IDWriteFactory7_AddRef(builder->factory);
    list_init(&builder->data.locales);
 
    *ret = builder;
 
    return S_OK;
}

Referenced by create_fontfallback_builder(), and dwrite_system_fallback_initonce().

create_matching_font()

HRESULT create_matching_font	(	IDWriteFontCollection *	collection,
		const WCHAR *	name,
		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_system_fontfallback()

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

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().

customfontfallback_AddRef()

static ULONG WINAPI customfontfallback_AddRef ( IDWriteFontFallback1 *  iface )

static

Definition at line 2582 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback = impl_from_IDWriteFontFallback1(iface);
    ULONG refcount = InterlockedIncrement(&fallback->refcount);
 
    TRACE("%p, refcount %lu.\n", iface, refcount);
 
    return refcount;
}

customfontfallback_Release()

static ULONG WINAPI customfontfallback_Release ( IDWriteFontFallback1 *  iface )

static

Definition at line 2592 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback = impl_from_IDWriteFontFallback1(iface);
    ULONG refcount = InterlockedDecrement(&fallback->refcount);
 
    TRACE("%p, refcount %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        IDWriteFactory7_Release(fallback->factory);
        if (fallback->systemcollection)
            IDWriteFontCollection_Release(fallback->systemcollection);
        release_fallback_data(&fallback->data);
        free(fallback);
    }
 
    return refcount;
}

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_system_fallback_initonce()

static BOOL WINAPI dwrite_system_fallback_initonce ( INIT_ONCE *  once, void *  param, void **  context  )

static

Definition at line 2985 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *builder;
    IDWriteFontFallbackBuilder *builder_iface;
    unsigned int range_count, families_count;
    IDWriteFactory7 *factory = param;
    DWRITE_UNICODE_RANGE ranges[16];
    WCHAR *families[4], *str;
    HRESULT hr;
    size_t i;
 
    if (FAILED(create_fontfallback_builder_internal(factory, &builder))) return FALSE;
    builder_iface = &builder->IDWriteFontFallbackBuilder_iface;
 
    for (i = 0; i < ARRAY_SIZE(system_fallback_config); ++i)
    {
        const struct fallback_description *entry = &system_fallback_config[i];
 
        system_fallback_parse_ranges(entry->ranges, ranges, ARRAY_SIZE(ranges), &range_count);
 
        /* TODO: reuse the buffer */
        str = wcsdup(entry->families);
        system_fallback_parse_families(str, families, ARRAY_SIZE(families), &families_count);
 
        if (FAILED(hr = IDWriteFontFallbackBuilder_AddMapping(builder_iface, ranges, range_count,
                (const WCHAR **)families, families_count, NULL, entry->locale, NULL, 1.0f)))
        {
            WARN("Failed to add mapping, hr %#lx.\n", hr);
        }
 
        free(str);
    }
 
    hr = fallbackbuilder_init_fallback_data(builder, &system_fallback);
    IDWriteFontFallbackBuilder_Release(builder_iface);
 
    return hr == S_OK;
}

Referenced by create_system_fontfallback().

dwritenumbersubstitution_AddRef()

static ULONG WINAPI dwritenumbersubstitution_AddRef ( IDWriteNumberSubstitution *  iface )

static

Definition at line 2265 of file analyzer.c.

{
    struct dwrite_numbersubstitution *object = impl_from_IDWriteNumberSubstitution(iface);
    ULONG refcount = InterlockedIncrement(&object->refcount);
 
    TRACE("%p, refcount %ld.\n", iface, refcount);
 
    return refcount;
}

dwritenumbersubstitution_QueryInterface()

static HRESULT WINAPI dwritenumbersubstitution_QueryInterface ( IDWriteNumberSubstitution *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2246 of file analyzer.c.

{
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IDWriteNumberSubstitution) ||
        IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IDWriteNumberSubstitution_AddRef(iface);
        return S_OK;
    }
 
    WARN("%s not implemented.\n", debugstr_guid(riid));
 
    *obj = NULL;
 
    return E_NOINTERFACE;
}

dwritenumbersubstitution_Release()

static ULONG WINAPI dwritenumbersubstitution_Release ( IDWriteNumberSubstitution *  iface )

static

Definition at line 2275 of file analyzer.c.

{
    struct dwrite_numbersubstitution *object = impl_from_IDWriteNumberSubstitution(iface);
    ULONG refcount = InterlockedDecrement(&object->refcount);
 
    TRACE("%p, refcount %ld.\n", iface, refcount);
 
    if (!refcount)
    {
        free(object->locale);
        free(object);
    }
 
    return refcount;
}

dwritetextanalyzer1_AnalyzeVerticalGlyphOrientation()

static HRESULT WINAPI dwritetextanalyzer1_AnalyzeVerticalGlyphOrientation ( IDWriteTextAnalyzer2 *  iface, IDWriteTextAnalysisSource1 *  source, UINT32  text_pos, UINT32  len, IDWriteTextAnalysisSink1 *  sink  )

static

Definition at line 1991 of file analyzer.c.

{
    FIXME("(%p %u %u %p): stub\n", source, text_pos, len, sink);
    return E_NOTIMPL;
}

dwritetextanalyzer1_ApplyCharacterSpacing()

static HRESULT WINAPI dwritetextanalyzer1_ApplyCharacterSpacing ( IDWriteTextAnalyzer2 *  iface, FLOAT  leading_spacing, FLOAT  trailing_spacing, FLOAT  min_advance_width, UINT32  len, UINT32  glyph_count, UINT16 const *  clustermap, FLOAT const *  advances, DWRITE_GLYPH_OFFSET const *  offsets, DWRITE_SHAPING_GLYPH_PROPERTIES const *  props, FLOAT *  modified_advances, DWRITE_GLYPH_OFFSET *  modified_offsets  )

static

Definition at line 1899 of file analyzer.c.

{
    unsigned int i;
 
    TRACE("%.2f, %.2f, %.2f, %u, %u, %p, %p, %p, %p, %p, %p.\n", leading_spacing, trailing_spacing, min_advance_width,
        len, glyph_count, clustermap, advances, offsets, props, modified_advances, modified_offsets);
 
    if (min_advance_width < 0.0f) {
        if (modified_advances != advances)
            memset(modified_advances, 0, glyph_count*sizeof(*modified_advances));
        return E_INVALIDARG;
    }
 
    for (i = 0; i < len;)
    {
        unsigned int length = get_cluster_length(clustermap, i, len);
        unsigned int start, end;
 
        start = clustermap[i];
        end = i + length < len ? clustermap[i + length] : glyph_count;
 
        apply_cluster_spacing(leading_spacing, trailing_spacing, min_advance_width, start, end - 1, advances,
                offsets, props, modified_advances, modified_offsets);
 
        i += length;
    }
 
    return S_OK;
}

dwritetextanalyzer1_GetBaseline()

static HRESULT WINAPI dwritetextanalyzer1_GetBaseline ( IDWriteTextAnalyzer2 *  iface, IDWriteFontFace *  fontface, DWRITE_BASELINE  baseline, BOOL  vertical, BOOL  is_simulation_allowed, DWRITE_SCRIPT_ANALYSIS  sa, const WCHAR *  localeName, INT32 *  baseline_coord, BOOL *  exists  )

static

Definition at line 1932 of file analyzer.c.

{
    struct dwrite_fontface *font_obj;
    const DWRITE_FONT_METRICS1 *metrics;
 
    TRACE("%p, %d, %d, %u, %s, %p, %p.\n", fontface, vertical, is_simulation_allowed, sa.script, debugstr_w(localeName),
            baseline_coord, exists);
 
    *exists = FALSE;
    *baseline_coord = 0;
 
    if (baseline == DWRITE_BASELINE_DEFAULT)
        baseline = vertical ? DWRITE_BASELINE_CENTRAL : DWRITE_BASELINE_ROMAN;
 
    if ((unsigned int)baseline > DWRITE_BASELINE_MAXIMUM)
        return E_INVALIDARG;
 
    /* TODO: fetch BASE table data if available. */
 
    if (!*exists && is_simulation_allowed)
    {
        font_obj = unsafe_impl_from_IDWriteFontFace(fontface);
        metrics = &font_obj->metrics;
 
        switch (baseline)
        {
            case DWRITE_BASELINE_ROMAN:
                *baseline_coord = vertical ? metrics->descent : 0;
                break;
            case DWRITE_BASELINE_CENTRAL:
                *baseline_coord = vertical ? (metrics->ascent + metrics->descent) / 2 :
                        -(metrics->ascent - metrics->descent) / 2;
                break;
            case DWRITE_BASELINE_MATH:
                *baseline_coord = vertical ? (metrics->ascent + metrics->descent) / 2 :
                        -(metrics->ascent + metrics->descent) / 2;
                break;
            case DWRITE_BASELINE_HANGING:
                /* FIXME: this one isn't accurate, but close. */
                *baseline_coord = vertical ? metrics->capHeight * 6 / 7 + metrics->descent : metrics->capHeight * 6 / 7;
                break;
            case DWRITE_BASELINE_IDEOGRAPHIC_BOTTOM:
            case DWRITE_BASELINE_MINIMUM:
                *baseline_coord = vertical ? 0 : metrics->descent;
                break;
            case DWRITE_BASELINE_IDEOGRAPHIC_TOP:
            case DWRITE_BASELINE_MAXIMUM:
                *baseline_coord = vertical ? metrics->ascent + metrics->descent : -metrics->ascent;
                break;
            default:
                ;
        }
    }
 
    return S_OK;
}

dwritetextanalyzer1_GetGlyphOrientationTransform()

static HRESULT WINAPI dwritetextanalyzer1_GetGlyphOrientationTransform ( IDWriteTextAnalyzer2 *  iface, DWRITE_GLYPH_ORIENTATION_ANGLE  angle, BOOL  is_sideways, DWRITE_MATRIX *  transform  )

static

Definition at line 1998 of file analyzer.c.

{
    TRACE("%d, %d, %p.\n", angle, is_sideways, transform);
 
    return IDWriteTextAnalyzer2_GetGlyphOrientationTransform(iface, angle, is_sideways, 0.0, 0.0, transform);
}

dwritetextanalyzer1_GetJustificationOpportunities()

static HRESULT WINAPI dwritetextanalyzer1_GetJustificationOpportunities ( IDWriteTextAnalyzer2 *  iface, IDWriteFontFace *  face, FLOAT  font_em_size, DWRITE_SCRIPT_ANALYSIS  sa, UINT32  length, UINT32  glyph_count, const WCHAR *  text, const UINT16 *  clustermap, const DWRITE_SHAPING_GLYPH_PROPERTIES *  prop, DWRITE_JUSTIFICATION_OPPORTUNITY *  jo  )

static

Definition at line 2079 of file analyzer.c.

{
    FIXME("(%p %.2f %u %u %u %s %p %p %p): stub\n", face, font_em_size, sa.script, length, glyph_count,
        debugstr_wn(text, length), clustermap, prop, jo);
    return E_NOTIMPL;
}

dwritetextanalyzer1_GetJustifiedGlyphs()

static HRESULT WINAPI dwritetextanalyzer1_GetJustifiedGlyphs ( IDWriteTextAnalyzer2 *  iface, IDWriteFontFace *  face, FLOAT  font_em_size, DWRITE_SCRIPT_ANALYSIS  sa, UINT32  length, UINT32  glyph_count, UINT32  max_glyphcount, const UINT16 *  clustermap, const UINT16 *  indices, const FLOAT *  advances, const FLOAT *  justifiedadvances, const DWRITE_GLYPH_OFFSET *  justifiedoffsets, const DWRITE_SHAPING_GLYPH_PROPERTIES *  prop, UINT32 *  actual_count, UINT16 *  modified_clustermap, UINT16 *  modified_indices, FLOAT *  modified_advances, DWRITE_GLYPH_OFFSET *  modified_offsets  )

static

Definition at line 2097 of file analyzer.c.

{
    FIXME("(%p %.2f %u %u %u %u %p %p %p %p %p %p %p %p %p %p %p): stub\n", face, font_em_size, sa.script,
        length, glyph_count, max_glyphcount, clustermap, indices, advances, justifiedadvances, justifiedoffsets,
        prop, actual_count, modified_clustermap, modified_indices, modified_advances, modified_offsets);
    return E_NOTIMPL;
}

dwritetextanalyzer1_GetScriptProperties()

static HRESULT WINAPI dwritetextanalyzer1_GetScriptProperties ( IDWriteTextAnalyzer2 *  iface, DWRITE_SCRIPT_ANALYSIS  sa, DWRITE_SCRIPT_PROPERTIES *  props  )

static

Definition at line 2006 of file analyzer.c.

{
    TRACE("%u, %p.\n", sa.script, props);
 
    if (sa.script > Script_LastId)
        return E_INVALIDARG;
 
    *props = dwritescripts_properties[sa.script].props;
    return S_OK;
}

dwritetextanalyzer1_GetTextComplexity()

static HRESULT WINAPI dwritetextanalyzer1_GetTextComplexity ( IDWriteTextAnalyzer2 *  iface, const WCHAR *  text, UINT32  len, IDWriteFontFace *  face, BOOL *  is_simple, UINT32 *  len_read, UINT16 *  indices  )

static

Definition at line 2030 of file analyzer.c.

{
    HRESULT hr = S_OK;
    int i;
 
    TRACE("%s:%u, %p, %p, %p, %p.\n", debugstr_wn(text, len), len, face, is_simple, len_read, indices);
 
    *is_simple = FALSE;
    *len_read = 0;
 
    if (!face)
        return E_INVALIDARG;
 
    if (len == 0) {
        *is_simple = TRUE;
        return S_OK;
    }
 
    *is_simple = text[0] && is_char_from_simple_script(text[0]);
    for (i = 1; i < len && text[i]; i++) {
        if (is_char_from_simple_script(text[i])) {
            if (!*is_simple)
                break;
        }
        else
            *is_simple = FALSE;
    }
 
    *len_read = i;
 
    /* fetch indices */
    if (*is_simple && indices)
    {
        UINT32 *codepoints;
 
        if (!(codepoints = calloc(*len_read, sizeof(*codepoints))))
            return E_OUTOFMEMORY;
 
        for (i = 0; i < *len_read; i++)
            codepoints[i] = text[i];
 
        hr = IDWriteFontFace_GetGlyphIndices(face, codepoints, *len_read, indices);
        free(codepoints);
    }
 
    return hr;
}

dwritetextanalyzer1_JustifyGlyphAdvances()

static HRESULT WINAPI dwritetextanalyzer1_JustifyGlyphAdvances ( IDWriteTextAnalyzer2 *  iface, FLOAT  width, UINT32  glyph_count, const DWRITE_JUSTIFICATION_OPPORTUNITY *  jo, const FLOAT *  advances, const DWRITE_GLYPH_OFFSET *  offsets, FLOAT *  justifiedadvances, DWRITE_GLYPH_OFFSET *  justifiedoffsets  )

static

Definition at line 2088 of file analyzer.c.

{
    FIXME("(%.2f %u %p %p %p %p %p): stub\n", width, glyph_count, jo, advances, offsets, justifiedadvances,
        justifiedoffsets);
    return E_NOTIMPL;
}

dwritetextanalyzer2_CheckTypographicFeature()

static HRESULT WINAPI dwritetextanalyzer2_CheckTypographicFeature ( IDWriteTextAnalyzer2 *  iface, IDWriteFontFace *  fontface, DWRITE_SCRIPT_ANALYSIS  sa, const WCHAR *  locale, DWRITE_FONT_FEATURE_TAG  feature, UINT32  glyph_count, const UINT16 *  glyphs, UINT8 *  feature_applies  )

static

Definition at line 2182 of file analyzer.c.

{
    struct scriptshaping_context context = { 0 };
    const struct dwritescript_properties *props;
    struct dwrite_fontface *font_obj;
    HRESULT hr;
 
    TRACE("%p, %p, %u, %s, %s, %u, %p, %p.\n", iface, fontface, sa.script, debugstr_w(locale), debugstr_fourcc(feature),
            glyph_count, glyphs, feature_applies);
 
    if (sa.script > Script_LastId)
        return E_INVALIDARG;
 
    font_obj = unsafe_impl_from_IDWriteFontFace(fontface);
 
    context.cache = fontface_get_shaping_cache(font_obj);
    context.language_tag = get_opentype_language(locale);
    if (!(context.glyph_infos = calloc(glyph_count, sizeof(*context.glyph_infos))))
        return E_OUTOFMEMORY;
 
    props = &dwritescripts_properties[sa.script];
 
    hr = shape_check_typographic_feature(&context, props->scripttags, feature, glyph_count, glyphs, feature_applies);
 
    free(context.glyph_infos);
 
    return hr;
}

dwritetextanalyzer2_GetGlyphOrientationTransform()

static HRESULT WINAPI dwritetextanalyzer2_GetGlyphOrientationTransform ( IDWriteTextAnalyzer2 *  iface, DWRITE_GLYPH_ORIENTATION_ANGLE  angle, BOOL  is_sideways, FLOAT  originX, FLOAT  originY, DWRITE_MATRIX *  m  )

static

Definition at line 2110 of file analyzer.c.

{
    static const DWRITE_MATRIX transforms[] = {
        {  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f },
        {  0.0f,  1.0f, -1.0f,  0.0f, 0.0f, 0.0f },
        { -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f },
        {  0.0f, -1.0f,  1.0f,  0.0f, 0.0f, 0.0f }
    };
 
    TRACE("%d, %d, %.2f, %.2f, %p.\n", angle, is_sideways, originX, originY, m);
 
    if ((UINT32)angle > DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES) {
        memset(m, 0, sizeof(*m));
        return E_INVALIDARG;
    }
 
    /* for sideways case simply rotate 90 degrees more */
    if (is_sideways) {
        switch (angle) {
        case DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES:
            angle = DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES;
            break;
        case DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES:
            angle = DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES;
            break;
        case DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES:
            angle = DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES;
            break;
        case DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES:
            angle = DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES;
            break;
        default:
            ;
        }
    }
 
    *m = transforms[angle];
 
    /* shift components represent transform necessary to get from original point to
       rotated one in new coordinate system */
    if ((originX != 0.0f || originY != 0.0f) && angle != DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES) {
        m->dx = originX - (m->m11 * originX + m->m21 * originY);
        m->dy = originY - (m->m12 * originX + m->m22 * originY);
    }
 
    return S_OK;
}

dwritetextanalyzer2_GetTypographicFeatures()

static HRESULT WINAPI dwritetextanalyzer2_GetTypographicFeatures ( IDWriteTextAnalyzer2 *  iface, IDWriteFontFace *  fontface, DWRITE_SCRIPT_ANALYSIS  sa, const WCHAR *  locale, UINT32  max_tagcount, UINT32 *  actual_tagcount, DWRITE_FONT_FEATURE_TAG *  tags  )

static

Definition at line 2159 of file analyzer.c.

{
    struct scriptshaping_context context = { 0 };
    const struct dwritescript_properties *props;
    struct dwrite_fontface *font_obj;
 
    TRACE("%p, %p, %u, %s, %u, %p, %p.\n", iface, fontface, sa.script, debugstr_w(locale), max_tagcount,
            actual_tagcount, tags);
 
    if (sa.script > Script_LastId)
        return E_INVALIDARG;
 
    font_obj = unsafe_impl_from_IDWriteFontFace(fontface);
 
    context.cache = fontface_get_shaping_cache(font_obj);
    context.language_tag = get_opentype_language(locale);
    props = &dwritescripts_properties[sa.script];
 
    return shape_get_typographic_features(&context, props->scripttags, max_tagcount, actual_tagcount, tags);
};

dwritetextanalyzer_AddRef()

static ULONG WINAPI dwritetextanalyzer_AddRef ( IDWriteTextAnalyzer2 *  iface )

static

Definition at line 1277 of file analyzer.c.

{
    return 2;
}

dwritetextanalyzer_AnalyzeBidi()

static HRESULT WINAPI dwritetextanalyzer_AnalyzeBidi ( IDWriteTextAnalyzer2 *  iface, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, IDWriteTextAnalysisSink *  sink  )

static

Definition at line 1313 of file analyzer.c.

{
    struct text_source_context context;
    UINT8 baselevel, resolved, explicit;
    unsigned int i, chars_count = 0;
    struct bidi_char *chars, *ptr;
    UINT32 pos, seq_length;
    HRESULT hr;
 
    TRACE("%p, %u, %u, %p.\n", source, position, length, sink);
 
    if (!length)
        return S_OK;
 
    if (!(chars = calloc(length, sizeof(*chars))))
        return E_OUTOFMEMORY;
 
    ptr = chars;
    text_source_context_init(&context, source, position, length);
    while (!text_source_get_next_u32_char(&context))
    {
        ptr->ch = context.ch;
        ptr->nominal_bidi_class = ptr->bidi_class = get_char_bidi_class(context.ch);
        ptr++;
 
        ++chars_count;
    }
 
    /* Resolve levels using utf-32 codepoints, size differences are accounted for
       when levels are reported with SetBidiLevel(). */
 
    baselevel = IDWriteTextAnalysisSource_GetParagraphReadingDirection(source);
    hr = bidi_computelevels(chars, chars_count, baselevel);
    if (FAILED(hr))
        goto done;
 
    pos = position;
    resolved = chars->resolved;
    explicit = chars->explicit;
    seq_length = get_bidi_char_length(chars);
 
    for (i = 1, ptr = chars + 1; i < chars_count; ++i, ++ptr)
    {
        if (ptr->resolved == resolved && ptr->explicit == explicit)
        {
            seq_length += get_bidi_char_length(ptr);
        }
        else
        {
            hr = IDWriteTextAnalysisSink_SetBidiLevel(sink, pos, seq_length, explicit, resolved);
            if (FAILED(hr))
                goto done;
 
            pos += seq_length;
            seq_length = get_bidi_char_length(ptr);
            resolved = ptr->resolved;
            explicit = ptr->explicit;
        }
    }
 
    /* one char length case or normal completion call */
    hr = IDWriteTextAnalysisSink_SetBidiLevel(sink, pos, seq_length, explicit, resolved);
 
done:
    free(chars);
 
    return hr;
}

dwritetextanalyzer_AnalyzeLineBreakpoints()

static HRESULT WINAPI dwritetextanalyzer_AnalyzeLineBreakpoints ( IDWriteTextAnalyzer2 *  iface, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, IDWriteTextAnalysisSink *  sink  )

static

Definition at line 1393 of file analyzer.c.

{
    DWRITE_LINE_BREAKPOINT *breakpoints;
    HRESULT hr;
 
    TRACE("%p, %u, %u, %p.\n", source, position, length, sink);
 
    if (!length)
        return S_OK;
 
    if (!(breakpoints = calloc(length, sizeof(*breakpoints))))
        return E_OUTOFMEMORY;
 
    if (SUCCEEDED(hr = analyze_linebreaks(source, position, length, breakpoints)))
        hr = IDWriteTextAnalysisSink_SetLineBreakpoints(sink, position, length, breakpoints);
 
    free(breakpoints);
 
    return hr;
}

dwritetextanalyzer_AnalyzeNumberSubstitution()

static HRESULT WINAPI dwritetextanalyzer_AnalyzeNumberSubstitution ( IDWriteTextAnalyzer2 *  iface, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, IDWriteTextAnalysisSink *  sink  )

static

Definition at line 1383 of file analyzer.c.

{
    static int once;
 
    if (!once++)
        FIXME("(%p %u %u %p): stub\n", source, position, length, sink);
    return S_OK;
}

dwritetextanalyzer_AnalyzeScript()

static HRESULT WINAPI dwritetextanalyzer_AnalyzeScript ( IDWriteTextAnalyzer2 *  iface, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, IDWriteTextAnalysisSink *  sink  )

static

Definition at line 1287 of file analyzer.c.

{
    struct text_source_context context;
    HRESULT hr;
 
    TRACE("%p, %u, %u, %p.\n", source, position, length, sink);
 
    if (!length)
        return S_OK;
 
    if (FAILED(hr = text_source_context_init(&context, source, position, length))) return hr;
 
    return analyze_script(&context, sink);
}

dwritetextanalyzer_GetGdiCompatibleGlyphPlacements()

static HRESULT WINAPI dwritetextanalyzer_GetGdiCompatibleGlyphPlacements ( IDWriteTextAnalyzer2 *  iface, WCHAR const *  text, UINT16 const *  clustermap, DWRITE_SHAPING_TEXT_PROPERTIES *  text_props, UINT32  text_len, UINT16 const *  glyphs, DWRITE_SHAPING_GLYPH_PROPERTIES const *  glyph_props, UINT32  glyph_count, IDWriteFontFace *  fontface, float  emSize, float  ppdip, DWRITE_MATRIX const *  transform, BOOL  use_gdi_natural, BOOL  is_sideways, BOOL  is_rtl, DWRITE_SCRIPT_ANALYSIS const *  analysis, WCHAR const *  locale, DWRITE_TYPOGRAPHIC_FEATURES const **  features, UINT32 const *  feature_range_lengths, UINT32  feature_ranges, float *  advances, DWRITE_GLYPH_OFFSET *  offsets  )

static

Definition at line 1660 of file analyzer.c.

{
    const struct dwritescript_properties *scriptprops;
    struct scriptshaping_context context = { 0 };
    DWRITE_MEASURING_MODE measuring_mode;
    struct dwrite_fontface *font_obj;
    unsigned int i;
    HRESULT hr;
 
    TRACE("%s, %p, %p, %u, %p, %p, %u, %p, %.2f, %.2f, %p, %d, %d, %d, %s, %s, %p, %p, %u, %p, %p.\n",
            debugstr_wn(text, text_len), clustermap, text_props, text_len, glyphs, glyph_props, glyph_count, fontface,
            emSize, ppdip, transform, use_gdi_natural, is_sideways, is_rtl, debugstr_sa_script(analysis->script),
            debugstr_w(locale), features, feature_range_lengths, feature_ranges, advances, offsets);
 
    analyzer_dump_user_features(features, feature_range_lengths, feature_ranges);
 
    if (glyph_count == 0)
        return S_OK;
 
    font_obj = unsafe_impl_from_IDWriteFontFace(fontface);
 
    measuring_mode = use_gdi_natural ? DWRITE_MEASURING_MODE_GDI_NATURAL : DWRITE_MEASURING_MODE_GDI_CLASSIC;
 
    for (i = 0; i < glyph_count; ++i)
    {
        if (glyph_props[i].isZeroWidthSpace)
            advances[i] = 0.0f;
        else
            advances[i] = fontface_get_scaled_design_advance(font_obj, measuring_mode, emSize, ppdip,
                    transform, glyphs[i], is_sideways);
        offsets[i].advanceOffset = 0.0f;
        offsets[i].ascenderOffset = 0.0f;
    }
 
    context.cache = fontface_get_shaping_cache(font_obj);
    context.script = analysis->script > Script_LastId ? Script_Unknown : analysis->script;
    context.text = text;
    context.length = text_len;
    context.is_rtl = is_rtl;
    context.is_sideways = is_sideways;
    context.u.pos.glyphs = glyphs;
    context.u.pos.glyph_props = glyph_props;
    context.u.pos.text_props = text_props;
    context.u.pos.clustermap = clustermap;
    context.glyph_count = glyph_count;
    context.emsize = emSize * ppdip;
    context.measuring_mode = measuring_mode;
    context.advances = advances;
    context.offsets = offsets;
    context.language_tag = get_opentype_language(locale);
    context.user_features.features = features;
    context.user_features.range_lengths = feature_range_lengths;
    context.user_features.range_count = feature_ranges;
    context.glyph_infos = calloc(glyph_count, sizeof(*context.glyph_infos));
    context.table = &context.cache->gpos;
 
    if (!context.glyph_infos)
    {
        hr = E_OUTOFMEMORY;
        goto failed;
    }
 
    scriptprops = &dwritescripts_properties[context.script];
    hr = shape_get_positions(&context, scriptprops->scripttags);
 
failed:
    free(context.glyph_infos);
 
    return hr;
}

dwritetextanalyzer_GetGlyphPlacements()

static HRESULT WINAPI dwritetextanalyzer_GetGlyphPlacements ( IDWriteTextAnalyzer2 *  iface, WCHAR const *  text, UINT16 const *  clustermap, DWRITE_SHAPING_TEXT_PROPERTIES *  text_props, UINT32  text_len, UINT16 const *  glyphs, DWRITE_SHAPING_GLYPH_PROPERTIES const *  glyph_props, UINT32  glyph_count, IDWriteFontFace *  fontface, float  emSize, BOOL  is_sideways, BOOL  is_rtl, DWRITE_SCRIPT_ANALYSIS const *  analysis, WCHAR const *  locale, DWRITE_TYPOGRAPHIC_FEATURES const **  features, UINT32 const *  feature_range_lengths, UINT32  feature_ranges, float *  advances, DWRITE_GLYPH_OFFSET *  offsets  )

static

Definition at line 1587 of file analyzer.c.

{
    const struct dwritescript_properties *scriptprops;
    struct scriptshaping_context context = { 0 };
    struct dwrite_fontface *font_obj;
    unsigned int i;
    HRESULT hr;
 
    TRACE("%s, %p, %p, %u, %p, %p, %u, %p, %.2f, %d, %d, %s, %s, %p, %p, %u, %p, %p.\n", debugstr_wn(text, text_len),
        clustermap, text_props, text_len, glyphs, glyph_props, glyph_count, fontface, emSize, is_sideways,
        is_rtl, debugstr_sa_script(analysis->script), debugstr_w(locale), features, feature_range_lengths,
        feature_ranges, advances, offsets);
 
    analyzer_dump_user_features(features, feature_range_lengths, feature_ranges);
 
    if (glyph_count == 0)
        return S_OK;
 
    font_obj = unsafe_impl_from_IDWriteFontFace(fontface);
 
    for (i = 0; i < glyph_count; ++i)
    {
        if (glyph_props[i].isZeroWidthSpace)
            advances[i] = 0.0f;
        else
            advances[i] = fontface_get_scaled_design_advance(font_obj, DWRITE_MEASURING_MODE_NATURAL, emSize, 1.0f,
                    NULL, glyphs[i], is_sideways);
        offsets[i].advanceOffset = 0.0f;
        offsets[i].ascenderOffset = 0.0f;
    }
 
    context.cache = fontface_get_shaping_cache(font_obj);
    context.script = analysis->script > Script_LastId ? Script_Unknown : analysis->script;
    context.text = text;
    context.length = text_len;
    context.is_rtl = is_rtl;
    context.is_sideways = is_sideways;
    context.u.pos.glyphs = glyphs;
    context.u.pos.glyph_props = glyph_props;
    context.u.pos.text_props = text_props;
    context.u.pos.clustermap = clustermap;
    context.glyph_count = glyph_count;
    context.emsize = emSize;
    context.measuring_mode = DWRITE_MEASURING_MODE_NATURAL;
    context.advances = advances;
    context.offsets = offsets;
    context.language_tag = get_opentype_language(locale);
    context.user_features.features = features;
    context.user_features.range_lengths = feature_range_lengths;
    context.user_features.range_count = feature_ranges;
    context.glyph_infos = calloc(glyph_count, sizeof(*context.glyph_infos));
    context.table = &context.cache->gpos;
 
    if (!context.glyph_infos)
    {
        hr = E_OUTOFMEMORY;
        goto failed;
    }
 
    scriptprops = &dwritescripts_properties[context.script];
    hr = shape_get_positions(&context, scriptprops->scripttags);
 
failed:
    free(context.glyph_infos);
 
    return hr;
}

dwritetextanalyzer_GetGlyphs()

static HRESULT WINAPI dwritetextanalyzer_GetGlyphs ( IDWriteTextAnalyzer2 *  iface, WCHAR const *  text, UINT32  length, IDWriteFontFace *  fontface, BOOL  is_sideways, BOOL  is_rtl, DWRITE_SCRIPT_ANALYSIS const *  analysis, WCHAR const *  locale, IDWriteNumberSubstitution *  substitution, DWRITE_TYPOGRAPHIC_FEATURES const **  features, UINT32 const *  feature_range_lengths, UINT32  feature_ranges, UINT32  max_glyph_count, UINT16 *  clustermap, DWRITE_SHAPING_TEXT_PROPERTIES *  text_props, UINT16 *  glyphs, DWRITE_SHAPING_GLYPH_PROPERTIES *  glyph_props, UINT32 *  actual_glyph_count  )

static

Definition at line 1516 of file analyzer.c.

{
    const struct dwritescript_properties *scriptprops;
    struct scriptshaping_context context = { 0 };
    struct dwrite_fontface *font_obj;
    WCHAR digits[NATIVE_DIGITS_LEN];
    unsigned int glyph_count;
    HRESULT hr;
 
    TRACE("%s:%u, %p, %d, %d, %s, %s, %p, %p, %p, %u, %u, %p, %p, %p, %p, %p.\n", debugstr_wn(text, length),
        length, fontface, is_sideways, is_rtl, debugstr_sa_script(analysis->script), debugstr_w(locale), substitution,
        features, feature_range_lengths, feature_ranges, max_glyph_count, clustermap, text_props, glyphs,
        glyph_props, actual_glyph_count);
 
    analyzer_dump_user_features(features, feature_range_lengths, feature_ranges);
 
    get_number_substitutes(substitution, is_rtl, digits);
    font_obj = unsafe_impl_from_IDWriteFontFace(fontface);
    glyph_count = max(max_glyph_count, length);
 
    context.cache = fontface_get_shaping_cache(font_obj);
    context.script = analysis->script > Script_LastId ? Script_Unknown : analysis->script;
    context.text = text;
    context.length = length;
    context.is_rtl = is_rtl;
    context.is_sideways = is_sideways;
    context.u.subst.glyphs = calloc(glyph_count, sizeof(*glyphs));
    context.u.subst.glyph_props = calloc(glyph_count, sizeof(*glyph_props));
    context.u.subst.text_props = text_props;
    context.u.subst.clustermap = clustermap;
    context.u.subst.max_glyph_count = max_glyph_count;
    context.u.subst.capacity = glyph_count;
    context.u.subst.digits = digits;
    context.language_tag = get_opentype_language(locale);
    context.user_features.features = features;
    context.user_features.range_lengths = feature_range_lengths;
    context.user_features.range_count = feature_ranges;
    context.glyph_infos = calloc(glyph_count, sizeof(*context.glyph_infos));
    context.table = &context.cache->gsub;
 
    *actual_glyph_count = 0;
 
    if (!context.u.subst.glyphs || !context.u.subst.glyph_props || !context.glyph_infos)
    {
        hr = E_OUTOFMEMORY;
        goto failed;
    }
 
    scriptprops = &dwritescripts_properties[context.script];
    hr = shape_get_glyphs(&context, scriptprops->scripttags);
    if (SUCCEEDED(hr))
    {
        *actual_glyph_count = context.glyph_count;
        memcpy(glyphs, context.u.subst.glyphs, context.glyph_count * sizeof(*glyphs));
        memcpy(glyph_props, context.u.subst.glyph_props, context.glyph_count * sizeof(*glyph_props));
    }
 
failed:
    free(context.u.subst.glyph_props);
    free(context.u.subst.glyphs);
    free(context.glyph_infos);
 
    return hr;
}

dwritetextanalyzer_QueryInterface()

static HRESULT WINAPI dwritetextanalyzer_QueryInterface ( IDWriteTextAnalyzer2 *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1258 of file analyzer.c.

{
    TRACE("%s, %p.\n", debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IDWriteTextAnalyzer2) ||
        IsEqualIID(riid, &IID_IDWriteTextAnalyzer1) ||
        IsEqualIID(riid, &IID_IDWriteTextAnalyzer) ||
        IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        return S_OK;
    }
 
    WARN("%s not implemented.\n", debugstr_guid(riid));
 
    *obj = NULL;
    return E_NOINTERFACE;
}

dwritetextanalyzer_Release()

static ULONG WINAPI dwritetextanalyzer_Release ( IDWriteTextAnalyzer2 *  iface )

static

Definition at line 1282 of file analyzer.c.

{
    return 1;
}

fallback_builder_add_locale()

static struct fallback_locale * fallback_builder_add_locale ( struct dwrite_fontfallback_builder *  builder, const WCHAR *  locale_name  )

static

Definition at line 2663 of file analyzer.c.

{
    struct fallback_locale *locale;
 
    if (!locale_name) locale_name = L"";
    if ((locale = font_fallback_get_locale(&builder->data.locales, locale_name))) return locale;
    if (!(locale = calloc(1, sizeof(*locale)))) return NULL;
    lstrcpynW(locale->name, locale_name, ARRAY_SIZE(locale->name));
    list_add_tail(&builder->data.locales, &locale->entry);
    return locale;
}

Referenced by fontfallbackbuilder_AddMapping().

fallback_font_get_supported_length()

static UINT32 fallback_font_get_supported_length ( IDWriteFont3 *  font, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length  )

static

Definition at line 2385 of file analyzer.c.

{
    struct text_source_context context;
    UINT32 mapped = 0;
 
    text_source_context_init(&context, source, position, length);
    while (!text_source_get_next_u32_char(&context))
    {
        /* Ignore selectors that are not leading. */
        if (!mapped || !fallback_is_uvs(&context))
        {
            if (!IDWriteFont3_HasCharacter(font, context.ch)) break;
        }
        mapped += text_source_get_char_length(&context);
    }
 
    return mapped;
}

Referenced by fallback_map_characters(), and fontfallback_MapCharacters().

fallback_is_uvs()

static BOOL fallback_is_uvs ( const struct text_source_context *  context )

inlinestatic

Definition at line 2374 of file analyzer.c.

{
    /* MONGOLIAN FREE VARIATION SELECTOR ONE..THREE */
    if (context->ch >= 0x180b && context->ch <= 0x180d) return TRUE;
    /* VARIATION SELECTOR-1..16 */
    if (context->ch >= 0xfe00 && context->ch <= 0xfe0f) return TRUE;
    /* VARIATION SELECTOR-17..256 */
    if (context->ch >= 0xe0100 && context->ch <= 0xe01ef) return TRUE;
    return FALSE;
}

Referenced by fallback_font_get_supported_length().

fallback_locale_add_mapping()

static HRESULT fallback_locale_add_mapping ( struct fallback_locale *  locale, size_t  index  )

static

Definition at line 490 of file analyzer.c.

{
    size_t count = locale->ranges.count;
 
    /* Append to last range, or start a new one. */
    if (count && locale->ranges.data[count - 1] == (index - 1))
    {
        locale->ranges.data[count - 1] = index;
        return S_OK;
    }
 
    if (!dwrite_array_reserve((void **)&locale->ranges.data, &locale->ranges.size, count + 2,
            sizeof(*locale->ranges.data)))
    {
        return E_OUTOFMEMORY;
    }
 
    locale->ranges.data[count] = locale->ranges.data[count + 1] = index;
    locale->ranges.count += 2;
 
    return S_OK;
}

Referenced by fontfallbackbuilder_AddMapping().

fallback_locale_list_destroy()

static void fallback_locale_list_destroy ( struct list *  locales )

static

Definition at line 478 of file analyzer.c.

{
    struct fallback_locale *cur, *cur2;
 
    LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, locales, struct fallback_locale, entry)
    {
        list_remove(&cur->entry);
        free(cur->ranges.data);
        free(cur);
    }
}

Referenced by release_fallback_data().

fallback_map_characters()

static HRESULT fallback_map_characters ( const struct dwrite_fontfallback *  fallback, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  text_length, DWRITE_FONT_WEIGHT  weight, DWRITE_FONT_STYLE  style, DWRITE_FONT_STRETCH  stretch, IDWriteFont **  ret_font, UINT32 *  ret_length, float *  scale  )

static

Definition at line 2405 of file analyzer.c.

{
    const struct fallback_mapping *mapping = NULL;
    struct text_source_context context;
    const struct fallback_data *data;
    const WCHAR *locale_name = NULL;
    struct fallback_locale *locale;
    UINT32 i, length = 0, mapped;
    IDWriteFont3 *font;
    HRESULT hr;
 
    /* ~0u is a marker for system fallback data */
    data = fallback->data.count == ~0u ? &system_fallback : &fallback->data;
 
    /* We will try to map as much of given input as GetLocaleName() says. It's assumed that returned length covers
       whole span of characters set with that locale, so callback is only used once. */
    if (FAILED(hr = IDWriteTextAnalysisSource_GetLocaleName(source, position, &length, &locale_name)))
        return hr;
 
    length = length ? min(length, text_length) : text_length;
    if (!locale_name) locale_name = L"";
 
    /* Lookup locale entry once, if specific locale is missing neutral one will be returned. */
    locale = font_fallback_get_locale(&data->locales, locale_name);
 
    if (FAILED(hr = text_source_context_init(&context, source, position, length))) return hr;
 
    /* Find a mapping for given locale. */
    text_source_get_next_u32_char(&context);
    mapping = find_fallback_mapping(data, locale, context.ch);
    mapped = text_source_get_char_length(&context);
    while (!text_source_get_next_u32_char(&context))
    {
        if (find_fallback_mapping(data, locale, context.ch) != mapping) break;
        mapped += text_source_get_char_length(&context);
    }
 
    if (!mapping)
    {
        *ret_font = NULL;
        *ret_length = mapped;
 
        return S_OK;
    }
 
    /* Go through families in the mapping, use first family that supports some of the input. */
    for (i = 0; i < mapping->families_count; ++i)
    {
        if (SUCCEEDED(create_matching_font(mapping->collection ? mapping->collection : fallback->systemcollection,
                mapping->families[i], weight, style, stretch, &IID_IDWriteFont3, (void **)&font)))
        {
            if (!(mapped = fallback_font_get_supported_length(font, source, position, mapped)))
            {
                IDWriteFont3_Release(font);
                continue;
            }
 
            *ret_font = (IDWriteFont *)font;
            *ret_length = mapped;
            *scale = mapping->scale;
 
            return S_OK;
        }
    }
 
    /* Mapping was found, but either font couldn't be created or there's no font that supports given input. */
    *ret_font = NULL;
    *ret_length = length;
 
    return S_OK;
}

Referenced by fontfallback_MapCharacters().

fallback_mapping_contains_character()

static BOOL fallback_mapping_contains_character ( const struct fallback_mapping *  mapping, UINT32  ch  )

static

Definition at line 581 of file analyzer.c.

{
    size_t i;
 
    for (i = 0; i < mapping->ranges_count; ++i)
    {
        const DWRITE_UNICODE_RANGE *range = &mapping->ranges[i];
        if (range->first <= ch && range->last >= ch) return TRUE;
    }
 
    return FALSE;
}

Referenced by find_fallback_mapping().

fallbackbuilder_create_fallback()

static HRESULT fallbackbuilder_create_fallback ( struct dwrite_fontfallback_builder *  builder, struct dwrite_fontfallback **  ret  )

static

Definition at line 2847 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback;
    HRESULT hr;
 
    if (!(fallback = calloc(1, sizeof(*fallback))))
        return E_OUTOFMEMORY;
 
    fallback->IDWriteFontFallback1_iface.lpVtbl = &customfontfallbackvtbl;
    fallback->refcount = 1;
    fallback->factory = builder->factory;
    IDWriteFactory7_AddRef(fallback->factory);
    if (FAILED(hr = IDWriteFactory_GetSystemFontCollection((IDWriteFactory *)fallback->factory,
            &fallback->systemcollection, FALSE)))
    {
        goto done;
    }
 
    if (FAILED(hr = fallbackbuilder_init_fallback_data(builder, &fallback->data)))
    {
        goto done;
    }
 
    *ret = fallback;
 
    return S_OK;
 
done:
 
    IDWriteFontFallback1_Release(&fallback->IDWriteFontFallback1_iface);
    return hr;
}

Referenced by fontfallbackbuilder_CreateFontFallback().

fallbackbuilder_init_fallback_data()

static HRESULT fallbackbuilder_init_fallback_data ( const struct dwrite_fontfallback_builder *  builder, struct fallback_data *  data  )

static

Definition at line 2790 of file analyzer.c.

{
    struct fallback_locale *iter, *locale;
    size_t i, j;
 
    /* Duplicate locales list. */
    list_init(&data->locales);
    LIST_FOR_EACH_ENTRY(iter, &builder->data.locales, struct fallback_locale, entry)
    {
        if (!(locale = calloc(1, sizeof(*locale)))) goto failed;
        wcscpy(locale->name, iter->name);
        locale->ranges.count = iter->ranges.count;
        locale->ranges.size = iter->ranges.count;
        if (!(locale->ranges.data = malloc(iter->ranges.count * sizeof(*iter->ranges.data))))
        {
            free(locale);
            goto failed;
        }
        memcpy(locale->ranges.data, iter->ranges.data, iter->ranges.count * sizeof(*iter->ranges.data));
        list_add_tail(&data->locales, &locale->entry);
    }
 
    /* Duplicate mappings. */
    if (!(data->mappings = calloc(builder->data.count, sizeof(*data->mappings))))
        goto failed;
 
    data->count = builder->data.count;
    for (i = 0; i < data->count; ++i)
    {
        struct fallback_mapping *src = &builder->data.mappings[i];
        struct fallback_mapping *dst = &data->mappings[i];
 
        if (!(dst->ranges = calloc(src->ranges_count, sizeof(*src->ranges)))) goto failed;
        memcpy(dst->ranges, src->ranges, src->ranges_count * sizeof(*src->ranges));
        dst->ranges_count = src->ranges_count;
 
        if (!(dst->families = calloc(src->families_count, sizeof(*src->families)))) goto failed;
        dst->families_count = src->families_count;
        for (j = 0; j < src->families_count; ++j)
        {
            if (!(dst->families[j] = wcsdup(src->families[j]))) goto failed;
        }
 
        dst->collection = src->collection;
        if (dst->collection)
            IDWriteFontCollection_AddRef(dst->collection);
        dst->scale = src->scale;
    }
 
    return S_OK;
 
failed:
 
    return E_OUTOFMEMORY;
}

Referenced by dwrite_system_fallback_initonce(), and fallbackbuilder_create_fallback().

find_fallback_mapping()

static const struct fallback_mapping * find_fallback_mapping ( const struct fallback_data *  fallback, const struct fallback_locale *  locale, UINT32  ch  )

static

Definition at line 594 of file analyzer.c.

{
    const struct fallback_mapping *mapping;
    size_t i, j;
 
    for (i = 0; i < locale->ranges.count; i += 2)
    {
        size_t start = locale->ranges.data[i], end = locale->ranges.data[i + 1];
        for (j = start; j <= end; ++j)
        {
            mapping = &fallback->mappings[j];
            if (fallback_mapping_contains_character(mapping, ch)) return mapping;
        }
    }
 
    mapping = NULL;
 
    /* Mapping wasn't found for specific locale, try with neutral one. This will only recurse once. */
    if (*locale->name)
    {
        locale = font_fallback_get_locale(&fallback->locales, L"");
        mapping = find_fallback_mapping(fallback, locale, ch);
    }
 
    return mapping;
}

Referenced by fallback_map_characters(), and find_fallback_mapping().

font_fallback_get_locale()

static struct fallback_locale * font_fallback_get_locale ( const struct list *  locales, const WCHAR *  locale_name  )

static

Definition at line 514 of file analyzer.c.

{
    struct fallback_locale *locale, *neutral = NULL;
 
    LIST_FOR_EACH_ENTRY(locale, locales, struct fallback_locale, entry)
    {
        if (!wcsicmp(locale->name, locale_name)) return locale;
        if (!*locale->name) neutral = locale;
    }
 
    return neutral;
}

Referenced by fallback_builder_add_locale(), fallback_map_characters(), and find_fallback_mapping().

fontfallback1_MapCharacters()

static HRESULT WINAPI fontfallback1_MapCharacters ( IDWriteFontFallback1 *  iface, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, IDWriteFontCollection *  basecollection, const WCHAR *  basefamily, DWRITE_FONT_AXIS_VALUE const *  axis_values, UINT32  values_count, UINT32 *  mapped_length, FLOAT *  scale, IDWriteFontFace5 **  ret_fontface  )

static

Definition at line 2555 of file analyzer.c.

{
    FIXME("%p, %p, %u, %u, %p, %s, %p, %u, %p, %p, %p.\n", iface, source, position, length, basecollection,
            debugstr_w(basefamily), axis_values, values_count, mapped_length, scale, ret_fontface);
 
    return E_NOTIMPL;
}

fontfallback_AddRef()

static ULONG WINAPI fontfallback_AddRef ( IDWriteFontFallback1 *  iface )

static

Definition at line 2356 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback = impl_from_IDWriteFontFallback1(iface);
 
    TRACE("%p.\n", iface);
 
    return IDWriteFactory7_AddRef(fallback->factory);
}

fontfallback_MapCharacters()

static HRESULT WINAPI fontfallback_MapCharacters ( IDWriteFontFallback1 *  iface, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length, IDWriteFontCollection *  basecollection, const WCHAR *  basefamily, DWRITE_FONT_WEIGHT  weight, DWRITE_FONT_STYLE  style, DWRITE_FONT_STRETCH  stretch, UINT32 *  mapped_length, IDWriteFont **  ret_font, float *  scale  )

static

Definition at line 2513 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback = impl_from_IDWriteFontFallback1(iface);
    IDWriteFont3 *font;
 
    TRACE("%p, %p, %u, %u, %p, %s, %u, %u, %u, %p, %p, %p.\n", iface, source, position, length,
        basecollection, debugstr_w(basefamily), weight, style, stretch, mapped_length, ret_font, scale);
 
    *mapped_length = 0;
    *ret_font = NULL;
    *scale = 1.0f;
 
    if (!source)
        return E_INVALIDARG;
 
    if (!length)
        return S_OK;
 
    if (!basecollection)
        basecollection = fallback->systemcollection;
 
    if (basefamily && *basefamily)
    {
        if (SUCCEEDED(create_matching_font(basecollection, basefamily, weight, style, stretch,
                &IID_IDWriteFont, (void **)&font)))
        {
            if ((*mapped_length = fallback_font_get_supported_length(font, source, position, length)))
            {
                *ret_font = (IDWriteFont *)font;
                *scale = 1.0f;
                return S_OK;
            }
            IDWriteFont3_Release(font);
        }
    }
 
    return fallback_map_characters(fallback, source, position, length, weight, style, stretch, ret_font, mapped_length, scale);
}

fontfallback_QueryInterface()

static HRESULT WINAPI fontfallback_QueryInterface ( IDWriteFontFallback1 *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2337 of file analyzer.c.

{
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IDWriteFontFallback1) ||
            IsEqualIID(riid, &IID_IDWriteFontFallback) ||
            IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IDWriteFontFallback1_AddRef(iface);
        return S_OK;
    }
 
    WARN("%s not implemented.\n", debugstr_guid(riid));
 
    *obj = NULL;
    return E_NOINTERFACE;
}

fontfallback_Release()

static ULONG WINAPI fontfallback_Release ( IDWriteFontFallback1 *  iface )

static

Definition at line 2365 of file analyzer.c.

{
    struct dwrite_fontfallback *fallback = impl_from_IDWriteFontFallback1(iface);
 
    TRACE("%p.\n", fallback);
 
    return IDWriteFactory7_Release(fallback->factory);
}

fontfallbackbuilder_AddMapping()

static HRESULT WINAPI fontfallbackbuilder_AddMapping ( IDWriteFontFallbackBuilder *  iface, const DWRITE_UNICODE_RANGE *  ranges, UINT32  ranges_count, WCHAR const **  families, UINT32  families_count, IDWriteFontCollection *  collection, WCHAR const *  locale_name, WCHAR const *  base_family, float  scale  )

static

Definition at line 2676 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *builder = impl_from_IDWriteFontFallbackBuilder(iface);
    struct fallback_mapping *mapping;
    struct fallback_locale *locale;
    unsigned int i, j, m, count;
 
    TRACE("%p, %p, %u, %p, %u, %p, %s, %s, %f.\n", iface, ranges, ranges_count, families, families_count,
            collection, debugstr_w(locale_name), debugstr_w(base_family), scale);
 
    if (!ranges || !ranges_count || !families || !families_count || scale < 0.0f)
        return E_INVALIDARG;
 
    if (base_family)
        FIXME("base family ignored.\n");
 
    if (!dwrite_array_reserve((void **)&builder->data.mappings, &builder->mappings_size,
            builder->data.count + 1, sizeof(*builder->data.mappings)))
    {
        return E_OUTOFMEMORY;
    }
 
    mapping = &builder->data.mappings[builder->data.count];
    memset(mapping, 0, sizeof(*mapping));
 
    /* Append new mapping, link to its locale node. */
 
    if (!(locale = fallback_builder_add_locale(builder, locale_name)))
        return E_FAIL;
 
    if (!(mapping->ranges = calloc(ranges_count, sizeof(*mapping->ranges))))
        goto failed;
 
    /* Filter ranges that won't be usable. */
    for (i = 0, count = 0; i < ranges_count; ++i)
    {
        if (ranges[i].first > ranges[i].last) continue;
        if (ranges[i].first > 0x10ffff) continue;
        mapping->ranges[count].first = ranges[i].first;
        mapping->ranges[count].last = min(ranges[i].last, 0x10ffff);
        count++;
    }
    if (!count)
    {
        release_fallback_mapping(mapping);
        return S_OK;
    }
 
    mapping->ranges_count = count;
 
    if (!(mapping->families = calloc(families_count, sizeof(*mapping->families))))
        goto failed;
    mapping->families_count = families_count;
    for (i = 0; i < families_count; i++)
        if (!(mapping->families[i] = wcsdup(families[i]))) goto failed;
    mapping->scale = scale;
 
    if (FAILED(fallback_locale_add_mapping(locale, builder->data.count))) goto failed;
 
    /* Mappings with explicit collections take priority, for that reduce existing mappings ranges
       by newly added ranges. */
 
    mapping->collection = collection;
    if (mapping->collection)
    {
        IDWriteFontCollection_AddRef(mapping->collection);
 
        for (m = 0; m < builder->data.count; ++m)
        {
            struct fallback_mapping *c = &builder->data.mappings[m];
            if (c->collection) continue;
            for (i = 0; i < count; ++i)
            {
                const DWRITE_UNICODE_RANGE *new_range = &mapping->ranges[i];
 
                for (j = 0; j < c->ranges_count; ++j)
                {
                    DWRITE_UNICODE_RANGE *range = &c->ranges[j];
 
                    /* In case existing ranges intersect, disable or reduce them */
                    if (range->first >= new_range->first && range->last <= new_range->last)
                    {
                        range->first = range->last = ~0u;
                    }
                    else if (range->first >= new_range->first && range->first <= new_range->last)
                    {
                        range->first = new_range->last;
                    }
                    else if (range->last >= new_range->first && range->last <= new_range->last)
                    {
                        range->last = new_range->first;
                    }
                }
            }
        }
    }
 
    builder->data.count++;
    return S_OK;
 
failed:
    release_fallback_mapping(mapping);
    return E_OUTOFMEMORY;
}

fontfallbackbuilder_AddMappings()

static HRESULT WINAPI fontfallbackbuilder_AddMappings ( IDWriteFontFallbackBuilder *  iface, IDWriteFontFallback *  fallback  )

static

Definition at line 2783 of file analyzer.c.

{
    FIXME("%p, %p stub.\n", iface, fallback);
 
    return E_NOTIMPL;
}

fontfallbackbuilder_AddRef()

static ULONG WINAPI fontfallbackbuilder_AddRef ( IDWriteFontFallbackBuilder *  iface )

static

Definition at line 2636 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *fallbackbuilder = impl_from_IDWriteFontFallbackBuilder(iface);
    ULONG refcount = InterlockedIncrement(&fallbackbuilder->refcount);
 
    TRACE("%p, refcount %ld.\n", iface, refcount);
 
    return refcount;
}

fontfallbackbuilder_CreateFontFallback()

static HRESULT WINAPI fontfallbackbuilder_CreateFontFallback ( IDWriteFontFallbackBuilder *  iface, IDWriteFontFallback **  ret  )

static

Definition at line 2880 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *builder = impl_from_IDWriteFontFallbackBuilder(iface);
    struct dwrite_fontfallback *fallback;
    HRESULT hr;
 
    TRACE("%p, %p.\n", iface, ret);
 
    *ret = NULL;
 
    if (SUCCEEDED(hr = fallbackbuilder_create_fallback(builder, &fallback)))
    {
        *ret = (IDWriteFontFallback *)&fallback->IDWriteFontFallback1_iface;
    }
 
    return hr;
}

fontfallbackbuilder_QueryInterface()

static HRESULT WINAPI fontfallbackbuilder_QueryInterface ( IDWriteFontFallbackBuilder *  iface, REFIID  riid, void **  obj  )

static

Definition at line 2620 of file analyzer.c.

{
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IDWriteFontFallbackBuilder) || IsEqualIID(riid, &IID_IUnknown)) {
        *obj = iface;
        IDWriteFontFallbackBuilder_AddRef(iface);
        return S_OK;
    }
 
    WARN("%s not implemented.\n", debugstr_guid(riid));
 
    *obj = NULL;
    return E_NOINTERFACE;
}

fontfallbackbuilder_Release()

static ULONG WINAPI fontfallbackbuilder_Release ( IDWriteFontFallbackBuilder *  iface )

static

Definition at line 2646 of file analyzer.c.

{
    struct dwrite_fontfallback_builder *builder = impl_from_IDWriteFontFallbackBuilder(iface);
    ULONG refcount = InterlockedDecrement(&builder->refcount);
 
    TRACE("%p, refcount %ld.\n", iface, refcount);
 
    if (!refcount)
    {
        IDWriteFactory7_Release(builder->factory);
        release_fallback_data(&builder->data);
        free(builder);
    }
 
    return refcount;
}

get_bidi_char_length()

static unsigned int get_bidi_char_length ( const struct bidi_char *  c )

inlinestatic

Definition at line 1303 of file analyzer.c.

{
    return c->ch > 0xffff ? 2 : 1;
}

Referenced by dwritetextanalyzer_AnalyzeBidi().

get_char_bidi_class()

static UINT8 get_char_bidi_class ( UINT32  ch )

inlinestatic

Definition at line 1308 of file analyzer.c.

{
    return get_table_entry_32(bidi_direction_table, ch);
}

Referenced by dwritetextanalyzer_AnalyzeBidi().

get_char_sa()

static DWRITE_SCRIPT_ANALYSIS get_char_sa ( UINT32  c )

static

Definition at line 655 of file analyzer.c.

{
    DWRITE_SCRIPT_ANALYSIS sa;
 
    sa.script = get_char_script(c);
    sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
    if ((c <= 0x001f)                          /* C0 controls */
            || (c >= 0x007f && c <= 0x009f)    /* DELETE, C1 controls */
            || (c == 0x00ad)                   /* SOFT HYPHEN */
            || (c >= 0x200b && c <= 0x200f)    /* ZWSP, ZWNJ, ZWJ, LRM, RLM */
            || (c >= 0x2028 && c <= 0x202e)    /* Line/paragraph separators, LRE, RLE, PDF, LRO, RLO */
            || (c >= 0x2060 && c <= 0x2064)    /* WJ, invisible operators */
            || (c >= 0x2066 && c <= 0x2069)    /* LRI, RLI, FSI, PDI */
            || (c >= 0x206a && c <= 0x206f)    /* Deprecated control characters */
            || (c == 0xfeff)                   /* ZWBNSP */
            || (c == 0xfff9)                   /* Interlinear annotation */
            || (c == 0xfffa)
            || (c == 0xfffb)
            || (c >= 0x1bca0 && c <= 0x1bca3)  /* Shorthand format controls */
            || (c >= 0x1d173 && c <= 0x1d17a)  /* Musical symbols: beams and slurs */
            || (c == 0xe0001)                  /* Language tag, deprecated */
            || (c >= 0xe0020 && c <= 0xe007f)) /* Tag components */
    {
        sa.shapes = DWRITE_SCRIPT_SHAPES_NO_VISUAL;
    }
    else
    {
        sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
    }
 
    return sa;
}

Referenced by analyze_script().

get_char_script()

static UINT16 get_char_script ( UINT32  c )

inlinestatic

Definition at line 649 of file analyzer.c.

{
    UINT16 script = get_table_entry_32(wine_scripts_table, c);
    return script == Script_Inherited ? Script_Unknown : script;
}

Referenced by get_char_sa(), and is_char_from_simple_script().

get_cluster_length()

static UINT32 get_cluster_length ( UINT16 const *  clustermap, UINT32  start, UINT32  text_len  )

inlinestatic

Definition at line 1853 of file analyzer.c.

{
    UINT16 g = clustermap[start];
    UINT32 length = 1;
 
    while (start < (text_len - 1) && clustermap[++start] == g)
        length++;
    return length;
}

Referenced by dwritetextanalyzer1_ApplyCharacterSpacing().

get_number_substitutes()

static void get_number_substitutes ( IDWriteNumberSubstitution *  substitution, BOOL  is_rtl, WCHAR *  digits  )

static

Definition at line 1428 of file analyzer.c.

{
    struct dwrite_numbersubstitution *numbersubst = unsafe_impl_from_IDWriteNumberSubstitution(substitution);
    DWRITE_NUMBER_SUBSTITUTION_METHOD method;
    WCHAR isolang[9];
    DWORD lctype;
 
    digits[0] = 0;
 
    if (!numbersubst)
        return;
 
    lctype = numbersubst->ignore_user_override ? LOCALE_NOUSEROVERRIDE : 0;
 
    if (numbersubst->method == DWRITE_NUMBER_SUBSTITUTION_METHOD_FROM_CULTURE) {
        DWORD value;
 
        method = DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE;
        if (GetLocaleInfoEx(numbersubst->locale, lctype | LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER, (WCHAR *)&value, 2)) {
            switch (value)
            {
            case 0:
                method = DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL;
                break;
            case 2:
                method = DWRITE_NUMBER_SUBSTITUTION_METHOD_NATIONAL;
                break;
            case 1:
            default:
                if (value != 1)
                    WARN("Unknown IDIGITSUBSTITUTION value %lu, locale %s.\n", value, debugstr_w(numbersubst->locale));
            }
        }
        else
            WARN("Failed to get IDIGITSUBSTITUTION for locale %s\n", debugstr_w(numbersubst->locale));
    }
    else
        method = numbersubst->method;
 
    switch (method)
    {
    case DWRITE_NUMBER_SUBSTITUTION_METHOD_NATIONAL:
        GetLocaleInfoEx(numbersubst->locale, lctype | LOCALE_SNATIVEDIGITS, digits, NATIVE_DIGITS_LEN);
        break;
    case DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL:
    case DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL:
        if (GetLocaleInfoEx(numbersubst->locale, LOCALE_SISO639LANGNAME, isolang, ARRAY_SIZE(isolang)))
        {
             static const WCHAR arabicW[] = {0x640,0x641,0x642,0x643,0x644,0x645,0x646,0x647,0x648,0x649,0};
 
             /* For some Arabic locales Latin digits are returned for SNATIVEDIGITS */
             if (!wcscmp(L"ar", isolang))
             {
                 wcscpy(digits, arabicW);
                 break;
             }
        }
        GetLocaleInfoEx(numbersubst->locale, lctype | LOCALE_SNATIVEDIGITS, digits, NATIVE_DIGITS_LEN);
        break;
    default:
        ;
    }
 
    if (method != DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE && !*digits) {
        WARN("Failed to get number substitutes for locale %s, method %d\n", debugstr_w(numbersubst->locale), method);
        method = DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE;
    }
 
    if ((method == DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL && !is_rtl) || method == DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE)
        digits[0] = 0;
}

Referenced by dwritetextanalyzer_GetGlyphs().

get_opentype_language()

static UINT32 get_opentype_language ( const WCHAR *  locale )

static

Definition at line 1415 of file analyzer.c.

{
    UINT32 language = DWRITE_MAKE_OPENTYPE_TAG('d','f','l','t');
 
    if (locale) {
        WCHAR tag[5];
        if (GetLocaleInfoEx(locale, LOCALE_SOPENTYPELANGUAGETAG, tag, ARRAY_SIZE(tag)))
            language = DWRITE_MAKE_OPENTYPE_TAG(tag[0],tag[1],tag[2],tag[3]);
    }
 
    return language;
}

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

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().

has_strong_condition()

static BOOL has_strong_condition ( DWRITE_BREAK_CONDITION  old_condition, DWRITE_BREAK_CONDITION  new_condition  )

static

Definition at line 802 of file analyzer.c.

{
    if (old_condition == DWRITE_BREAK_CONDITION_MAY_NOT_BREAK || old_condition == DWRITE_BREAK_CONDITION_MUST_BREAK)
        return TRUE;
 
    if (old_condition == DWRITE_BREAK_CONDITION_CAN_BREAK && new_condition != DWRITE_BREAK_CONDITION_MUST_BREAK)
        return TRUE;
 
    return FALSE;
}

Referenced by set_break_condition().

impl_from_IDWriteFontFallback1()

static struct dwrite_fontfallback * impl_from_IDWriteFontFallback1 ( IDWriteFontFallback1 *  iface )

inlinestatic

Definition at line 639 of file analyzer.c.

{
    return CONTAINING_RECORD(iface, struct dwrite_fontfallback, IDWriteFontFallback1_iface);
}

Referenced by customfontfallback_AddRef(), customfontfallback_Release(), fontfallback_AddRef(), fontfallback_MapCharacters(), fontfallback_Release(), and release_system_fontfallback().

impl_from_IDWriteFontFallbackBuilder()

static struct dwrite_fontfallback_builder * impl_from_IDWriteFontFallbackBuilder ( IDWriteFontFallbackBuilder *  iface )

inlinestatic

Definition at line 644 of file analyzer.c.

{
    return CONTAINING_RECORD(iface, struct dwrite_fontfallback_builder, IDWriteFontFallbackBuilder_iface);
}

Referenced by fontfallbackbuilder_AddMapping(), fontfallbackbuilder_AddRef(), fontfallbackbuilder_CreateFontFallback(), and fontfallbackbuilder_Release().

impl_from_IDWriteNumberSubstitution()

static struct dwrite_numbersubstitution * impl_from_IDWriteNumberSubstitution ( IDWriteNumberSubstitution *  iface )

inlinestatic

Definition at line 632 of file analyzer.c.

{
    return CONTAINING_RECORD(iface, struct dwrite_numbersubstitution, IDWriteNumberSubstitution_iface);
}

Referenced by dwritenumbersubstitution_AddRef(), and dwritenumbersubstitution_Release().

is_char_from_simple_script()

static BOOL is_char_from_simple_script ( WCHAR  c )

inlinestatic

Definition at line 2018 of file analyzer.c.

{
    if (IS_HIGH_SURROGATE(c) || IS_LOW_SURROGATE(c) ||
            /* LRM, RLM, LRE, RLE, PDF, LRO, RLO */
            c == 0x200e || c == 0x200f || (c >= 0x202a && c <= 0x202e))
        return FALSE;
    else {
        UINT16 script = get_char_script(c);
        return !dwritescripts_properties[script].is_complex;
    }
}

Referenced by dwritetextanalyzer1_GetTextComplexity().

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().

release_fallback_data()

static void release_fallback_data ( struct fallback_data *  data )

static

Definition at line 571 of file analyzer.c.

{
    size_t i;
 
    for (i = 0; i < data->count; ++i)
        release_fallback_mapping(&data->mappings[i]);
    free(data->mappings);
    fallback_locale_list_destroy(&data->locales);
}

Referenced by customfontfallback_Release(), fontfallbackbuilder_Release(), and release_system_fallback_data().

release_fallback_mapping()

static void release_fallback_mapping ( struct fallback_mapping *  mapping )

static

Definition at line 559 of file analyzer.c.

{
    unsigned int i;
 
    free(mapping->ranges);
    for (i = 0; i < mapping->families_count; ++i)
        free(mapping->families[i]);
    free(mapping->families);
    if (mapping->collection)
        IDWriteFontCollection_Release(mapping->collection);
}

Referenced by fontfallbackbuilder_AddMapping(), and release_fallback_data().

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 *

iface

)

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_break_condition()

static void set_break_condition ( UINT32  pos, enum BreakConditionLocation  location, DWRITE_BREAK_CONDITION  condition, struct linebreaking_state *  state  )

inlinestatic

Definition at line 815 of file analyzer.c.

{
    unsigned int index = state->breaks[pos].index;
 
    if (location == BreakConditionBefore)
    {
        if (has_strong_condition(state->breakpoints[index].breakConditionBefore, condition))
            return;
        state->breakpoints[index].breakConditionBefore = condition;
        if (pos)
        {
            --pos;
 
            index = state->breaks[pos].index;
            if (state->breaks[pos].length > 1) index++;
 
            state->breakpoints[index].breakConditionAfter = condition;
        }
    }
    else
    {
        if (state->breaks[pos].length > 1) index++;
 
        if (has_strong_condition(state->breakpoints[index].breakConditionAfter, condition))
            return;
        state->breakpoints[index].breakConditionAfter = condition;
 
        if (pos + 1 < state->count)
        {
            index = state->breaks[pos + 1].index;
            state->breakpoints[index].breakConditionBefore = condition;
        }
    }
}

Referenced by analyze_linebreaks().

system_fallback_parse_families()

static void system_fallback_parse_families ( WCHAR *  str, WCHAR **  families, unsigned int  max_count, unsigned int *  ret  )

static

Definition at line 2964 of file analyzer.c.

{
    unsigned int count = 0;
    WCHAR *family, *ctx;
 
    family = wcstok_s(str, L",", &ctx);
    while (family && count < max_count)
    {
        while (*family == ' ') family++;
        families[count++] = family;
        family = wcstok_s(NULL, L",", &ctx);
    }
 
    *ret = count;
}

Referenced by dwrite_system_fallback_initonce().

system_fallback_parse_ranges()

static void system_fallback_parse_ranges ( const char *  str, DWRITE_UNICODE_RANGE *  ranges, unsigned int  max_count, unsigned int *  ret  )

static

Definition at line 2942 of file analyzer.c.

{
    unsigned int count = 0;
    char *end;
 
    while (*str && count < max_count)
    {
        ranges[count].first = ranges[count].last = strtoul(str, &end, 16);
        if (*end == '-')
        {
            str = end + 1;
            ranges[count].last = strtoul(str, &end, 16);
        }
        str = end;
        if (*str == ',') str++;
        count++;
    }
 
    *ret = count;
}

Referenced by dwrite_system_fallback_initonce().

text_source_context_init()

static HRESULT text_source_context_init ( struct text_source_context *  context, IDWriteTextAnalysisSource *  source, UINT32  position, UINT32  length  )

static

Definition at line 421 of file analyzer.c.

{
    memset(context, 0, sizeof(*context));
    context->source = source;
    context->position = position;
    context->length = length;
 
    return IDWriteTextAnalysisSource_GetTextAtPosition(source, position, &context->text, &context->chunk_length);
}

Referenced by analyze_linebreaks(), dwritetextanalyzer_AnalyzeBidi(), dwritetextanalyzer_AnalyzeScript(), fallback_font_get_supported_length(), and fallback_map_characters().

text_source_get_char_length()

static unsigned int text_source_get_char_length ( const struct text_source_context *  context )

inlinestatic

Definition at line 379 of file analyzer.c.

{
    return context->ch > 0xffff ? 2 : 1;
}

Referenced by analyze_linebreaks(), analyze_script(), fallback_font_get_supported_length(), and fallback_map_characters().

text_source_get_next_u32_char()

static BOOL text_source_get_next_u32_char ( struct text_source_context *  context )

static

Definition at line 432 of file analyzer.c.

{
    if (context->consumed == context->length)
    {
        context->ch = 0;
        context->end = TRUE;
    }
    else if (context->cursor < context->chunk_length)
    {
        text_source_get_u32_char(context);
    }
    else
    {
        text_source_read_more(context);
        /* Normal end-of-text condition. */
        if (!context->text || !context->chunk_length)
            context->end = TRUE;
        else
            text_source_get_u32_char(context);
    }
 
    return context->end;
}

Referenced by analyze_linebreaks(), analyze_script(), dwritetextanalyzer_AnalyzeBidi(), fallback_font_get_supported_length(), and fallback_map_characters().

text_source_get_u32_char()

static void text_source_get_u32_char ( struct text_source_context *  context )

static

Definition at line 397 of file analyzer.c.

{
    const WCHAR *text;
    UINT32 available;
 
    /* Make sure to have full pair of surrogates */
    text_source_read_more(context);
 
    available = context->chunk_length - context->cursor;
    text = context->text + context->cursor;
 
    if (available > 1 && IS_HIGH_SURROGATE(*text) && IS_LOW_SURROGATE(*(text + 1)))
    {
        context->cursor += 2;
        context->consumed += 2;
        context->ch = 0x10000 + ((*text - 0xd800) << 10) + *(text + 1) - 0xdc00;
        return;
    }
 
    context->cursor++;
    context->consumed++;
    context->ch = *text;
}

Referenced by text_source_get_next_u32_char().

text_source_read_more()

static void text_source_read_more ( struct text_source_context *  context )

static

Definition at line 384 of file analyzer.c.

{
    if ((context->chunk_length - context->cursor) > 1) return;
 
    context->position += context->cursor;
    context->cursor = 0;
    if (FAILED(context->status = IDWriteTextAnalysisSource_GetTextAtPosition(context->source, context->position,
            &context->text, &context->chunk_length)))
    {
        context->end = TRUE;
    }
}

Referenced by text_source_get_next_u32_char(), and text_source_get_u32_char().

unsafe_impl_from_IDWriteNumberSubstitution()

struct dwrite_numbersubstitution * unsafe_impl_from_IDWriteNumberSubstitution ( IDWriteNumberSubstitution *  iface )

static

Definition at line 2298 of file analyzer.c.

{
    if (!iface || iface->lpVtbl != &numbersubstitutionvtbl)
        return NULL;
    return CONTAINING_RECORD(iface, struct dwrite_numbersubstitution, IDWriteNumberSubstitution_iface);
}

Referenced by get_number_substitutes().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dwrite

)

Variable Documentation

bidi_direction_table

const unsigned short bidi_direction_table[]

extern

Definition at line 6 of file direction.c.

Referenced by get_char_bidi_class().

customfontfallbackvtbl

const IDWriteFontFallback1Vtbl customfontfallbackvtbl

static

Initial value:

=
{
    fontfallback_QueryInterface,
    customfontfallback_AddRef,
    customfontfallback_Release,
    fontfallback_MapCharacters,
    fontfallback1_MapCharacters,
}

Definition at line 2611 of file analyzer.c.

Referenced by fallbackbuilder_create_fallback().

dwritescripts_properties

const struct dwritescript_properties dwritescripts_properties[Script_LastId+1]

static

Definition at line 48 of file analyzer.c.

Referenced by debugstr_sa_script(), dwritetextanalyzer1_GetScriptProperties(), dwritetextanalyzer2_CheckTypographicFeature(), dwritetextanalyzer2_GetTypographicFeatures(), dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(), dwritetextanalyzer_GetGlyphPlacements(), dwritetextanalyzer_GetGlyphs(), and is_char_from_simple_script().

fontfallbackbuildervtbl

const IDWriteFontFallbackBuilderVtbl fontfallbackbuildervtbl

static

Initial value:

=
{
    fontfallbackbuilder_QueryInterface,
    fontfallbackbuilder_AddRef,
    fontfallbackbuilder_Release,
    fontfallbackbuilder_AddMapping,
    fontfallbackbuilder_AddMappings,
    fontfallbackbuilder_CreateFontFallback,
}

Definition at line 2899 of file analyzer.c.

Referenced by create_fontfallback_builder_internal().

fontfallbackvtbl

const IDWriteFontFallback1Vtbl fontfallbackvtbl

static

Initial value:

=
{
    fontfallback_QueryInterface,
    fontfallback_AddRef,
    fontfallback_Release,
    fontfallback_MapCharacters,
    fontfallback1_MapCharacters,
}

Definition at line 2566 of file analyzer.c.

Referenced by create_system_fontfallback().

init_system_fallback_once

INIT_ONCE init_system_fallback_once = INIT_ONCE_STATIC_INIT

static

Definition at line 2981 of file analyzer.c.

Referenced by create_system_fontfallback().

numbersubstitutionvtbl

const IDWriteNumberSubstitutionVtbl numbersubstitutionvtbl

static

Initial value:

=
{
    dwritenumbersubstitution_QueryInterface,
    dwritenumbersubstitution_AddRef,
    dwritenumbersubstitution_Release
}

Definition at line 2291 of file analyzer.c.

Referenced by create_numbersubstitution(), and unsafe_impl_from_IDWriteNumberSubstitution().

system_fallback

struct fallback_data system_fallback

static

Initial value:

=
{
    .locales = LIST_INIT(system_fallback.locales),
}

Definition at line 554 of file analyzer.c.

Referenced by dwrite_system_fallback_initonce(), fallback_map_characters(), layout_resolve_fonts(), and release_system_fallback_data().

system_fallback_config

const struct fallback_description system_fallback_config[]

static

Referenced by dwrite_system_fallback_initonce().

textanalyzer

IDWriteTextAnalyzer2 textanalyzer = { &textanalyzervtbl }

static

Definition at line 2239 of file analyzer.c.

Referenced by get_text_analyzer().

textanalyzervtbl

const IDWriteTextAnalyzer2Vtbl textanalyzervtbl

static

Initial value:

=
{
    dwritetextanalyzer_QueryInterface,
    dwritetextanalyzer_AddRef,
    dwritetextanalyzer_Release,
    dwritetextanalyzer_AnalyzeScript,
    dwritetextanalyzer_AnalyzeBidi,
    dwritetextanalyzer_AnalyzeNumberSubstitution,
    dwritetextanalyzer_AnalyzeLineBreakpoints,
    dwritetextanalyzer_GetGlyphs,
    dwritetextanalyzer_GetGlyphPlacements,
    dwritetextanalyzer_GetGdiCompatibleGlyphPlacements,
    dwritetextanalyzer1_ApplyCharacterSpacing,
    dwritetextanalyzer1_GetBaseline,
    dwritetextanalyzer1_AnalyzeVerticalGlyphOrientation,
    dwritetextanalyzer1_GetGlyphOrientationTransform,
    dwritetextanalyzer1_GetScriptProperties,
    dwritetextanalyzer1_GetTextComplexity,
    dwritetextanalyzer1_GetJustificationOpportunities,
    dwritetextanalyzer1_JustifyGlyphAdvances,
    dwritetextanalyzer1_GetJustifiedGlyphs,
    dwritetextanalyzer2_GetGlyphOrientationTransform,
    dwritetextanalyzer2_GetTypographicFeatures,
    dwritetextanalyzer2_CheckTypographicFeature
}

Definition at line 2213 of file analyzer.c.

wine_linebreak_table

const unsigned short wine_linebreak_table[]

extern

Definition at line 7 of file linebreak.c.

Referenced by analyze_linebreaks(), and lb_is_newline_char().

wine_scripts_table

const unsigned short wine_scripts_table[]

extern

Definition at line 7 of file scripts.c.

Referenced by get_char_script().