analyzer.c File Reference

#include <assert.h>
#include <stdio.h>
#include <limits.h>
#include <math.h>
#include "initguid.h"
#include "windows.h"
#include "winternl.h"
#include "dwrite_3.h"
#include "usp10.h"
#include "wine/test.h"

Include dependency graph for analyzer.c:

Go to the source code of this file.

Classes
struct	ot_gdef_classdef_format1
struct	ot_gdef_class_range
struct	ot_gdef_classdef_format2
struct	script_analysis
struct	call_entry
struct	testcontext
struct	call_sequence
struct	testanalysissource
struct	sa_test
struct	linebreaks_test
struct	textcomplexity_test
struct	dwrite_fonttable
struct	spacing_test
struct	orientation_transf_test
struct	bidi_test

Macros
#define	COBJMACROS
#define	LRE   0x202a
#define	RLE   0x202b
#define	PDF   0x202c
#define	LRO   0x202d
#define	RLO   0x202e
#define	LRI   0x2066
#define	RLI   0x2067
#define	FSI   0x2068
#define	PDI   0x2069
#define	MS_GDEF_TAG   DWRITE_MAKE_OPENTYPE_TAG('G','D','E','F')
#define	GET_BE_WORD(x)   RtlUshortByteSwap(x)
#define	GET_BE_DWORD(x)   RtlUlongByteSwap(x)
#define	GET_LE_WORD(x)   (x)
#define	GET_LE_DWORD(x)   (x)
#define	NUM_CALL_SEQUENCES   1
#define	ANALYZER_ID   0
#define	ok_sequence(seq, index, exp, contx, todo)    ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)
#define	BREAKPOINT_COUNT   20
#define	BIDI_LEVELS_COUNT   10
#define	DELETE_FONTFILE(filename)   _delete_testfontfile(filename, __LINE__)
#define	P_S   { 0 }
#define	P_Z   { 0, 0, 0, 1, 0 }
#define	P_D   { 0, 0, 1, 0, 0 }
#define	P_D_Z   { 0, 0, 1, 1, 0 }

Enumerations
enum	analysis_kind { ScriptAnalysis , LastKind }
enum	ot_gdef_class {   GDEF_CLASS_UNCLASSIFIED = 0 , GDEF_CLASS_BASE = 1 , GDEF_CLASS_LIGATURE = 2 , GDEF_CLASS_MARK = 3 ,   GDEF_CLASS_COMPONENT = 4 , GDEF_CLASS_MAX = GDEF_CLASS_COMPONENT , GDEF_CLASS_UNCLASSIFIED = 0 , GDEF_CLASS_BASE = 1 ,   GDEF_CLASS_LIGATURE = 2 , GDEF_CLASS_MARK = 3 , GDEF_CLASS_COMPONENT = 4 , GDEF_CLASS_MAX = GDEF_CLASS_COMPONENT }
enum	script_id { Script_Unknown = 0 , Script_Arabic = 3 , Script_Latin = 49 }

Functions
static void *	create_text_analyzer (REFIID riid)
static const char *	get_analysis_kind_name (enum analysis_kind kind)
static void	add_call (struct call_sequence **seq, int sequence_index, const struct call_entry *call)
static void	flush_sequence (struct call_sequence **seg, int sequence_index)
static void	init_call_sequences (struct call_sequence **seq, int n)
static void	test_uint (UINT32 actual, UINT32 expected, const char *name, const struct testcontext *ctxt)
static void	ok_sequence_ (struct call_sequence **seq, int sequence_index, const struct call_entry *expected, const char *context, BOOL todo, const char *file, int line)
static HRESULT WINAPI	analysissink_QueryInterface (IDWriteTextAnalysisSink *iface, REFIID riid, void **obj)
static ULONG WINAPI	analysissink_AddRef (IDWriteTextAnalysisSink *iface)
static ULONG WINAPI	analysissink_Release (IDWriteTextAnalysisSink *iface)
static HRESULT WINAPI	analysissink_SetScriptAnalysis (IDWriteTextAnalysisSink *iface, UINT32 position, UINT32 length, DWRITE_SCRIPT_ANALYSIS const *sa)
static HRESULT WINAPI	analysissink_SetScriptAnalysis2 (IDWriteTextAnalysisSink *iface, UINT32 position, UINT32 length, DWRITE_SCRIPT_ANALYSIS const *sa)
static HRESULT WINAPI	analysissink_SetLineBreakpoints (IDWriteTextAnalysisSink *iface, UINT32 position, UINT32 length, DWRITE_LINE_BREAKPOINT const *breakpoints)
static HRESULT WINAPI	analysissink_SetBidiLevel (IDWriteTextAnalysisSink *iface, UINT32 position, UINT32 length, UINT8 explicitLevel, UINT8 resolvedLevel)
static HRESULT WINAPI	analysissink_SetNumberSubstitution (IDWriteTextAnalysisSink *iface, UINT32 position, UINT32 length, IDWriteNumberSubstitution *substitution)
static HRESULT WINAPI	analysissource_QueryInterface (IDWriteTextAnalysisSource *iface, REFIID riid, void **obj)
static ULONG WINAPI	analysissource_AddRef (IDWriteTextAnalysisSource *iface)
static ULONG WINAPI	analysissource_Release (IDWriteTextAnalysisSource *iface)
static void	init_textsource (struct testanalysissource *source, const WCHAR *text, INT text_length, DWRITE_READING_DIRECTION direction)
static struct testanalysissource *	impl_from_IDWriteTextAnalysisSource (IDWriteTextAnalysisSource *iface)
static HRESULT WINAPI	analysissource_GetTextAtPosition (IDWriteTextAnalysisSource *iface, UINT32 position, WCHAR const **text, UINT32 *text_len)
static HRESULT WINAPI	analysissource_GetTextBeforePosition (IDWriteTextAnalysisSource *iface, UINT32 position, WCHAR const **text, UINT32 *text_len)
static DWRITE_READING_DIRECTION WINAPI	analysissource_GetParagraphReadingDirection (IDWriteTextAnalysisSource *iface)
static HRESULT WINAPI	analysissource_GetLocaleName (IDWriteTextAnalysisSource *iface, UINT32 position, UINT32 *text_len, WCHAR const **locale)
static HRESULT WINAPI	analysissource_GetNumberSubstitution (IDWriteTextAnalysisSource *iface, UINT32 position, UINT32 *text_len, IDWriteNumberSubstitution **substitution)
static IDWriteFontFace *	create_fontface (void)
static WCHAR *	create_testfontfile (const WCHAR *filename)
static void	_delete_testfontfile (const WCHAR *filename, int line)
static IDWriteFontFace *	create_testfontface (const WCHAR *filename)
static void	init_expected_sa (struct call_sequence **seq, const struct sa_test *test)
static void	get_script_analysis (const WCHAR *str, DWRITE_SCRIPT_ANALYSIS *sa)
static void	test_AnalyzeScript (void)
static void	compare_breakpoints (const struct linebreaks_test *test, DWRITE_LINE_BREAKPOINT *actual)
static void	test_AnalyzeLineBreakpoints (void)
static void	test_GetScriptProperties (void)
static void	test_GetTextComplexity (void)
static void	test_numbersubstitution (void)
static void	get_fontface_glyphs (IDWriteFontFace *fontface, const WCHAR *str, UINT16 *glyphs)
static void	get_fontface_advances (IDWriteFontFace *fontface, FLOAT emsize, const UINT16 *glyphs, FLOAT *advances, UINT32 count)
static const void *	table_read_ensure (const struct dwrite_fonttable *table, unsigned int offset, unsigned int size)
static WORD	table_read_be_word (const struct dwrite_fonttable *table, unsigned int offset)
static int	gdef_class_compare_format2 (const void *g, const void *r)
static unsigned int	get_glyph_class (const struct dwrite_fonttable *table, UINT16 glyph)
static void	get_enus_string (IDWriteLocalizedStrings *strings, WCHAR *buff, unsigned int size)
static void	test_glyph_props (IDWriteTextAnalyzer *analyzer, const WCHAR *family, const WCHAR *face, IDWriteFontFace *fontface)
static void	test_GetGlyphs (void)
static void	test_GetTypographicFeatures (void)
static void	test_GetGlyphPlacements (void)
static void	test_ApplyCharacterSpacing (void)
static const char *	dbgstr_matrix (const DWRITE_MATRIX *m)
static void	test_GetGlyphOrientationTransform (void)
static void	test_GetBaseline (void)
static BOOL	float_eq (FLOAT left, FLOAT right)
static void	test_GetGdiCompatibleGlyphPlacements (void)
static void	compare_bidi_levels (unsigned int seq, const struct bidi_test *test, UINT32 len, UINT8 *explicit, UINT8 *resolved)
static void	test_AnalyzeBidi (void)
static void	test_glyph_justification_property (void)
	START_TEST (analyzer)

Variables
static IDWriteFactory *	factory
static struct call_sequence *	sequences [NUM_CALL_SEQUENCES]
static struct call_sequence *	expected_seq [1]
static DWRITE_SCRIPT_ANALYSIS	g_sa
static DWRITE_LINE_BREAKPOINT	g_actual_bp [BREAKPOINT_COUNT]
static UINT8	g_explicit_levels [BIDI_LEVELS_COUNT]
static UINT8	g_resolved_levels [BIDI_LEVELS_COUNT]
static IDWriteTextAnalysisSinkVtbl	analysissinkvtbl
static IDWriteTextAnalysisSinkVtbl	analysissinkvtbl2
static IDWriteTextAnalysisSink	analysissink = { &analysissinkvtbl }
static IDWriteTextAnalysisSink	analysissink2 = { &analysissinkvtbl2 }
static IDWriteTextAnalysisSourceVtbl	analysissourcevtbl
static struct testanalysissource	analysissource = { { &analysissourcevtbl } }
static struct sa_test	sa_tests []
static const struct linebreaks_test	linebreaks_tests []
static const struct textcomplexity_test	textcomplexity_tests []
static const struct spacing_test	spacing_tests []
static const struct orientation_transf_test	ot_tests []
static const struct bidi_test	bidi_tests []

Macro Definition Documentation

ANALYZER_ID

#define ANALYZER_ID   0

Definition at line 141 of file analyzer.c.

BIDI_LEVELS_COUNT

#define BIDI_LEVELS_COUNT   10

Definition at line 345 of file analyzer.c.

BREAKPOINT_COUNT

#define BREAKPOINT_COUNT   20

Definition at line 329 of file analyzer.c.

COBJMACROS

#define COBJMACROS

Definition at line 21 of file analyzer.c.

DELETE_FONTFILE

#define DELETE_FONTFILE

(

filename

)

_delete_testfontfile(filename, __LINE__)

Definition at line 551 of file analyzer.c.

FSI

#define FSI   0x2068

Definition at line 59 of file analyzer.c.

GET_BE_DWORD

#define GET_BE_DWORD

(

x

)

RtlUlongByteSwap(x)

Definition at line 71 of file analyzer.c.

GET_BE_WORD

#define GET_BE_WORD

(

x

)

RtlUshortByteSwap(x)

Definition at line 70 of file analyzer.c.

GET_LE_DWORD

#define GET_LE_DWORD

(

x

)

(x)

Definition at line 73 of file analyzer.c.

GET_LE_WORD

#define GET_LE_WORD

(

x

)

(x)

Definition at line 72 of file analyzer.c.

LRE

#define LRE   0x202a

Definition at line 52 of file analyzer.c.

LRI

#define LRI   0x2066

Definition at line 57 of file analyzer.c.

LRO

#define LRO   0x202d

Definition at line 55 of file analyzer.c.

MS_GDEF_TAG

#define MS_GDEF_TAG   DWRITE_MAKE_OPENTYPE_TAG('G','D','E','F')

Definition at line 62 of file analyzer.c.

NUM_CALL_SEQUENCES

#define NUM_CALL_SEQUENCES   1

Definition at line 140 of file analyzer.c.

ok_sequence

#define ok_sequence	(		seq,
			index,
			exp,
			contx,
			todo
	)		ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)

Definition at line 284 of file analyzer.c.

P_D

#define P_D   { 0, 0, 1, 0, 0 }

P_D_Z

#define P_D_Z   { 0, 0, 1, 1, 0 }

P_S

#define P_S   { 0 }

P_Z

#define P_Z   { 0, 0, 0, 1, 0 }

PDF

#define PDF   0x202c

Definition at line 54 of file analyzer.c.

PDI

#define PDI   0x2069

Definition at line 60 of file analyzer.c.

RLE

#define RLE   0x202b

Definition at line 53 of file analyzer.c.

RLI

#define RLI   0x2067

Definition at line 58 of file analyzer.c.

RLO

#define RLO   0x202e

Definition at line 56 of file analyzer.c.

Enumeration Type Documentation

analysis_kind

enum analysis_kind

Enumerator
ScriptAnalysis
LastKind

Definition at line 98 of file analyzer.c.

                   {
    ScriptAnalysis,
    LastKind
};

ot_gdef_class

enum ot_gdef_class

Enumerator
GDEF_CLASS_UNCLASSIFIED
GDEF_CLASS_BASE
GDEF_CLASS_LIGATURE
GDEF_CLASS_MARK
GDEF_CLASS_COMPONENT
GDEF_CLASS_MAX
GDEF_CLASS_UNCLASSIFIED
GDEF_CLASS_BASE
GDEF_CLASS_LIGATURE
GDEF_CLASS_MARK
GDEF_CLASS_COMPONENT
GDEF_CLASS_MAX

Definition at line 1459 of file analyzer.c.

{
    GDEF_CLASS_UNCLASSIFIED = 0,
    GDEF_CLASS_BASE = 1,
    GDEF_CLASS_LIGATURE = 2,
    GDEF_CLASS_MARK = 3,
    GDEF_CLASS_COMPONENT = 4,
    GDEF_CLASS_MAX = GDEF_CLASS_COMPONENT,
};

script_id

enum script_id

Enumerator
Script_Unknown
Script_Arabic
Script_Latin

Definition at line 2852 of file analyzer.c.

{
    Script_Unknown = 0,
    Script_Arabic = 3,
    Script_Latin = 49,
};

Function Documentation

_delete_testfontfile()

static void _delete_testfontfile ( const WCHAR *  filename, int  line  )

static

Definition at line 552 of file analyzer.c.

{
    BOOL ret = DeleteFileW(filename);
    ok_(__FILE__,line)(ret, "failed to delete file %s, error %ld\n", wine_dbgstr_w(filename), GetLastError());
}

add_call()

static void add_call ( struct call_sequence **  seq, int  sequence_index, const struct call_entry *  call  )

static

Definition at line 145 of file analyzer.c.

{
    struct call_sequence *call_seq = seq[sequence_index];
 
    if (!call_seq->sequence)
    {
        call_seq->size = 10;
        call_seq->sequence = malloc(call_seq->size * sizeof(*call_seq->sequence));
    }
 
    if (call_seq->count == call_seq->size)
    {
        call_seq->size *= 2;
        call_seq->sequence = realloc(call_seq->sequence, call_seq->size * sizeof(*call_seq->sequence));
    }
 
    assert(call_seq->sequence);
 
    call_seq->sequence[call_seq->count++] = *call;
}

Referenced by analysissink_SetScriptAnalysis(), init_expected_sa(), and ok_sequence_().

analysissink_AddRef()

static ULONG WINAPI analysissink_AddRef ( IDWriteTextAnalysisSink *  iface )

static

Definition at line 299 of file analyzer.c.

{
    return 2;
}

analysissink_QueryInterface()

static HRESULT WINAPI analysissink_QueryInterface ( IDWriteTextAnalysisSink *  iface, REFIID  riid, void **  obj  )

static

Definition at line 287 of file analyzer.c.

{
    if (IsEqualIID(riid, &IID_IDWriteTextAnalysisSink) || IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

analysissink_Release()

static ULONG WINAPI analysissink_Release ( IDWriteTextAnalysisSink *  iface )

static

Definition at line 304 of file analyzer.c.

{
    return 1;
}

analysissink_SetBidiLevel()

static HRESULT WINAPI analysissink_SetBidiLevel ( IDWriteTextAnalysisSink *  iface, UINT32  position, UINT32  length, UINT8  explicitLevel, UINT8  resolvedLevel  )

static

Definition at line 348 of file analyzer.c.

{
    if (position + length > BIDI_LEVELS_COUNT) {
        ok(0, "SetBidiLevel: reported pos=%u, len=%u overflows expected length %d\n", position, length, BIDI_LEVELS_COUNT);
        return E_FAIL;
    }
    memset(g_explicit_levels + position, explicitLevel, length);
    memset(g_resolved_levels + position, resolvedLevel, length);
    return S_OK;
}

analysissink_SetLineBreakpoints()

static HRESULT WINAPI analysissink_SetLineBreakpoints ( IDWriteTextAnalysisSink *  iface, UINT32  position, UINT32  length, DWRITE_LINE_BREAKPOINT const *  breakpoints  )

static

Definition at line 332 of file analyzer.c.

{
    if (position + length > BREAKPOINT_COUNT) {
        ok(0, "SetLineBreakpoints: reported pos=%u, len=%u overflows expected length %d\n", position, length, BREAKPOINT_COUNT);
        return E_FAIL;
    }
    memcpy(&g_actual_bp[position], breakpoints, length*sizeof(DWRITE_LINE_BREAKPOINT));
    return S_OK;
}

analysissink_SetNumberSubstitution()

static HRESULT WINAPI analysissink_SetNumberSubstitution ( IDWriteTextAnalysisSink *  iface, UINT32  position, UINT32  length, IDWriteNumberSubstitution *  substitution  )

static

Definition at line 363 of file analyzer.c.

{
    ok(0, "unexpected\n");
    return E_NOTIMPL;
}

analysissink_SetScriptAnalysis()

static HRESULT WINAPI analysissink_SetScriptAnalysis ( IDWriteTextAnalysisSink *  iface, UINT32  position, UINT32  length, DWRITE_SCRIPT_ANALYSIS const *  sa  )

static

Definition at line 309 of file analyzer.c.

{
    struct call_entry entry;
    entry.kind = ScriptAnalysis;
    entry.sa.pos = position;
    entry.sa.len = length;
    entry.sa.shapes = sa->shapes;
    add_call(sequences, ANALYZER_ID, &entry);
    return S_OK;
}

analysissink_SetScriptAnalysis2()

static HRESULT WINAPI analysissink_SetScriptAnalysis2 ( IDWriteTextAnalysisSink *  iface, UINT32  position, UINT32  length, DWRITE_SCRIPT_ANALYSIS const *  sa  )

static

Definition at line 322 of file analyzer.c.

{
    g_sa = *sa;
    return S_OK;
}

analysissource_AddRef()

static ULONG WINAPI analysissource_AddRef ( IDWriteTextAnalysisSource *  iface )

static

Definition at line 402 of file analyzer.c.

{
    ok(0, "AddRef not expected\n");
    return 2;
}

analysissource_GetLocaleName()

static HRESULT WINAPI analysissource_GetLocaleName ( IDWriteTextAnalysisSource *  iface, UINT32  position, UINT32 *  text_len, WCHAR const **  locale  )

static

Definition at line 468 of file analyzer.c.

{
    *locale = NULL;
    *text_len = 0;
    return S_OK;
}

analysissource_GetNumberSubstitution()

static HRESULT WINAPI analysissource_GetNumberSubstitution ( IDWriteTextAnalysisSource *  iface, UINT32  position, UINT32 *  text_len, IDWriteNumberSubstitution **  substitution  )

static

Definition at line 476 of file analyzer.c.

{
    ok(0, "unexpected\n");
    return E_NOTIMPL;
}

analysissource_GetParagraphReadingDirection()

static DWRITE_READING_DIRECTION WINAPI analysissource_GetParagraphReadingDirection ( IDWriteTextAnalysisSource *  iface )

static

Definition at line 461 of file analyzer.c.

{
    struct testanalysissource *source = impl_from_IDWriteTextAnalysisSource(iface);
    return source->direction;
}

analysissource_GetTextAtPosition()

static HRESULT WINAPI analysissource_GetTextAtPosition ( IDWriteTextAnalysisSource *  iface, UINT32  position, WCHAR const **  text, UINT32 *  text_len  )

static

Definition at line 435 of file analyzer.c.

{
    struct testanalysissource *source = impl_from_IDWriteTextAnalysisSource(iface);
 
    if (position >= source->text_length)
    {
        *text = NULL;
        *text_len = 0;
    }
    else
    {
        *text = source->text + position;
        *text_len = source->text_length - position;
    }
 
    return S_OK;
}

analysissource_GetTextBeforePosition()

static HRESULT WINAPI analysissource_GetTextBeforePosition ( IDWriteTextAnalysisSource *  iface, UINT32  position, WCHAR const **  text, UINT32 *  text_len  )

static

Definition at line 454 of file analyzer.c.

{
    ok(0, "unexpected\n");
    return E_NOTIMPL;
}

analysissource_QueryInterface()

static HRESULT WINAPI analysissource_QueryInterface ( IDWriteTextAnalysisSource *  iface, REFIID  riid, void **  obj  )

static

Definition at line 395 of file analyzer.c.

{
    ok(0, "QueryInterface not expected\n");
    return E_NOTIMPL;
}

analysissource_Release()

static ULONG WINAPI analysissource_Release ( IDWriteTextAnalysisSource *  iface )

static

Definition at line 408 of file analyzer.c.

{
    ok(0, "Release not expected\n");
    return 1;
}

compare_bidi_levels()

static void compare_bidi_levels ( unsigned int  seq, const struct bidi_test *  test, UINT32  len, UINT8 *  explicit, UINT8 *  resolved  )

static

Definition at line 2759 of file analyzer.c.

{
    unsigned int i, failcount = 0;
    BOOL match;
 
    match = !memcmp(explicit, test->explicit, len);
    if (!match) {
        if (test->todo) {
            failcount++;
        todo_wine
            ok(0, "test %u: %s wrong explicit levels:\n", seq, wine_dbgstr_w(test->text));
        }
        else
            ok(0, "test %u: %s wrong explicit levels:\n", seq, wine_dbgstr_w(test->text));
 
        for (i = 0; i < len; i++) {
            if (test->explicit[i] != explicit[i]) {
               if (test->todo) {
                   failcount++;
               todo_wine
                   ok(0, "\tat %u, explicit level %u, expected %u\n", i, explicit[i], test->explicit[i]);
               }
               else
                   ok(0, "\tat %u, explicit level %u, expected %u\n", i, explicit[i], test->explicit[i]);
            }
        }
    }
 
    match = !memcmp(resolved, test->resolved, len);
    if (!match) {
        if (test->todo) {
            failcount++;
        todo_wine
            ok(0, "test %u: %s wrong resolved levels:\n", seq, wine_dbgstr_w(test->text));
        }
        else
            ok(0, "test %u: %s wrong resolved levels:\n", seq, wine_dbgstr_w(test->text));
 
        for (i = 0; i < len; i++) {
            if (test->resolved[i] != resolved[i]) {
               if (test->todo) {
                   failcount++;
               todo_wine
                   ok(0, "\tat %u, resolved level %u, expected %u\n", i, resolved[i], test->resolved[i]);
               }
               else
                   ok(0, "\tat %u, resolved level %u, expected %u\n", i, resolved[i], test->resolved[i]);
            }
        }
    }
 
    todo_wine_if(test->todo && failcount == 0)
        ok(1, "test %u: marked as \"todo_wine\" but succeeds\n", seq);
}

Referenced by test_AnalyzeBidi().

compare_breakpoints()

static void compare_breakpoints ( const struct linebreaks_test *  test, DWRITE_LINE_BREAKPOINT *  actual  )

static

Definition at line 1191 of file analyzer.c.

{
    static const char *conditions[] = {"N","CB","NB","B"};
    const WCHAR *text = test->text;
    int cmp = memcmp(test->bp, actual, sizeof(*actual)*BREAKPOINT_COUNT);
    ok(!cmp, "%s: got wrong breakpoint data\n", wine_dbgstr_w(test->text));
    if (cmp) {
        int i = 0;
        while (*text) {
            ok(!memcmp(&test->bp[i], &actual[i], sizeof(*actual)),
                "%s: got [%s, %s] (%s, %s), expected [%s, %s] (%s, %s)\n",
                wine_dbgstr_wn(&test->text[i], 1),
                conditions[g_actual_bp[i].breakConditionBefore],
                conditions[g_actual_bp[i].breakConditionAfter],
                g_actual_bp[i].isWhitespace ? "WS"  : "0",
                g_actual_bp[i].isSoftHyphen ? "SHY" : "0",
                conditions[test->bp[i].breakConditionBefore],
                conditions[test->bp[i].breakConditionAfter],
                test->bp[i].isWhitespace ? "WS"  : "0",
                test->bp[i].isSoftHyphen ? "SHY" : "0");
            if (g_actual_bp[i].isSoftHyphen)
                ok(!g_actual_bp[i].isWhitespace, "%s: soft hyphen marked as a whitespace\n",
                    wine_dbgstr_wn(&test->text[i], 1));
            text++;
            i++;
        }
    }
}

Referenced by test_AnalyzeLineBreakpoints().

create_fontface()

static IDWriteFontFace * create_fontface ( void  )

static

Definition at line 496 of file analyzer.c.

{
    IDWriteGdiInterop *interop;
    IDWriteFontFace *fontface;
    IDWriteFont *font;
    LOGFONTW logfont;
    HRESULT hr;
 
    hr = IDWriteFactory_GetGdiInterop(factory, &interop);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    memset(&logfont, 0, sizeof(logfont));
    logfont.lfHeight = 12;
    logfont.lfWidth  = 12;
    logfont.lfWeight = FW_NORMAL;
    logfont.lfItalic = 1;
    lstrcpyW(logfont.lfFaceName, L"Tahoma");
 
    hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDWriteFont_CreateFontFace(font, &fontface);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    IDWriteFont_Release(font);
    IDWriteGdiInterop_Release(interop);
 
    return fontface;
}

Referenced by dwritefactory_CreateFontFace(), get_fontface_from_font(), test_ComputeGlyphOrigins(), test_CreateAlphaTexture(), test_CreateBitmapRenderTarget(), test_CreateGlyphRunAnalysis(), test_font_resource(), test_GetAlphaBlendParams(), test_GetBaseline(), test_GetGdiCompatibleGlyphPlacements(), test_GetGlyphImageFormats(), test_GetGlyphRunOutline(), test_GetGlyphs(), test_GetPaletteEntries(), test_GetRecommendedRenderingMode(), test_GetTextComplexity(), test_GetTypographicFeatures(), test_GetVerticalGlyphVariants(), test_glyph_justification_property(), test_HasKerningPairs(), test_HasVerticalGlyphVariants(), test_inmemory_file_loader(), and test_TranslateColorGlyphRun().

create_testfontface()

static IDWriteFontFace * create_testfontface ( const WCHAR *  filename )

static

Definition at line 558 of file analyzer.c.

{
    IDWriteFontFace *face;
    IDWriteFontFile *file;
    HRESULT hr;
 
    hr = IDWriteFactory_CreateFontFileReference(factory, filename, NULL, &file);
    ok(hr == S_OK, "Unexpected hr %#lx.\n",hr);
 
    hr = IDWriteFactory_CreateFontFace(factory, DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &file, 0,
        DWRITE_FONT_SIMULATIONS_NONE, &face);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IDWriteFontFile_Release(file);
 
    return face;
}

Referenced by test_GetGlyphPlacements().

create_testfontfile()

static WCHAR * create_testfontfile ( const WCHAR *  filename )

static

Definition at line 526 of file analyzer.c.

{
    static WCHAR pathW[MAX_PATH];
    DWORD written;
    HANDLE file;
    HRSRC res;
    void *ptr;
 
    GetTempPathW(ARRAY_SIZE(pathW), pathW);
    lstrcatW(pathW, filename);
 
    file = CreateFileW(pathW, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
    ok(file != INVALID_HANDLE_VALUE, "file creation failed, at %s, error %ld\n", wine_dbgstr_w(pathW),
        GetLastError());
 
    res = FindResourceA(GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(1), (LPCSTR)RT_RCDATA);
    ok(res != 0, "couldn't find resource\n");
    ptr = LockResource(LoadResource(GetModuleHandleA(NULL), res));
    WriteFile(file, ptr, SizeofResource(GetModuleHandleA(NULL), res), &written, NULL);
    ok(written == SizeofResource(GetModuleHandleA(NULL), res), "couldn't write resource\n");
    CloseHandle(file);
 
    return pathW;
}

Referenced by test_GetGlyphPlacements().

create_text_analyzer()

static void * create_text_analyzer ( REFIID  riid )

static

Definition at line 38 of file analyzer.c.

{
    IDWriteTextAnalyzer *analyzer;
    void *ret = NULL;
 
    if (SUCCEEDED(IDWriteFactory_CreateTextAnalyzer(factory, &analyzer)))
    {
        IDWriteTextAnalyzer_QueryInterface(analyzer, riid, &ret);
        IDWriteTextAnalyzer_Release(analyzer);
    }
 
    return ret;
}

Referenced by get_script_analysis(), test_AnalyzeBidi(), test_AnalyzeLineBreakpoints(), test_AnalyzeScript(), test_ApplyCharacterSpacing(), test_GetBaseline(), test_GetGdiCompatibleGlyphPlacements(), test_GetGlyphOrientationTransform(), test_GetGlyphPlacements(), test_GetGlyphs(), test_GetScriptProperties(), test_GetTextComplexity(), test_GetTypographicFeatures(), and test_glyph_justification_property().

dbgstr_matrix()

static const char * dbgstr_matrix ( const DWRITE_MATRIX *  m )

inlinestatic

Definition at line 2371 of file analyzer.c.

{
    static char buff[64];
    sprintf(buff, "{%.2f, %.2f, %.2f, %.2f, %.2f, %.2f}", m->m11, m->m12,
        m->m21, m->m22, m->dx, m->dy);
    return buff;
}

Referenced by test_GetGlyphOrientationTransform().

float_eq()

static BOOL float_eq ( FLOAT  left, FLOAT  right  )

inlinestatic

Definition at line 2560 of file analyzer.c.

{
    int x = *(int *)&left;
    int y = *(int *)&right;
 
    if (x < 0)
        x = INT_MIN - x;
    if (y < 0)
        y = INT_MIN - y;
 
    return abs(x - y) <= 8;
}

Referenced by test_GetGdiCompatibleGlyphPlacements().

flush_sequence()

static void flush_sequence ( struct call_sequence **  seg, int  sequence_index  )

inlinestatic

Definition at line 166 of file analyzer.c.

{
    struct call_sequence *call_seq = seg[sequence_index];
 
    free(call_seq->sequence);
    call_seq->sequence = NULL;
    call_seq->count = call_seq->size = 0;
}

gdef_class_compare_format2()

static int gdef_class_compare_format2 ( const void *  g, const void *  r  )

static

Definition at line 1490 of file analyzer.c.

{
    const struct ot_gdef_class_range *range = r;
    UINT16 glyph = *(UINT16 *)g;
 
    if (glyph < GET_BE_WORD(range->start_glyph))
        return -1;
    else if (glyph > GET_BE_WORD(range->end_glyph))
        return 1;
    else
        return 0;
}

Referenced by get_glyph_class().

get_analysis_kind_name()

static const char * get_analysis_kind_name ( enum analysis_kind  kind )

static

Definition at line 103 of file analyzer.c.

{
    switch (kind)
    {
    case ScriptAnalysis:
        return "ScriptAnalysis";
    default:
        return "unknown";
    }
}

Referenced by ok_sequence_(), and test_uint().

get_enus_string()

static void get_enus_string ( IDWriteLocalizedStrings *  strings, WCHAR *  buff, unsigned int  size  )

static

Definition at line 1549 of file analyzer.c.

{
    BOOL exists = FALSE;
    unsigned int index;
    HRESULT hr;
 
    hr = IDWriteLocalizedStrings_FindLocaleName(strings, L"en-us", &index, &exists);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    /* Not all fonts have an en-us name! */
    if (!exists)
        index = 0;
 
    hr = IDWriteLocalizedStrings_GetString(strings, index, buff, size);
    ok(hr == S_OK, "Failed to get name string, hr %#lx.\n", hr);
}

Referenced by test_GetGlyphs().

get_fontface_advances()

static void get_fontface_advances ( IDWriteFontFace *  fontface, FLOAT  emsize, const UINT16 *  glyphs, FLOAT *  advances, UINT32  count  )

static

Definition at line 1442 of file analyzer.c.

{
    DWRITE_FONT_METRICS fontmetrics;
    UINT32 i;
 
    IDWriteFontFace_GetMetrics(fontface, &fontmetrics);
    for (i = 0; i < count; i++) {
        DWRITE_GLYPH_METRICS metrics;
        HRESULT hr;
 
        hr = IDWriteFontFace_GetDesignGlyphMetrics(fontface, glyphs + i, 1, &metrics, FALSE);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        advances[i] = (FLOAT)metrics.advanceWidth * emsize / (FLOAT)fontmetrics.designUnitsPerEm;
    }
}

Referenced by test_GetGlyphs().

get_fontface_glyphs()

static void get_fontface_glyphs ( IDWriteFontFace *  fontface, const WCHAR *  str, UINT16 *  glyphs  )

static

Definition at line 1430 of file analyzer.c.

{
    while (*str) {
        UINT32 codepoint = *str;
        HRESULT hr;
 
        hr = IDWriteFontFace_GetGlyphIndices(fontface, &codepoint, 1, glyphs++);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        str++;
    }
}

Referenced by test_GetGlyphs().

get_glyph_class()

static unsigned int get_glyph_class ( const struct dwrite_fonttable *  table, UINT16  glyph  )

static

Definition at line 1503 of file analyzer.c.

{
    unsigned int glyph_class = GDEF_CLASS_UNCLASSIFIED, offset;
    WORD format, count;
 
    offset = table_read_be_word(table, 4);
 
    format = table_read_be_word(table, offset);
 
    if (format == 1)
    {
        const struct ot_gdef_classdef_format1 *format1;
 
        count = table_read_be_word(table, offset + FIELD_OFFSET(struct ot_gdef_classdef_format1, glyph_count));
        format1 = table_read_ensure(table, offset, FIELD_OFFSET(struct ot_gdef_classdef_format1, classes[count]));
        if (format1)
        {
            WORD start_glyph = GET_BE_WORD(format1->start_glyph);
            if (glyph >= start_glyph && (glyph - start_glyph) < count)
            {
                glyph_class = GET_BE_WORD(format1->classes[glyph - start_glyph]);
                if (glyph_class > GDEF_CLASS_MAX)
                     glyph_class = GDEF_CLASS_UNCLASSIFIED;
            }
        }
    }
    else if (format == 2)
    {
        const struct ot_gdef_classdef_format2 *format2;
 
        count = table_read_be_word(table, offset + FIELD_OFFSET(struct ot_gdef_classdef_format2, range_count));
        format2 = table_read_ensure(table, offset, FIELD_OFFSET(struct ot_gdef_classdef_format2, ranges[count]));
        if (format2)
        {
            const struct ot_gdef_class_range *range = bsearch(&glyph, format2->ranges, count,
                    sizeof(struct ot_gdef_class_range), gdef_class_compare_format2);
            glyph_class = range && glyph <= GET_BE_WORD(range->end_glyph) ?
                    GET_BE_WORD(range->glyph_class) : GDEF_CLASS_UNCLASSIFIED;
            if (glyph_class > GDEF_CLASS_MAX)
                 glyph_class = GDEF_CLASS_UNCLASSIFIED;
        }
    }
 
    return glyph_class;
}

Referenced by test_glyph_props().

get_script_analysis()

static void get_script_analysis ( const WCHAR *  str, DWRITE_SCRIPT_ANALYSIS *  sa  )

static

Definition at line 1085 of file analyzer.c.

{
    IDWriteTextAnalyzer *analyzer;
    HRESULT hr;
 
    init_textsource(&analysissource, str, -1, DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    hr = IDWriteTextAnalyzer_AnalyzeScript(analyzer, &analysissource.IDWriteTextAnalysisSource_iface, 0,
        lstrlenW(analysissource.text), &analysissink2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    *sa = g_sa;
 
    IDWriteTextAnalyzer_Release(analyzer);
}

Referenced by test_GetGlyphPlacements(), test_GetGlyphs(), and test_GetTypographicFeatures().

impl_from_IDWriteTextAnalysisSource()

static struct testanalysissource * impl_from_IDWriteTextAnalysisSource ( IDWriteTextAnalysisSource *  iface )

inlinestatic

Definition at line 430 of file analyzer.c.

{
    return CONTAINING_RECORD(iface, struct testanalysissource, IDWriteTextAnalysisSource_iface);
}

Referenced by analysissource_GetParagraphReadingDirection(), and analysissource_GetTextAtPosition().

init_call_sequences()

static void init_call_sequences ( struct call_sequence **  seq, int  n  )

static

Definition at line 175 of file analyzer.c.

{
    int i;
 
    for (i = 0; i < n; i++)
        seq[i] = calloc(1, sizeof(*seq[i]));
}

Referenced by START_TEST().

init_expected_sa()

static void init_expected_sa ( struct call_sequence **  seq, const struct sa_test *  test  )

static

Definition at line 1062 of file analyzer.c.

{
    static const struct call_entry end_of_sequence = { LastKind };
    int i;
 
    flush_sequence(seq, ANALYZER_ID);
 
    /* add expected calls */
    for (i = 0; i < test->item_count; i++)
    {
        struct call_entry call;
 
        call.kind = ScriptAnalysis;
        call.sa.pos = test->sa[i].pos;
        call.sa.len = test->sa[i].len;
        call.sa.shapes = test->sa[i].shapes;
        add_call(seq, 0, &call);
    }
 
    /* and stop marker */
    add_call(seq, 0, &end_of_sequence);
}

Referenced by test_AnalyzeScript().

init_textsource()

static void init_textsource ( struct testanalysissource *  source, const WCHAR *  text, INT  text_length, DWRITE_READING_DIRECTION  direction  )

static

Definition at line 422 of file analyzer.c.

{
    source->text = text;
    source->text_length = text_length == -1 ? lstrlenW(text) : text_length;
    source->direction = direction;
};

Referenced by get_script_analysis(), test_AnalyzeBidi(), test_AnalyzeLineBreakpoints(), and test_AnalyzeScript().

ok_sequence_()

static void ok_sequence_ ( struct call_sequence **  seq, int  sequence_index, const struct call_entry *  expected, const char *  context, BOOL  todo, const char *  file, int  line  )

static

Definition at line 195 of file analyzer.c.

{
    struct call_sequence *call_seq = seq[sequence_index];
    static const struct call_entry end_of_sequence = { LastKind };
    const struct call_entry *actual, *sequence;
    int failcount = 0;
    struct testcontext ctxt;
 
    add_call(seq, sequence_index, &end_of_sequence);
 
    sequence = call_seq->sequence;
    actual = sequence;
 
    ctxt.failcount = &failcount;
    ctxt.todo = todo;
    ctxt.file = file;
    ctxt.line = line;
 
    while (expected->kind != LastKind && actual->kind != LastKind)
    {
        if (expected->kind == actual->kind)
        {
            ctxt.kind = expected->kind;
 
            switch (actual->kind)
            {
            case ScriptAnalysis:
                test_uint(actual->sa.pos, expected->sa.pos, "position", &ctxt);
                test_uint(actual->sa.len, expected->sa.len, "length", &ctxt);
                test_uint(actual->sa.shapes, expected->sa.shapes, "shapes", &ctxt);
                break;
            default:
                ok(0, "%s: callback not handled, %s\n", context, get_analysis_kind_name(actual->kind));
            }
            expected++;
            actual++;
        }
        else if (todo)
        {
            failcount++;
            todo_wine
            {
                ok_(file, line) (0, "%s: call %s was expected, but got call %s instead\n",
                    context, get_analysis_kind_name(expected->kind), get_analysis_kind_name(actual->kind));
            }
 
            flush_sequence(seq, sequence_index);
            return;
        }
        else
        {
            ok_(file, line) (0, "%s: call %s was expected, but got call %s instead\n",
                context, get_analysis_kind_name(expected->kind), get_analysis_kind_name(actual->kind));
            expected++;
            actual++;
        }
    }
 
    if (todo)
    {
        todo_wine
        {
            if (expected->kind != LastKind || actual->kind != LastKind)
            {
                failcount++;
                ok_(file, line) (0, "%s: the call sequence is not complete: expected %s - actual %s\n",
                    context, get_analysis_kind_name(expected->kind), get_analysis_kind_name(actual->kind));
            }
        }
    }
    else if (expected->kind != LastKind || actual->kind != LastKind)
    {
        ok_(file, line) (0, "%s: the call sequence is not complete: expected %s - actual %s\n",
            context, get_analysis_kind_name(expected->kind), get_analysis_kind_name(actual->kind));
    }
 
    if (todo && !failcount) /* succeeded yet marked todo */
    {
        todo_wine
        {
            ok_(file, line)(1, "%s: marked \"todo_wine\" but succeeds\n", context);
        }
    }
 
    flush_sequence(seq, sequence_index);
}

START_TEST()

START_TEST

(

analyzer

)

Definition at line 2961 of file analyzer.c.

{
    HRESULT hr;
 
    hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, &IID_IDWriteFactory, (IUnknown**)&factory);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    if (hr != S_OK)
    {
        win_skip("failed to create factory\n");
        return;
    }
 
    init_call_sequences(sequences, NUM_CALL_SEQUENCES);
    init_call_sequences(expected_seq, 1);
 
    test_AnalyzeScript();
    test_AnalyzeLineBreakpoints();
    test_AnalyzeBidi();
    test_GetScriptProperties();
    test_GetTextComplexity();
    test_GetGlyphs();
    test_numbersubstitution();
    test_GetTypographicFeatures();
    test_GetGlyphPlacements();
    test_ApplyCharacterSpacing();
    test_GetGlyphOrientationTransform();
    test_GetBaseline();
    test_GetGdiCompatibleGlyphPlacements();
    test_glyph_justification_property();
 
    IDWriteFactory_Release(factory);
}

table_read_be_word()

static WORD table_read_be_word ( const struct dwrite_fonttable *  table, unsigned int  offset  )

static

Definition at line 1484 of file analyzer.c.

{
    const WORD *ptr = table_read_ensure(table, offset, sizeof(*ptr));
    return ptr ? GET_BE_WORD(*ptr) : 0;
}

Referenced by get_glyph_class(), and test_glyph_props().

table_read_ensure()

static const void * table_read_ensure ( const struct dwrite_fonttable *  table, unsigned int  offset, unsigned int  size  )

static

Definition at line 1476 of file analyzer.c.

{
    if (size > table->size || offset > table->size - size)
        return NULL;
 
    return table->data + offset;
}

Referenced by get_glyph_class(), and table_read_be_word().

test_AnalyzeBidi()

static void test_AnalyzeBidi ( void  )

static

Definition at line 2814 of file analyzer.c.

{
    const struct bidi_test *ptr = bidi_tests;
    IDWriteTextAnalyzer *analyzer;
    UINT32 i = 0;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    while (*ptr->text)
    {
        UINT32 len;
 
        init_textsource(&analysissource, ptr->text, -1, ptr->direction);
 
        len = lstrlenW(ptr->text);
        if (len > BIDI_LEVELS_COUNT) {
            ok(0, "test %u: increase BIDI_LEVELS_COUNT to at least %u\n", i, len);
            i++;
            ptr++;
            continue;
        }
 
        memset(g_explicit_levels, 0, sizeof(g_explicit_levels));
        memset(g_resolved_levels, 0, sizeof(g_resolved_levels));
        hr = IDWriteTextAnalyzer_AnalyzeBidi(analyzer, &analysissource.IDWriteTextAnalysisSource_iface, 0,
            len, &analysissink);
        ok(hr == S_OK, "%u: unexpected hr %#lx.\n", i, hr);
        compare_bidi_levels(i, ptr, len, g_explicit_levels, g_resolved_levels);
 
        i++;
        ptr++;
    }
 
    IDWriteTextAnalyzer_Release(analyzer);
}

Referenced by START_TEST().

test_AnalyzeLineBreakpoints()

static void test_AnalyzeLineBreakpoints ( void  )

static

Definition at line 1220 of file analyzer.c.

{
    const struct linebreaks_test *ptr = linebreaks_tests;
    IDWriteTextAnalyzer *analyzer;
    UINT32 i = 0;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    init_textsource(&analysissource, L"", 0, DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);
    hr = IDWriteTextAnalyzer_AnalyzeLineBreakpoints(analyzer, &analysissource.IDWriteTextAnalysisSource_iface, 0, 0,
        &analysissink);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    while (*ptr->text)
    {
        UINT32 len;
 
        init_textsource(&analysissource, ptr->text, -1, DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);
 
        len = lstrlenW(ptr->text);
        if (len > BREAKPOINT_COUNT) {
            ok(0, "test %u: increase BREAKPOINT_COUNT to at least %u\n", i, len);
            i++;
            ptr++;
            continue;
        }
 
        memset(g_actual_bp, 0, sizeof(g_actual_bp));
        hr = IDWriteTextAnalyzer_AnalyzeLineBreakpoints(analyzer, &analysissource.IDWriteTextAnalysisSource_iface,
            0, len, &analysissink);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        compare_breakpoints(ptr, g_actual_bp);
 
        i++;
        ptr++;
    }
 
    IDWriteTextAnalyzer_Release(analyzer);
}

Referenced by START_TEST().

test_AnalyzeScript()

static void test_AnalyzeScript ( void  )

static

Definition at line 1104 of file analyzer.c.

{
    IDWriteTextAnalyzer *analyzer;
    HRESULT hr;
    UINT i;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    for (i = 0; i < ARRAY_SIZE(sa_tests); i++)
    {
        init_textsource(&analysissource, sa_tests[i].string, sa_tests[i].str_len,
            DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);
 
        winetest_push_context("Test %s", wine_dbgstr_wn(sa_tests[i].string, sa_tests[i].str_len));
 
        init_expected_sa(expected_seq, &sa_tests[i]);
        hr = IDWriteTextAnalyzer_AnalyzeScript(analyzer, &analysissource.IDWriteTextAnalysisSource_iface, 0,
            sa_tests[i].str_len == -1 ? lstrlenW(sa_tests[i].string) : sa_tests[i].str_len, &analysissink);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok_sequence(sequences, ANALYZER_ID, expected_seq[0]->sequence,
            wine_dbgstr_wn(sa_tests[i].string, sa_tests[i].str_len), FALSE);
 
        winetest_pop_context();
    }
 
    IDWriteTextAnalyzer_Release(analyzer);
}

Referenced by START_TEST().

test_ApplyCharacterSpacing()

static void test_ApplyCharacterSpacing ( void  )

static

Definition at line 2198 of file analyzer.c.

{
    DWRITE_SHAPING_GLYPH_PROPERTIES props[3];
    IDWriteTextAnalyzer1 *analyzer;
    UINT16 clustermap[2];
    HRESULT hr;
    int i;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer1);
    if (!analyzer)
    {
        win_skip("ApplyCharacterSpacing() is not supported.\n");
        return;
    }
 
    for (i = 0; i < ARRAY_SIZE(spacing_tests); ++i)
    {
        const struct spacing_test *ptr = spacing_tests + i;
        DWRITE_GLYPH_OFFSET offsets[3];
        UINT32 glyph_count;
        FLOAT advances[3];
 
        offsets[0].advanceOffset = ptr->offsets[0];
        offsets[1].advanceOffset = ptr->offsets[1];
        offsets[2].advanceOffset = ptr->offsets[2];
        /* Ascender offsets are never touched as spacing applies in reading direction only,
           we'll only test them to see if they are not changed */
        offsets[0].ascenderOffset = 23.0;
        offsets[1].ascenderOffset = 32.0;
        offsets[2].ascenderOffset = 31.0;
 
        advances[0] = advances[1] = 123.45f;
        memcpy(props, ptr->props, sizeof(props));
        glyph_count = ptr->advances[2] > 0.0 ? 3 : 2;
        if (ptr->single_cluster)
        {
            clustermap[0] = 0;
            clustermap[1] = 0;
            props[0].isClusterStart = 1;
        }
        else
        {
            /* trivial case with one glyph per cluster */
            clustermap[0] = 0;
            clustermap[1] = 1;
            props[0].isClusterStart = props[1].isClusterStart = 1;
        }
 
        winetest_push_context("Test %u", i);
 
        hr = IDWriteTextAnalyzer1_ApplyCharacterSpacing(analyzer,
            ptr->leading,
            ptr->trailing,
            ptr->min_advance,
            ARRAY_SIZE(clustermap),
            glyph_count,
            clustermap,
            ptr->advances,
            offsets,
            props,
            advances,
            offsets);
        ok(hr == (ptr->min_advance < 0.0f ? E_INVALIDARG : S_OK), "Unexpected hr %#lx.\n", hr);
 
        if (hr == S_OK) {
            ok(ptr->modified_advances[0] == advances[0], "Got advance[0] %.2f, expected %.2f.\n", advances[0], ptr->modified_advances[0]);
            ok(ptr->modified_advances[1] == advances[1], "Got advance[1] %.2f, expected %.2f.\n", advances[1], ptr->modified_advances[1]);
            if (glyph_count > 2)
                ok(ptr->modified_advances[2] == advances[2], "Got advance[2] %.2f, expected %.2f.\n", advances[2], ptr->modified_advances[2]);
 
            ok(ptr->modified_offsets[0] == offsets[0].advanceOffset, "Got offset[0] %.2f, expected %.2f.\n",
                offsets[0].advanceOffset, ptr->modified_offsets[0]);
            ok(ptr->modified_offsets[1] == offsets[1].advanceOffset, "Got offset[1] %.2f, expected %.2f.\n",
                offsets[1].advanceOffset, ptr->modified_offsets[1]);
            if (glyph_count > 2)
                ok(ptr->modified_offsets[2] == offsets[2].advanceOffset, "Got offset[2] %.2f, expected %.2f.\n",
                    offsets[2].advanceOffset, ptr->modified_offsets[2]);
 
            ok(offsets[0].ascenderOffset == 23.0, "Unexpected ascenderOffset %.2f.\n", offsets[0].ascenderOffset);
            ok(offsets[1].ascenderOffset == 32.0, "Unexpected ascenderOffset %.2f.\n", offsets[1].ascenderOffset);
            ok(offsets[2].ascenderOffset == 31.0, "Unexpected ascenderOffset %.2f.\n", offsets[2].ascenderOffset);
        }
        else {
            ok(ptr->modified_advances[0] == advances[0], "Got advance[0] %.2f, expected %.2f.\n", advances[0], ptr->modified_advances[0]);
            ok(ptr->modified_advances[1] == advances[1], "Got advance[1] %.2f, expected %.2f.\n", advances[1], ptr->modified_advances[1]);
            ok(ptr->offsets[0] == offsets[0].advanceOffset, "Got offset[0] %.2f, expected %.2f.\n",
                offsets[0].advanceOffset, ptr->modified_offsets[0]);
            ok(ptr->offsets[1] == offsets[1].advanceOffset, "Got offset[1] %.2f, expected %.2f.\n",
                offsets[1].advanceOffset, ptr->modified_offsets[1]);
            ok(offsets[0].ascenderOffset == 23.0, "Unexpected ascenderOffset %.2f.\n", offsets[0].ascenderOffset);
            ok(offsets[1].ascenderOffset == 32.0, "Unexpected ascenderOffset %.2f.\n", offsets[1].ascenderOffset);
        }
 
        /* same, with argument aliasing */
        memcpy(advances, ptr->advances, glyph_count * sizeof(*advances));
        offsets[0].advanceOffset = ptr->offsets[0];
        offsets[1].advanceOffset = ptr->offsets[1];
        offsets[2].advanceOffset = ptr->offsets[2];
        /* Ascender offsets are never touched as spacing applies in reading direction only,
           we'll only test them to see if they are not changed */
        offsets[0].ascenderOffset = 23.0f;
        offsets[1].ascenderOffset = 32.0f;
        offsets[2].ascenderOffset = 31.0f;
 
        hr = IDWriteTextAnalyzer1_ApplyCharacterSpacing(analyzer,
            ptr->leading,
            ptr->trailing,
            ptr->min_advance,
            ARRAY_SIZE(clustermap),
            glyph_count,
            clustermap,
            advances,
            offsets,
            props,
            advances,
            offsets);
        ok(hr == (ptr->min_advance < 0.0f ? E_INVALIDARG : S_OK), "Unexpected hr %#lx.\n", hr);
 
        if (hr == S_OK)
        {
            ok(ptr->modified_advances[0] == advances[0], "Got advance[0] %.2f, expected %.2f.\n", advances[0], ptr->modified_advances[0]);
            ok(ptr->modified_advances[1] == advances[1], "Got advance[1] %.2f, expected %.2f.\n", advances[1], ptr->modified_advances[1]);
            if (glyph_count > 2)
                ok(ptr->modified_advances[2] == advances[2], "Got advance[2] %.2f, expected %.2f.\n", advances[2], ptr->modified_advances[2]);
 
            ok(ptr->modified_offsets[0] == offsets[0].advanceOffset, "Got offset[0] %.2f, expected %.2f.\n",
                offsets[0].advanceOffset, ptr->modified_offsets[0]);
            ok(ptr->modified_offsets[1] == offsets[1].advanceOffset, "Got offset[1] %.2f, expected %.2f.\n",
                offsets[1].advanceOffset, ptr->modified_offsets[1]);
            if (glyph_count > 2)
                ok(ptr->modified_offsets[2] == offsets[2].advanceOffset, "Got offset[2] %.2f, expected %.2f.\n",
                    offsets[2].advanceOffset, ptr->modified_offsets[2]);
 
            ok(offsets[0].ascenderOffset == 23.0f, "Unexpected ascenderOffset %.2f.\n", offsets[0].ascenderOffset);
            ok(offsets[1].ascenderOffset == 32.0f, "Unexpected ascenderOffset %.2f.\n", offsets[1].ascenderOffset);
            ok(offsets[2].ascenderOffset == 31.0f, "Unexpected ascenderOffset %.2f.\n", offsets[2].ascenderOffset);
        }
        else
        {
            /* with aliased advances original values are retained */
            ok(ptr->advances[0] == advances[0], "Got advance[0] %.2f, expected %.2f.\n", advances[0], ptr->advances[0]);
            ok(ptr->advances[1] == advances[1], "Got advance[1] %.2f, expected %.2f.\n", advances[1], ptr->advances[1]);
            ok(ptr->offsets[0] == offsets[0].advanceOffset, "Got offset[0] %.2f, expected %.2f.\n",
                offsets[0].advanceOffset, ptr->modified_offsets[0]);
            ok(ptr->offsets[1] == offsets[1].advanceOffset, "Got offset[1] %.2f, expected %.2f.\n",
                offsets[1].advanceOffset, ptr->modified_offsets[1]);
            ok(offsets[0].ascenderOffset == 23.0f, "Unexpected ascenderOffset %.2f.\n", offsets[0].ascenderOffset);
            ok(offsets[1].ascenderOffset == 32.0f, "Unexpected ascenderOffset %.2f.\n", offsets[1].ascenderOffset);
        }
 
        winetest_pop_context();
    }
 
    IDWriteTextAnalyzer1_Release(analyzer);
}

Referenced by START_TEST().

test_GetBaseline()

static void test_GetBaseline ( void  )

static

Definition at line 2496 of file analyzer.c.

{
    DWRITE_SCRIPT_ANALYSIS sa = { 0 };
    IDWriteTextAnalyzer1 *analyzer;
    IDWriteFontFace *fontface;
    INT32 baseline;
    BOOL exists;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer1);
    if (!analyzer)
    {
        win_skip("GetBaseline() is not supported.\n");
        return;
    }
 
    fontface = create_fontface();
 
    /* Tahoma does not have a BASE table. */
 
    exists = TRUE;
    baseline = 456;
    hr = IDWriteTextAnalyzer1_GetBaseline(analyzer, fontface, DWRITE_BASELINE_DEFAULT, FALSE,
           TRUE, sa, NULL, &baseline, &exists);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!baseline, "Unexpected baseline %d.\n", baseline);
    ok(!exists, "Unexpected flag %d.\n", exists);
 
    exists = TRUE;
    baseline = 456;
    hr = IDWriteTextAnalyzer1_GetBaseline(analyzer, fontface, DWRITE_BASELINE_DEFAULT, FALSE,
           FALSE, sa, NULL, &baseline, &exists);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!baseline, "Unexpected baseline %d.\n", baseline);
    ok(!exists, "Unexpected flag %d.\n", exists);
 
    exists = TRUE;
    baseline = 0;
    hr = IDWriteTextAnalyzer1_GetBaseline(analyzer, fontface, DWRITE_BASELINE_CENTRAL, FALSE,
           TRUE, sa, NULL, &baseline, &exists);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(baseline != 0, "Unexpected baseline %d.\n", baseline);
    ok(!exists, "Unexpected flag %d.\n", exists);
 
    exists = TRUE;
    baseline = 0;
    hr = IDWriteTextAnalyzer1_GetBaseline(analyzer, fontface, DWRITE_BASELINE_CENTRAL, FALSE,
           FALSE, sa, NULL, &baseline, &exists);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!baseline, "Unexpected baseline %d.\n", baseline);
    ok(!exists, "Unexpected flag %d.\n", exists);
 
    exists = TRUE;
    baseline = 456;
    hr = IDWriteTextAnalyzer1_GetBaseline(analyzer, fontface, DWRITE_BASELINE_DEFAULT + 100, FALSE,
           TRUE, sa, NULL, &baseline, &exists);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(!baseline, "Unexpected baseline %d.\n", baseline);
    ok(!exists, "Unexpected flag %d.\n", exists);
 
    IDWriteFontFace_Release(fontface);
    IDWriteTextAnalyzer1_Release(analyzer);
}

Referenced by START_TEST().

test_GetGdiCompatibleGlyphPlacements()

static void test_GetGdiCompatibleGlyphPlacements ( void  )

static

Definition at line 2573 of file analyzer.c.

{
    DWRITE_SHAPING_GLYPH_PROPERTIES glyphprops[1];
    DWRITE_SHAPING_TEXT_PROPERTIES textprops[1];
    DWRITE_SCRIPT_ANALYSIS sa = { 0 };
    IDWriteTextAnalyzer *analyzer;
    IDWriteFontFace *fontface;
    UINT16 clustermap[1];
    HRESULT hr;
    UINT32 count;
    UINT16 glyphs[1];
    FLOAT advance;
    DWRITE_GLYPH_OFFSET offsets[1];
    DWRITE_FONT_METRICS fontmetrics;
    float emsize;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    fontface = create_fontface();
 
    IDWriteFontFace_GetMetrics(fontface, &fontmetrics);
 
    count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, L"A", 1, fontface, FALSE, FALSE, &sa, NULL, NULL, NULL, NULL, 0, 1,
            clustermap, textprops, glyphs, glyphprops, &count);
    ok(hr == S_OK, "Failed to get glyphs, hr %#lx.\n", hr);
    ok(count == 1, "got %u\n", count);
 
    for (emsize = 12.0f; emsize <= 20.0f; emsize += 1.0f)
    {
        FLOAT compatadvance, expected, ppdip;
        DWRITE_GLYPH_METRICS metrics;
 
        hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, L"A", clustermap, textprops, 1, glyphs, glyphprops,
                count, fontface, emsize, FALSE, FALSE, &sa, NULL, NULL, NULL, 0, &advance, offsets);
        ok(hr == S_OK, "Failed to get glyph placements, hr %#lx.\n", hr);
        ok(advance > 0.0f, "Unexpected advance %f.\n", advance);
 
        /* 1 ppdip, no transform */
        ppdip = 1.0;
        hr = IDWriteFontFace_GetGdiCompatibleGlyphMetrics(fontface, emsize, ppdip, NULL, FALSE,
            glyphs, 1, &metrics, FALSE);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        expected = floorf(metrics.advanceWidth * emsize * ppdip / fontmetrics.designUnitsPerEm + 0.5f) / ppdip;
        hr = IDWriteTextAnalyzer_GetGdiCompatibleGlyphPlacements(analyzer, L"A", clustermap, textprops, 1, glyphs,
                glyphprops, count, fontface, emsize, ppdip, NULL, FALSE, FALSE, FALSE, &sa, NULL, NULL, NULL, 0,
                &compatadvance, offsets);
        ok(hr == S_OK, "Failed to get glyph placements, hr %#lx.\n", hr);
        ok(compatadvance == expected, "%.0f: got advance %f, expected %f, natural %f\n", emsize,
            compatadvance, expected, advance);
 
        /* 1.2 ppdip, no transform */
        ppdip = 1.2f;
        hr = IDWriteFontFace_GetGdiCompatibleGlyphMetrics(fontface, emsize, ppdip, NULL, FALSE,
            glyphs, 1, &metrics, FALSE);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        expected = floorf(metrics.advanceWidth * emsize * ppdip / fontmetrics.designUnitsPerEm + 0.5f) / ppdip;
        hr = IDWriteTextAnalyzer_GetGdiCompatibleGlyphPlacements(analyzer, L"A", clustermap, textprops, 1, glyphs,
                glyphprops, count, fontface, emsize, ppdip, NULL, FALSE, FALSE, FALSE, &sa, NULL, NULL, NULL, 0,
                &compatadvance, offsets);
        ok(hr == S_OK, "Failed to get glyph placements, hr %#lx.\n", hr);
        ok(float_eq(compatadvance, expected), "%.0f: got advance %f, expected %f, natural %f\n", emsize,
            compatadvance, expected, advance);
    }
 
    IDWriteFontFace_Release(fontface);
    IDWriteTextAnalyzer_Release(analyzer);
}

Referenced by START_TEST().

test_GetGlyphOrientationTransform()

static void test_GetGlyphOrientationTransform ( void  )

static

Definition at line 2379 of file analyzer.c.

{
    IDWriteTextAnalyzer2 *analyzer2;
    IDWriteTextAnalyzer1 *analyzer;
    FLOAT originx, originy;
    DWRITE_MATRIX m;
    HRESULT hr;
    int i;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer1);
    if (!analyzer)
    {
        win_skip("GetGlyphOrientationTransform() is not supported.\n");
        return;
    }
 
    /* invalid angle value */
    memset(&m, 0xcc, sizeof(m));
    hr = IDWriteTextAnalyzer1_GetGlyphOrientationTransform(analyzer,
        DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES + 1, FALSE, &m);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(m.m11 == 0.0, "got %.2f\n", m.m11);
 
    for (i = 0; i < ARRAY_SIZE(ot_tests); ++i)
    {
        memset(&m, 0, sizeof(m));
        hr = IDWriteTextAnalyzer1_GetGlyphOrientationTransform(analyzer, ot_tests[i].angle,
            ot_tests[i].is_sideways, &m);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok(!memcmp(&ot_tests[i].m, &m, sizeof(m)), "%d: wrong matrix %s\n", i, dbgstr_matrix(&m));
    }
 
    IDWriteTextAnalyzer1_Release(analyzer);
 
    analyzer2 = create_text_analyzer(&IID_IDWriteTextAnalyzer2);
    if (!analyzer2)
    {
        win_skip("IDWriteTextAnalyzer2::GetGlyphOrientationTransform() is not supported.\n");
        return;
    }
 
    /* invalid angle value */
    memset(&m, 0xcc, sizeof(m));
    hr = IDWriteTextAnalyzer2_GetGlyphOrientationTransform(analyzer2,
        DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES + 1, FALSE, 0.0, 0.0, &m);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(m.m11 == 0.0, "got %.2f\n", m.m11);
 
    originx = 50.0;
    originy = 60.0;
    for (i = 0; i < ARRAY_SIZE(ot_tests); i++) {
        DWRITE_GLYPH_ORIENTATION_ANGLE angle = DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES;
        DWRITE_MATRIX m_exp;
 
        memset(&m, 0, sizeof(m));
 
        /* zero offset gives same result as a call from IDWriteTextAnalyzer1 */
        hr = IDWriteTextAnalyzer2_GetGlyphOrientationTransform(analyzer2, ot_tests[i].angle,
            ot_tests[i].is_sideways, 0.0, 0.0, &m);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok(!memcmp(&ot_tests[i].m, &m, sizeof(m)), "%d: wrong matrix %s\n", i, dbgstr_matrix(&m));
 
        m_exp = ot_tests[i].m;
        hr = IDWriteTextAnalyzer2_GetGlyphOrientationTransform(analyzer2, ot_tests[i].angle,
            ot_tests[i].is_sideways, originx, originy, &m);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        /* 90 degrees more for sideways */
        if (ot_tests[i].is_sideways) {
            switch (ot_tests[i].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:
                ;
            }
        }
        else
            angle = ot_tests[i].angle;
 
        /* set expected offsets */
        switch (angle)
        {
        case DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES:
            break;
        case DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES:
            m_exp.dx = originx + originy;
            m_exp.dy = originy - originx;
            break;
        case DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES:
            m_exp.dx = originx + originx;
            m_exp.dy = originy + originy;
            break;
        case DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES:
            m_exp.dx = originx - originy;
            m_exp.dy = originy + originx;
            break;
        default:
            ;
        }
 
        ok(!memcmp(&m_exp, &m, sizeof(m)), "%d: wrong matrix %s\n", i, dbgstr_matrix(&m));
    }
 
    IDWriteTextAnalyzer2_Release(analyzer2);
}

Referenced by START_TEST().

test_GetGlyphPlacements()

static void test_GetGlyphPlacements ( void  )

static

Definition at line 1907 of file analyzer.c.

{
    DWRITE_SHAPING_GLYPH_PROPERTIES glyphprops[2];
    DWRITE_SHAPING_TEXT_PROPERTIES textprops[2];
    static const WCHAR aW[] = {'A','D',0};
    UINT16 clustermap[2], glyphs[2];
    DWRITE_GLYPH_OFFSET offsets[2];
    IDWriteTextAnalyzer *analyzer;
    IDWriteFontFace *fontface;
    DWRITE_SCRIPT_ANALYSIS sa;
    FLOAT advances[2];
    UINT32 count, len;
    WCHAR *path;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    path = create_testfontfile(L"wine_test_font.ttf");
    fontface = create_testfontface(path);
 
    get_script_analysis(aW, &sa);
    count = 0;
    len = lstrlenW(aW);
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, aW, len, fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, len, clustermap, textprops, glyphs, glyphprops, &count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(count == 2, "got %u\n", count);
 
    /* just return on zero glyphs */
    advances[0] = advances[1] = 1.0;
    offsets[0].advanceOffset = offsets[0].ascenderOffset = 2.0;
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, 0, fontface, 0.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 1.0, "got %.2f\n", advances[0]);
    ok(offsets[0].advanceOffset == 2.0 && offsets[0].ascenderOffset == 2.0, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    /* advances/offsets are scaled with provided font emSize and designed eM box size */
    advances[0] = advances[1] = 1.0;
    memset(offsets, 0xcc, sizeof(offsets));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, 0.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 0.0, "got %.2f\n", advances[0]);
    ok(offsets[0].advanceOffset == 0.0 && offsets[0].ascenderOffset == 0.0, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    advances[0] = advances[1] = 1.0;
    memset(offsets, 0xcc, sizeof(offsets));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, 2048.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 1000.0, "got %.2f\n", advances[0]);
    ok(offsets[0].advanceOffset == 0.0 && offsets[0].ascenderOffset == 0.0, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    advances[0] = advances[1] = 1.0;
    memset(offsets, 0xcc, sizeof(offsets));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, 1024.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 500.0, "got %.2f\n", advances[0]);
    ok(advances[1] == 500.0, "got %.2f\n", advances[1]);
    ok(offsets[0].advanceOffset == 0.0 && offsets[0].ascenderOffset == 0.0, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    advances[0] = advances[1] = 1.0;
    memset(offsets, 0xcc, sizeof(offsets));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, 20.48, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 10.0, "got %.2f\n", advances[0]);
    ok(advances[1] == 10.0, "got %.2f\n", advances[1]);
    ok(offsets[0].advanceOffset == 0.0 && offsets[0].ascenderOffset == 0.0, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    /* without clustermap */
    advances[0] = advances[1] = 1.0;
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, NULL, textprops,
        len, glyphs, glyphprops, len, fontface, 1024.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 500.0, "got %.2f\n", advances[0]);
    ok(advances[1] == 500.0, "got %.2f\n", advances[1]);
 
    /* it's happy to use negative size too */
    advances[0] = advances[1] = 1.0;
    memset(offsets, 0xcc, sizeof(offsets));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, -10.24, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == -5.0, "got %.2f\n", advances[0]);
    ok(offsets[0].advanceOffset == 0.0 && offsets[0].ascenderOffset == 0.0, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    /* DWRITE_SCRIPT_SHAPES_NO_VISUAL has no effect on placement */
    sa.shapes = DWRITE_SCRIPT_SHAPES_NO_VISUAL;
    advances[0] = advances[1] = 1.0f;
    memset(offsets, 0xcc, sizeof(offsets));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, 2048.0f, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 1000.0f, "got %.2f\n", advances[0]);
    ok(advances[1] == 1000.0f, "got %.2f\n", advances[1]);
    ok(offsets[0].advanceOffset == 0.0f && offsets[0].ascenderOffset == 0.0f, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    /* isZeroWidthSpace */
    sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
    advances[0] = advances[1] = 1.0f;
    memset(offsets, 0xcc, sizeof(offsets));
    glyphprops[0].isZeroWidthSpace = 1;
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, aW, clustermap, textprops,
        len, glyphs, glyphprops, len, fontface, 2048.0f, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == 0.0f, "got %.2f\n", advances[0]);
    ok(advances[1] == 1000.0f, "got %.2f\n", advances[1]);
    ok(offsets[0].advanceOffset == 0.0f && offsets[0].ascenderOffset == 0.0f, "got %.2f,%.2f\n",
        offsets[0].advanceOffset, offsets[0].ascenderOffset);
 
    IDWriteTextAnalyzer_Release(analyzer);
    IDWriteFontFace_Release(fontface);
    DELETE_FONTFILE(path);
}

Referenced by START_TEST().

test_GetGlyphs()

static void test_GetGlyphs ( void  )

static

Definition at line 1662 of file analyzer.c.

{
    static const WCHAR test1W[] = {'<','B',' ','C',0};
    static const WCHAR test2W[] = {'<','B','\t','C',0};
    static const WCHAR test3W[] = {0x202a,0x202c,0};
    DWRITE_SHAPING_GLYPH_PROPERTIES shapingprops[20];
    DWRITE_SHAPING_TEXT_PROPERTIES props[20];
    UINT32 maxglyphcount, actual_count;
    FLOAT advances[10], advances2[10];
    IDWriteFontCollection *syscoll;
    IDWriteTextAnalyzer *analyzer;
    IDWriteFontFace *fontface;
    DWRITE_SCRIPT_ANALYSIS sa;
    DWRITE_GLYPH_OFFSET offsets[10];
    UINT16 clustermap[10];
    UINT16 glyphs1[10];
    UINT16 glyphs2[10];
    unsigned int i, j;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    fontface = create_fontface();
 
    maxglyphcount = 1;
    sa.script = 0;
    sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Unexpected hr %#lx.\n", hr);
 
if (0) {
    /* NULL fontface - crashes on Windows */
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), NULL, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
}
 
    /* invalid script id */
    maxglyphcount = 10;
    actual_count = 0;
    sa.script = 999;
    sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 4, "got %d\n", actual_count);
    ok(sa.script == 999, "got %u\n", sa.script);
 
    /* no '\t' -> ' ' replacement */
    maxglyphcount = 10;
    actual_count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 4, "got %d\n", actual_count);
 
    actual_count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test2W, lstrlenW(test2W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs2, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 4, "got %d\n", actual_count);
    ok(glyphs1[2] != glyphs2[2], "got %d\n", glyphs1[2]);
 
    /* check that mirroring works */
    maxglyphcount = 10;
    actual_count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 4, "got %d\n", actual_count);
 
    actual_count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), fontface, FALSE, TRUE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs2, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 4, "got %d\n", actual_count);
    ok(glyphs1[0] != glyphs2[0], "got %d\n", glyphs1[0]);
 
    /* embedded control codes, with unknown script id 0 */
    get_fontface_glyphs(fontface, test3W, glyphs2);
    get_fontface_advances(fontface, 10.0, glyphs2, advances2, 2);
 
    actual_count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test3W, lstrlenW(test3W), fontface, FALSE, TRUE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 2, "got %d\n", actual_count);
    ok(glyphs1[0] == glyphs2[0], "got %u, expected %u\n", glyphs1[0], glyphs2[0]);
    ok(glyphs1[1] == glyphs2[1], "got %u, expected %u\n", glyphs1[1], glyphs2[1]);
    ok(shapingprops[0].isClusterStart == 1, "got %d\n", shapingprops[0].isClusterStart);
    ok(shapingprops[0].isZeroWidthSpace == 0, "got %d\n", shapingprops[0].isZeroWidthSpace);
    ok(shapingprops[1].isClusterStart == 1, "got %d\n", shapingprops[1].isClusterStart);
    ok(shapingprops[1].isZeroWidthSpace == 0, "got %d\n", shapingprops[1].isZeroWidthSpace);
    ok(clustermap[0] == 0, "got %d\n", clustermap[0]);
    ok(clustermap[1] == 1, "got %d\n", clustermap[1]);
 
    memset(advances, 0, sizeof(advances));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, test3W, clustermap, props, lstrlenW(test3W),
        glyphs1, shapingprops, actual_count, fontface, 10.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == advances2[0], "got %.2f, expected %.2f\n", advances[0], advances2[0]);
    ok(advances[1] == advances2[1], "got %.2f, expected %.2f\n", advances[1], advances2[1]);
 
    /* embedded control codes with proper script */
    sa.script = 0;
    get_script_analysis(test3W, &sa);
    ok(sa.script != 0, "got %d\n", sa.script);
    actual_count = 0;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test3W, lstrlenW(test3W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 2, "got %d\n", actual_count);
    ok(glyphs1[0] == glyphs2[0], "got %u, expected %u\n", glyphs1[0], glyphs2[0]);
    ok(glyphs1[1] == glyphs2[1], "got %u, expected %u\n", glyphs1[1], glyphs2[1]);
    ok(shapingprops[0].isClusterStart == 1, "got %d\n", shapingprops[0].isClusterStart);
    ok(shapingprops[0].isZeroWidthSpace == 0, "got %d\n", shapingprops[0].isZeroWidthSpace);
    ok(shapingprops[1].isClusterStart == 1, "got %d\n", shapingprops[1].isClusterStart);
    ok(shapingprops[1].isZeroWidthSpace == 0, "got %d\n", shapingprops[1].isZeroWidthSpace);
    ok(clustermap[0] == 0, "got %d\n", clustermap[0]);
    ok(clustermap[1] == 1, "got %d\n", clustermap[1]);
 
    memset(advances, 0, sizeof(advances));
    hr = IDWriteTextAnalyzer_GetGlyphPlacements(analyzer, test3W, clustermap, props, lstrlenW(test3W),
        glyphs1, shapingprops, actual_count, fontface, 10.0, FALSE, FALSE, &sa, NULL, NULL,
        NULL, 0, advances, offsets);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(advances[0] == advances2[0], "got %.2f, expected %.2f\n", advances[0], advances2[0]);
    ok(advances[1] == advances2[1], "got %.2f, expected %.2f\n", advances[1], advances2[1]);
 
    /* DWRITE_SCRIPT_SHAPES_NO_VISUAL run */
    maxglyphcount = 10;
    actual_count = 0;
    sa.script = 0;
    sa.shapes = DWRITE_SCRIPT_SHAPES_NO_VISUAL;
    hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, test1W, lstrlenW(test1W), fontface, FALSE, FALSE, &sa, NULL,
        NULL, NULL, NULL, 0, maxglyphcount, clustermap, props, glyphs1, shapingprops, &actual_count);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(actual_count == 4, "got %d\n", actual_count);
    ok(sa.script == 0, "got %u\n", sa.script);
    ok(!shapingprops[0].isZeroWidthSpace, "got %d\n", shapingprops[0].isZeroWidthSpace);
 
    IDWriteFontFace_Release(fontface);
 
    /* Test setting glyph properties from GDEF. */
    hr = IDWriteFactory_GetSystemFontCollection(factory, &syscoll, FALSE);
    ok(hr == S_OK, "Failed to get system collection, hr %#lx.\n", hr);
 
    for (i = 0; i < IDWriteFontCollection_GetFontFamilyCount(syscoll); ++i)
    {
        IDWriteLocalizedStrings *names;
        IDWriteFontFamily *family;
        WCHAR familyW[256];
 
        hr = IDWriteFontCollection_GetFontFamily(syscoll, i, &family);
        ok(hr == S_OK, "Failed to get font family, hr %#lx.\n", hr);
 
        hr = IDWriteFontFamily_GetFamilyNames(family, &names);
        ok(hr == S_OK, "Failed to get family names, hr %#lx.\n", hr);
        get_enus_string(names, familyW, ARRAY_SIZE(familyW));
        IDWriteLocalizedStrings_Release(names);
 
        for (j = 0; j < IDWriteFontFamily_GetFontCount(family); ++j)
        {
            IDWriteFont *font;
            WCHAR faceW[256];
 
            hr = IDWriteFontFamily_GetFont(family, j, &font);
            ok(hr == S_OK, "Failed to get font instance, hr %#lx.\n", hr);
 
            hr = IDWriteFont_CreateFontFace(font, &fontface);
            ok(hr == S_OK, "Failed to create fontface, hr %#lx.\n", hr);
 
            hr = IDWriteFont_GetFaceNames(font, &names);
            ok(hr == S_OK, "Failed to get face names, hr %#lx.\n", hr);
            get_enus_string(names, faceW, ARRAY_SIZE(faceW));
            IDWriteLocalizedStrings_Release(names);
 
            test_glyph_props(analyzer, familyW, faceW, fontface);
 
            IDWriteFontFace_Release(fontface);
            IDWriteFont_Release(font);
        }
 
        IDWriteFontFamily_Release(family);
    }
 
    IDWriteFontCollection_Release(syscoll);
 
    IDWriteTextAnalyzer_Release(analyzer);
}

Referenced by START_TEST().

test_GetScriptProperties()

static void test_GetScriptProperties ( void  )

static

Definition at line 1262 of file analyzer.c.

{
    IDWriteTextAnalyzer1 *analyzer;
    DWRITE_SCRIPT_PROPERTIES props;
    DWRITE_SCRIPT_ANALYSIS sa;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer1);
    if (!analyzer)
    {
        win_skip("GetScriptProperties() is not supported.\n");
        return;
    }
 
    sa.script = 1000;
    hr = IDWriteTextAnalyzer1_GetScriptProperties(analyzer, sa, &props);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    if (0) /* Crashes on Windows */
        hr = IDWriteTextAnalyzer1_GetScriptProperties(analyzer, sa, NULL);
 
    sa.script = 0;
    hr = IDWriteTextAnalyzer1_GetScriptProperties(analyzer, sa, &props);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    IDWriteTextAnalyzer1_Release(analyzer);
}

Referenced by START_TEST().

test_GetTextComplexity()

static void test_GetTextComplexity ( void  )

static

Definition at line 1320 of file analyzer.c.

{
    IDWriteTextAnalyzer1 *analyzer;
    IDWriteFontFace *fontface;
    UINT16 indices[10];
    BOOL simple;
    HRESULT hr;
    UINT32 len;
    int i;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer1);
    if (!analyzer)
    {
        win_skip("GetTextComplexity() is not supported.\n");
        return;
    }
 
if (0) { /* crashes on native */
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, NULL, 0, NULL, NULL, NULL, NULL);
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, NULL, 0, NULL, NULL, &len, NULL);
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, L"ABC", 3, NULL, NULL, NULL, NULL);
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, L"ABC", 3, NULL, NULL, &len, NULL);
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, L"ABC", 3, NULL, &simple, NULL, NULL);
}
 
    len = 1;
    simple = TRUE;
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, NULL, 0, NULL, &simple, &len, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(len == 0, "got %d\n", len);
    ok(simple == FALSE, "got %d\n", simple);
 
    len = 1;
    simple = TRUE;
    indices[0] = 1;
    hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, L"ABC", 3, NULL, &simple, &len, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
    ok(len == 0, "got %d\n", len);
    ok(simple == FALSE, "got %d\n", simple);
    ok(indices[0] == 1, "got %d\n", indices[0]);
 
    fontface = create_fontface();
 
    for (i = 0; i < ARRAY_SIZE(textcomplexity_tests); ++i)
    {
       const struct textcomplexity_test *ptr = &textcomplexity_tests[i];
       len = 1;
       simple = !ptr->simple;
       indices[0] = 0;
       hr = IDWriteTextAnalyzer1_GetTextComplexity(analyzer, ptr->text, ptr->length, fontface, &simple, &len, indices);
       ok(hr == S_OK, "%d: Unexpected hr %#lx.\n", i, hr);
       ok(len == ptr->len_read, "%d: read length: got %d, expected %d\n", i, len, ptr->len_read);
       ok(simple == ptr->simple, "%d: simple: got %d, expected %d\n", i, simple, ptr->simple);
       if (simple && ptr->length)
           ok(indices[0] > 0, "%d: got %d\n", i, indices[0]);
       else
           ok(indices[0] == 0, "%d: got %d\n", i, indices[0]);
    }
 
    IDWriteFontFace_Release(fontface);
    IDWriteTextAnalyzer1_Release(analyzer);
}

Referenced by START_TEST().

test_GetTypographicFeatures()

static void test_GetTypographicFeatures ( void  )

static

Definition at line 1855 of file analyzer.c.

{
    static const WCHAR arabicW[] = {0x064a,0x064f,0x0633,0};
    DWRITE_FONT_FEATURE_TAG tags[20];
    IDWriteTextAnalyzer2 *analyzer;
    IDWriteFontFace *fontface;
    DWRITE_SCRIPT_ANALYSIS sa;
    UINT32 count;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer2);
    if (!analyzer)
    {
        win_skip("GetTypographicFeatures() is not supported.\n");
        return;
    }
 
    fontface = create_fontface();
 
    get_script_analysis(L"abc", &sa);
    count = 0;
    hr = IDWriteTextAnalyzer2_GetTypographicFeatures(analyzer, fontface, sa, NULL, 0, &count, NULL);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Unexpected hr %#lx.\n", hr);
    ok(!!count, "Unexpected count %u.\n", count);
 
    /* invalid locale name is ignored */
    get_script_analysis(L"abc", &sa);
    count = 0;
    hr = IDWriteTextAnalyzer2_GetTypographicFeatures(analyzer, fontface, sa, L"cadabra", 0, &count, NULL);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Unexpected hr %#lx.\n", hr);
    ok(!!count, "Unexpected count %u.\n", count);
 
    /* Make some calls for different scripts. */
 
    get_script_analysis(arabicW, &sa);
    memset(tags, 0, sizeof(tags));
    count = 0;
    hr = IDWriteTextAnalyzer2_GetTypographicFeatures(analyzer, fontface, sa, NULL, ARRAY_SIZE(tags), &count, tags);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!!count, "Unexpected count %u.\n", count);
 
    get_script_analysis(L"abc", &sa);
    memset(tags, 0, sizeof(tags));
    count = 0;
    hr = IDWriteTextAnalyzer2_GetTypographicFeatures(analyzer, fontface, sa, NULL, ARRAY_SIZE(tags), &count, tags);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!!count, "Unexpected count %u.\n", count);
 
    IDWriteFontFace_Release(fontface);
    IDWriteTextAnalyzer2_Release(analyzer);
}

Referenced by START_TEST().

test_glyph_justification_property()

static void test_glyph_justification_property ( void  )

static

Definition at line 2859 of file analyzer.c.

{
    static const struct
    {
        enum script_id script;
        const WCHAR *text;
        unsigned short justification[10];
    } tests[] =
    {
        {
            Script_Latin,
            L"a b\tc",
            {
                SCRIPT_JUSTIFY_CHARACTER,
                SCRIPT_JUSTIFY_BLANK,
                SCRIPT_JUSTIFY_CHARACTER,
                SCRIPT_JUSTIFY_BLANK,
                SCRIPT_JUSTIFY_CHARACTER,
            },
        },
        {
            Script_Latin,
            L" a b",
            {
                SCRIPT_JUSTIFY_BLANK,
                SCRIPT_JUSTIFY_CHARACTER,
                SCRIPT_JUSTIFY_BLANK,
                SCRIPT_JUSTIFY_CHARACTER,
            },
        },
        {
            Script_Arabic,
            L" a b",
            {
                SCRIPT_JUSTIFY_ARABIC_BLANK,
                SCRIPT_JUSTIFY_NONE,
                SCRIPT_JUSTIFY_ARABIC_BLANK,
                SCRIPT_JUSTIFY_NONE,
            },
        },
        { Script_Unknown, L"a", { SCRIPT_JUSTIFY_CHARACTER } },
        { Script_Latin, L"\x640", { SCRIPT_JUSTIFY_CHARACTER } },
        { Script_Arabic, L"\x640", { SCRIPT_JUSTIFY_ARABIC_KASHIDA } },
 
        { Script_Arabic, L"\x633\x627", { SCRIPT_JUSTIFY_ARABIC_SEEN, SCRIPT_JUSTIFY_ARABIC_ALEF } },
        { Script_Arabic, L"\x633\x625", { SCRIPT_JUSTIFY_ARABIC_SEEN, SCRIPT_JUSTIFY_ARABIC_ALEF } },
        { Script_Arabic, L"\x633\x623", { SCRIPT_JUSTIFY_ARABIC_SEEN, SCRIPT_JUSTIFY_ARABIC_ALEF } },
        { Script_Arabic, L"\x633\x622", { SCRIPT_JUSTIFY_ARABIC_SEEN, SCRIPT_JUSTIFY_ARABIC_ALEF } },
 
        { Script_Arabic, L"\x644\x647", { SCRIPT_JUSTIFY_NONE, SCRIPT_JUSTIFY_ARABIC_HA } },
 
        { Script_Arabic, L"\x628\x631", { SCRIPT_JUSTIFY_NONE, SCRIPT_JUSTIFY_ARABIC_BARA } },
        { Script_Arabic, L"\x645\x631", { SCRIPT_JUSTIFY_NONE, SCRIPT_JUSTIFY_ARABIC_BARA } },
        { Script_Arabic, L"\x645\x632", { SCRIPT_JUSTIFY_NONE, SCRIPT_JUSTIFY_ARABIC_BARA } },
 
        { Script_Arabic, L"\x644\x633\x645", { SCRIPT_JUSTIFY_NONE, SCRIPT_JUSTIFY_ARABIC_SEEN_M, SCRIPT_JUSTIFY_ARABIC_NORMAL } },
    };
    DWRITE_SHAPING_GLYPH_PROPERTIES glyph_props[16];
    DWRITE_SHAPING_TEXT_PROPERTIES text_props[16];
    UINT16 clustermap[16], glyphs[16];
    IDWriteTextAnalyzer *analyzer;
    DWRITE_SCRIPT_ANALYSIS sa;
    IDWriteFontFace *fontface;
    UINT32 glyph_count;
    unsigned int i, j;
    HRESULT hr;
 
    analyzer = create_text_analyzer(&IID_IDWriteTextAnalyzer);
    ok(!!analyzer, "Failed to create analyzer instance.\n");
 
    fontface = create_fontface();
 
    for (i = 0; i < ARRAY_SIZE(tests); ++i)
    {
        if (tests[i].script == Script_Arabic && !strcmp(winetest_platform, "wine"))
            continue;
 
        winetest_push_context("Test %s", debugstr_w(tests[i].text));
 
        sa.script = tests[i].script;
        sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
 
        /* Use RTL for Arabic, it affects returned justification classes. */
        hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, tests[i].text, wcslen(tests[i].text), fontface,
                FALSE, sa.script == Script_Arabic, &sa, L"en-US", NULL, NULL, NULL, 0, ARRAY_SIZE(glyphs), clustermap,
                text_props, glyphs, glyph_props, &glyph_count);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        for (j = 0; j < glyph_count; ++j)
        {
            winetest_push_context("Glyph %u", j);
            ok(glyph_props[j].justification == tests[i].justification[j], "Unexpected justification value %u.\n",
                    glyph_props[j].justification);
            winetest_pop_context();
        }
 
        winetest_pop_context();
    }
 
    IDWriteFontFace_Release(fontface);
}

Referenced by START_TEST().

test_glyph_props()

static void test_glyph_props ( IDWriteTextAnalyzer *  analyzer, const WCHAR *  family, const WCHAR *  face, IDWriteFontFace *  fontface  )

static

Definition at line 1566 of file analyzer.c.

{
    unsigned int i, ch, count, offset;
    struct dwrite_fonttable gdef;
    DWRITE_UNICODE_RANGE *ranges;
    IDWriteFontFace1 *fontface1;
    BOOL exists = FALSE;
    HRESULT hr;
 
    hr = IDWriteFontFace_TryGetFontTable(fontface, MS_GDEF_TAG, (const void **)&gdef.data, &gdef.size,
            &gdef.context, &exists);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    if (!exists)
        return;
 
    offset = table_read_be_word(&gdef, 4);
    if (!offset)
    {
        IDWriteFontFace_ReleaseFontTable(fontface, gdef.context);
        return;
    }
 
    if (FAILED(IDWriteFontFace_QueryInterface(fontface, &IID_IDWriteFontFace1, (void **)&fontface1)))
    {
        IDWriteFontFace_ReleaseFontTable(fontface, gdef.context);
        return;
    }
 
    hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, 0, NULL, &count);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Unexpected hr %#lx.\n", hr);
 
    ranges = malloc(count * sizeof(*ranges));
 
    hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, count, ranges, &count);
    ok(hr == S_OK, "Failed to get ranges, hr %#lx.\n", hr);
 
    for (i = 0; i < count; ++i)
    {
        if (ranges[i].first > 0xffff)
            break;
 
        for (ch = ranges[i].first; ch <= ranges[i].last; ch++)
        {
            DWRITE_SHAPING_TEXT_PROPERTIES text_props[10];
            DWRITE_SHAPING_GLYPH_PROPERTIES glyph_props[10];
            UINT16 glyphs[10], clustermap[10], glyph;
            unsigned int actual_count, glyph_class;
            DWRITE_SCRIPT_ANALYSIS sa;
            WCHAR text[1];
 
            hr = IDWriteFontFace1_GetGlyphIndices(fontface1, &ch, 1, &glyph);
            ok(hr == S_OK, "Failed to get glyph index, hr %#lx.\n", hr);
 
            if (!glyph)
                continue;
 
            sa.script = 999;
            sa.shapes = DWRITE_SCRIPT_SHAPES_DEFAULT;
            text[0] = (WCHAR)ch;
            memset(glyph_props, 0, sizeof(glyph_props));
            hr = IDWriteTextAnalyzer_GetGlyphs(analyzer, text, 1, fontface, FALSE, FALSE, &sa, NULL,
                    NULL, NULL, NULL, 0, ARRAY_SIZE(glyphs), clustermap, text_props, glyphs, glyph_props, &actual_count);
            ok(hr == S_OK, "Failed to shape, hr %#lx.\n", hr);
            if (actual_count > 1)
                continue;
 
            glyph_class = get_glyph_class(&gdef, glyphs[0]);
 
            switch (glyph_class)
            {
                case GDEF_CLASS_MARK:
                    ok(glyph_props[0].isDiacritic && glyph_props[0].isZeroWidthSpace,
                            "%#x -> %u: unexpected glyph properties %u/%u. Class %u. Font %s - %s.\n",
                            text[0], glyphs[0], glyph_props[0].isDiacritic, glyph_props[0].isZeroWidthSpace,
                            glyph_class, wine_dbgstr_w(family), wine_dbgstr_w(face));
                    break;
                default:
                    break;
            }
 
            if (glyph_props[0].isDiacritic)
                ok(glyph_props[0].isZeroWidthSpace,
                        "%#x -> %u: unexpected glyph properties %u/%u. Class %u. Font %s - %s.\n", text[0], glyphs[0],
                        glyph_props[0].isDiacritic, glyph_props[0].isZeroWidthSpace, glyph_class,
                        wine_dbgstr_w(family), wine_dbgstr_w(face));
        }
    }
 
    free(ranges);
 
    IDWriteFontFace_ReleaseFontTable(fontface, gdef.context);
    IDWriteFontFace1_Release(fontface1);
}

Referenced by test_GetGlyphs().

test_numbersubstitution()

static void test_numbersubstitution ( void  )

static

Definition at line 1383 of file analyzer.c.

{
    IDWriteNumberSubstitution *substitution;
    HRESULT hr;
 
    /* locale is not specified, method does not require it */
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, NULL, FALSE, &substitution);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IDWriteNumberSubstitution_Release(substitution);
 
    /* invalid locale name, method does not require it */
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, L"dummy",
            FALSE, &substitution);
    ok(hr == S_OK, "Failed to create number substitution, hr %#lx.\n", hr);
    IDWriteNumberSubstitution_Release(substitution);
 
    /* invalid method */
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL+1, NULL, FALSE, &substitution);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    /* invalid method */
    hr = IDWriteFactory_CreateNumberSubstitution(factory, -1, NULL, FALSE, &substitution);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    /* invalid locale */
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL, NULL, FALSE, &substitution);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL, L"dummy",
            FALSE, &substitution);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL, L"dummy",
            FALSE, &substitution);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_NATIONAL, L"dummy",
            FALSE, &substitution);
    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
 
    /* invalid locale, but it's not needed for this method */
    hr = IDWriteFactory_CreateNumberSubstitution(factory, DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE, L"dummy", FALSE,
            &substitution);
    ok(hr == S_OK, "Failed to create number substitution, hr %#lx.\n", hr);
    IDWriteNumberSubstitution_Release(substitution);
}

Referenced by START_TEST().

test_uint()

static void test_uint ( UINT32  actual, UINT32  expected, const char *  name, const struct testcontext *  ctxt  )

static

Definition at line 183 of file analyzer.c.

{
    if (expected != actual && ctxt->todo)
    {
        (*ctxt->failcount)++;
        ok_(ctxt->file, ctxt->line) (0, "%s: \"%s\" expecting %u, got %u\n", get_analysis_kind_name(ctxt->kind), name, expected, actual);
    }
    else
        ok_(ctxt->file, ctxt->line) (expected == actual, "%s: \"%s\" expecting %u, got %u\n", get_analysis_kind_name(ctxt->kind), name,
            expected, actual);
}

Referenced by ok_sequence_().

Variable Documentation

analysissink

IDWriteTextAnalysisSink analysissink = { &analysissinkvtbl }

static

Definition at line 392 of file analyzer.c.

Referenced by test_AnalyzeBidi(), test_AnalyzeLineBreakpoints(), and test_AnalyzeScript().

analysissink2

IDWriteTextAnalysisSink analysissink2 = { &analysissinkvtbl2 }

static

Definition at line 393 of file analyzer.c.

Referenced by get_script_analysis().

analysissinkvtbl

IDWriteTextAnalysisSinkVtbl analysissinkvtbl

static

Initial value:

= {
    analysissink_QueryInterface,
    analysissink_AddRef,
    analysissink_Release,
    analysissink_SetScriptAnalysis,
    analysissink_SetLineBreakpoints,
    analysissink_SetBidiLevel,
    analysissink_SetNumberSubstitution
}

Definition at line 372 of file analyzer.c.

analysissinkvtbl2

IDWriteTextAnalysisSinkVtbl analysissinkvtbl2

static

Initial value:

= {
    analysissink_QueryInterface,
    analysissink_AddRef,
    analysissink_Release,
    analysissink_SetScriptAnalysis2,
    analysissink_SetLineBreakpoints,
    analysissink_SetBidiLevel,
    analysissink_SetNumberSubstitution
}

Definition at line 382 of file analyzer.c.

analysissource

struct testanalysissource analysissource = { { &analysissourcevtbl } }

static

Definition at line 494 of file analyzer.c.

Referenced by get_script_analysis(), test_AnalyzeBidi(), test_AnalyzeLineBreakpoints(), and test_AnalyzeScript().

analysissourcevtbl

IDWriteTextAnalysisSourceVtbl analysissourcevtbl

static

Initial value:

= {
    analysissource_QueryInterface,
    analysissource_AddRef,
    analysissource_Release,
    analysissource_GetTextAtPosition,
    analysissource_GetTextBeforePosition,
    analysissource_GetParagraphReadingDirection,
    analysissource_GetLocaleName,
    analysissource_GetNumberSubstitution
}

Definition at line 483 of file analyzer.c.

bidi_tests

const struct bidi_test bidi_tests[]

static

Definition at line 2654 of file analyzer.c.

Referenced by test_AnalyzeBidi().

expected_seq

struct call_sequence* expected_seq[1]

static

Definition at line 143 of file analyzer.c.

Referenced by START_TEST(), and test_AnalyzeScript().

factory

IDWriteFactory* factory

static

Definition at line 36 of file analyzer.c.

g_actual_bp

DWRITE_LINE_BREAKPOINT g_actual_bp[BREAKPOINT_COUNT]

static

Definition at line 330 of file analyzer.c.

Referenced by analysissink_SetLineBreakpoints(), compare_breakpoints(), and test_AnalyzeLineBreakpoints().

g_explicit_levels

UINT8 g_explicit_levels[BIDI_LEVELS_COUNT]

static

Definition at line 346 of file analyzer.c.

Referenced by analysissink_SetBidiLevel(), and test_AnalyzeBidi().

g_resolved_levels

UINT8 g_resolved_levels[BIDI_LEVELS_COUNT]

static

Definition at line 347 of file analyzer.c.

Referenced by analysissink_SetBidiLevel(), and test_AnalyzeBidi().

g_sa

DWRITE_SCRIPT_ANALYSIS g_sa

static

Definition at line 321 of file analyzer.c.

Referenced by analysissink_SetScriptAnalysis2(), and get_script_analysis().

linebreaks_tests

const struct linebreaks_test linebreaks_tests[]

static

Definition at line 1138 of file analyzer.c.

Referenced by test_AnalyzeLineBreakpoints().

ot_tests

const struct orientation_transf_test ot_tests[]

static

Initial value:

= {
    { DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES,   FALSE, {  1.0,  0.0,  0.0,  1.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES,  FALSE, {  0.0,  1.0, -1.0,  0.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES, FALSE, { -1.0,  0.0,  0.0, -1.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES, FALSE, {  0.0, -1.0,  1.0,  0.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES,   TRUE,  {  0.0,  1.0, -1.0,  0.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES,  TRUE,  { -1.0,  0.0,  0.0, -1.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES, TRUE,  {  0.0, -1.0,  1.0,  0.0, 0.0, 0.0 } },
    { DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES, TRUE,  {  1.0,  0.0,  0.0,  1.0, 0.0, 0.0 } }
}

Definition at line 2360 of file analyzer.c.

Referenced by test_GetGlyphOrientationTransform().

sa_tests

struct sa_test sa_tests[]

static

Definition at line 582 of file analyzer.c.

Referenced by test_AnalyzeScript().

sequences

struct call_sequence* sequences[NUM_CALL_SEQUENCES]

static

Definition at line 142 of file analyzer.c.

Referenced by analysissink_SetScriptAnalysis(), START_TEST(), and test_AnalyzeScript().

spacing_tests

const struct spacing_test spacing_tests[]

static

Definition at line 2054 of file analyzer.c.

Referenced by test_ApplyCharacterSpacing().

textcomplexity_tests

const struct textcomplexity_test textcomplexity_tests[]

static

Initial value:

= {
    { {0},                     1, FALSE, 1 },
    { {0},                     0,  TRUE, 0 },
    { {0x610,0},               0,  TRUE, 0 },
    { {'A','B','C','D',0},     3,  TRUE, 3 },
    { {'A','B','C','D',0},     5,  TRUE, 4 },
    { {'A','B','C','D',0},    10,  TRUE, 4 },
    { {'A',0x610,'C','D',0},   1,  TRUE, 1 },
    { {'A',0x610,'C','D',0},   2, FALSE, 2 },
    { {0x610,'A','C','D',0},   1, FALSE, 1 },
    { {0x610,'A','C','D',0},   2, FALSE, 1 },
    { {0x610,0x610,'C','D',0}, 2, FALSE, 2 },
    { {0xd800,'A','B',0},      1, FALSE, 1 },
    { {0xd800,'A','B',0},      2, FALSE, 1 },
    { {0xdc00,'A','B',0},      2, FALSE, 1 },
    { {0x202a,'A',0x202c,0},   3, FALSE, 1 },
    { {0x200e,'A',0},          2, FALSE, 1 },
    { {0x200f,'A',0},          2, FALSE, 1 },
    { {0x202d,'A',0},          2, FALSE, 1 },
    { {0x202e,'A',0},          2, FALSE, 1 },
 
}

Definition at line 1297 of file analyzer.c.

Referenced by test_GetTextComplexity().