usp10.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "winreg.h"
#include "usp10.h"
#include "usp10_internal.h"
#include "wine/debug.h"
#include "wine/heap.h"

Include dependency graph for usp10.c:

Go to the source code of this file.

Classes
struct	usp10_script_range
struct	StringGlyphs
struct	StringAnalysis
struct	FindGlyph_struct

Macros
#define	Numeric_space   0x0020
#define	ZWSP   0x200B
#define	ZWNJ   0x200C
#define	ZWJ   0x200D

Enumerations
enum	stringanalysis_flags { SCRIPT_STRING_ANALYSIS_FLAGS_SIZE = 0x1 , SCRIPT_STRING_ANALYSIS_FLAGS_INVALID = 0x2 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (uniscribe)
BOOL	usp10_array_reserve (void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size)
static BOOL	set_cache_font_properties (const HDC hdc, ScriptCache *sc)
static void	get_cache_font_properties (SCRIPT_FONTPROPERTIES *sfp, ScriptCache *sc)
static LONG	get_cache_height (SCRIPT_CACHE *psc)
static BYTE	get_cache_pitch_family (SCRIPT_CACHE *psc)
static WORD	get_cache_glyph (SCRIPT_CACHE *psc, DWORD c)
static WORD	set_cache_glyph (SCRIPT_CACHE *psc, WCHAR c, WORD glyph)
static BOOL	get_cache_glyph_widths (SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
static BOOL	set_cache_glyph_widths (SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
static HRESULT	init_script_cache (const HDC hdc, SCRIPT_CACHE *psc)
static WCHAR	mirror_char (WCHAR ch)
static DWORD	decode_surrogate_pair (const WCHAR *str, unsigned int index, unsigned int end)
static int __cdecl	usp10_compare_script_range (const void *key, const void *value)
static enum usp10_script	get_char_script (const WCHAR *str, unsigned int index, unsigned int end, unsigned int *consumed)
static int __cdecl	compare_FindGlyph (const void *a, const void *b)
int	USP10_FindGlyphInLogClust (const WORD *pwLogClust, int cChars, WORD target)
HRESULT WINAPI	ScriptFreeCache (SCRIPT_CACHE *psc)
HRESULT WINAPI	ScriptGetProperties (const SCRIPT_PROPERTIES ***props, int *num)
HRESULT WINAPI	ScriptGetFontProperties (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp)
HRESULT WINAPI	ScriptRecordDigitSubstitution (LCID locale, SCRIPT_DIGITSUBSTITUTE *sds)
HRESULT WINAPI	ScriptApplyDigitSubstitution (const SCRIPT_DIGITSUBSTITUTE *sds, SCRIPT_CONTROL *sc, SCRIPT_STATE *ss)
static BOOL	is_indic (enum usp10_script script)
static enum usp10_script	base_indic (enum usp10_script script)
static BOOL	script_is_numeric (enum usp10_script script)
static HRESULT	_ItemizeInternal (const WCHAR *pwcInChars, int cInChars, int cMaxItems, const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState, SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
HRESULT WINAPI	ScriptItemizeOpenType (const WCHAR *pwcInChars, int cInChars, int cMaxItems, const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState, SCRIPT_ITEM *pItems, OPENTYPE_TAG *pScriptTags, int *pcItems)
HRESULT WINAPI	ScriptItemize (const WCHAR *pwcInChars, int cInChars, int cMaxItems, const SCRIPT_CONTROL *psControl, const SCRIPT_STATE *psState, SCRIPT_ITEM *pItems, int *pcItems)
static int	getGivenTabWidth (ScriptCache *psc, SCRIPT_TABDEF *pTabdef, int charPos, int current_x)
static BOOL	requires_fallback (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, const WCHAR *pwcInChars, int cChars)
static void	find_fallback_font (enum usp10_script scriptid, WCHAR *FaceName)
HRESULT WINAPI	ScriptStringAnalyse (HDC hdc, const void *pString, int cString, int cGlyphs, int iCharset, DWORD dwFlags, int iReqWidth, SCRIPT_CONTROL *psControl, SCRIPT_STATE *psState, const int *piDx, SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass, SCRIPT_STRING_ANALYSIS *pssa)
static BOOL	does_glyph_start_cluster (const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cChars, int glyph, int direction)
static HRESULT	SS_ItemOut (SCRIPT_STRING_ANALYSIS ssa, int iX, int iY, int iItem, int cStart, int cEnd, UINT uOptions, const RECT *prc, BOOL fSelected, BOOL fDisabled)
HRESULT WINAPI	ScriptStringOut (SCRIPT_STRING_ANALYSIS ssa, int iX, int iY, UINT uOptions, const RECT *prc, int iMinSel, int iMaxSel, BOOL fDisabled)
HRESULT WINAPI	ScriptStringCPtoX (SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int *pX)
HRESULT WINAPI	ScriptStringXtoCP (SCRIPT_STRING_ANALYSIS ssa, int iX, int *piCh, int *piTrailing)
HRESULT WINAPI	ScriptStringFree (SCRIPT_STRING_ANALYSIS *pssa)
static int	get_cluster_size (const WORD *pwLogClust, int cChars, int item, int direction, int *iCluster, int *check_out)
static int	get_glyph_cluster_advance (const int *piAdvance, const SCRIPT_VISATTR *pva, const WORD *pwLogClust, int cGlyphs, int cChars, int glyph, int direction)
HRESULT WINAPI	ScriptCPtoX (int iCP, BOOL fTrailing, int cChars, int cGlyphs, const WORD *pwLogClust, const SCRIPT_VISATTR *psva, const int *piAdvance, const SCRIPT_ANALYSIS *psa, int *piX)
static BOOL	get_cluster_data (const WORD *pwLogClust, int cChars, int cluster_index, int *cluster_size, int *start_index)
static int	get_cluster_advance (const int *piAdvance, const SCRIPT_VISATTR *psva, const WORD *pwLogClust, int cGlyphs, int cChars, int cluster, int direction)
HRESULT WINAPI	ScriptXtoCP (int iX, int cChars, int cGlyphs, const WORD *pwLogClust, const SCRIPT_VISATTR *psva, const int *piAdvance, const SCRIPT_ANALYSIS *psa, int *piCP, int *piTrailing)
HRESULT WINAPI	ScriptBreak (const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
HRESULT WINAPI	ScriptIsComplex (const WCHAR *chars, int len, DWORD flag)
HRESULT WINAPI	ScriptShapeOpenType (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys, int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties, int cRanges, const WCHAR *pwcChars, int cChars, int cMaxGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProps, WORD *pwOutGlyphs, SCRIPT_GLYPHPROP *pOutGlyphProps, int *pcGlyphs)
HRESULT WINAPI	ScriptShape (HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcChars, int cChars, int cMaxGlyphs, SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust, SCRIPT_VISATTR *psva, int *pcGlyphs)
HRESULT WINAPI	ScriptPlaceOpenType (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys, int *rcRangeChars, TEXTRANGE_PROPERTIES **rpRangeProperties, int cRanges, const WCHAR *pwcChars, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProps, int cChars, const WORD *pwGlyphs, const SCRIPT_GLYPHPROP *pGlyphProps, int cGlyphs, int *piAdvance, GOFFSET *pGoffset, ABC *pABC)
HRESULT WINAPI	ScriptPlace (HDC hdc, SCRIPT_CACHE *psc, const WORD *pwGlyphs, int cGlyphs, const SCRIPT_VISATTR *psva, SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC)
HRESULT WINAPI	ScriptGetCMap (HDC hdc, SCRIPT_CACHE *psc, const WCHAR *pwcInChars, int cChars, DWORD dwFlags, WORD *pwOutGlyphs)
HRESULT WINAPI	ScriptTextOut (const HDC hdc, SCRIPT_CACHE *psc, int x, int y, UINT fuOptions, const RECT *lprc, const SCRIPT_ANALYSIS *psa, const WCHAR *pwcReserved, int iReserved, const WORD *pwGlyphs, int cGlyphs, const int *piAdvance, const int *piJustify, const GOFFSET *pGoffset)
HRESULT WINAPI	ScriptCacheGetHeight (HDC hdc, SCRIPT_CACHE *psc, LONG *height)
HRESULT WINAPI	ScriptGetGlyphABCWidth (HDC hdc, SCRIPT_CACHE *psc, WORD glyph, ABC *abc)
HRESULT WINAPI	ScriptLayout (int runs, const BYTE *level, int *vistolog, int *logtovis)
HRESULT WINAPI	ScriptStringGetLogicalWidths (SCRIPT_STRING_ANALYSIS ssa, int *piDx)
HRESULT WINAPI	ScriptStringValidate (SCRIPT_STRING_ANALYSIS ssa)
const SIZE *WINAPI	ScriptString_pSize (SCRIPT_STRING_ANALYSIS ssa)
const SCRIPT_LOGATTR *WINAPI	ScriptString_pLogAttr (SCRIPT_STRING_ANALYSIS ssa)
const int *WINAPI	ScriptString_pcOutChars (SCRIPT_STRING_ANALYSIS ssa)
HRESULT WINAPI	ScriptStringGetOrder (SCRIPT_STRING_ANALYSIS ssa, UINT *order)
HRESULT WINAPI	ScriptGetLogicalWidths (const SCRIPT_ANALYSIS *sa, int nbchars, int nbglyphs, const int *advances, const WORD *log_clust, const SCRIPT_VISATTR *sva, int *widths)
HRESULT WINAPI	ScriptApplyLogicalWidth (const int *dx, int num_chars, int num_glyphs, const WORD *log_clust, const SCRIPT_VISATTR *sva, const int *advance, const SCRIPT_ANALYSIS *sa, ABC *abc, int *justify)
HRESULT WINAPI	ScriptJustify (const SCRIPT_VISATTR *sva, const int *advance, int num_glyphs, int dx, int min_kashida, int *justify)
HRESULT WINAPI	ScriptGetFontScriptTags (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
HRESULT WINAPI	ScriptGetFontLanguageTags (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript, int cMaxTags, OPENTYPE_TAG *pLangSysTags, int *pcTags)
HRESULT WINAPI	ScriptGetFontFeatureTags (HDC hdc, SCRIPT_CACHE *psc, SCRIPT_ANALYSIS *psa, OPENTYPE_TAG tagScript, OPENTYPE_TAG tagLangSys, int cMaxTags, OPENTYPE_TAG *pFeatureTags, int *pcTags)

Variables
static const struct usp10_script_range	script_ranges []
const scriptData	scriptInformation []
static const SCRIPT_PROPERTIES *	script_props []
static CRITICAL_SECTION	cs_script_cache = { &cs_script_cache_dbg, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	cs_script_cache_dbg
static struct list	script_cache_list = LIST_INIT(script_cache_list)

Macro Definition Documentation

Numeric_space

#define Numeric_space   0x0020

ZWJ

#define ZWJ   0x200D

ZWNJ

#define ZWNJ   0x200C

ZWSP

#define ZWSP   0x200B

Enumeration Type Documentation

stringanalysis_flags

enum stringanalysis_flags

Enumerator
SCRIPT_STRING_ANALYSIS_FLAGS_SIZE
SCRIPT_STRING_ANALYSIS_FLAGS_INVALID

Definition at line 704 of file usp10.c.

{
    SCRIPT_STRING_ANALYSIS_FLAGS_SIZE    = 0x1,
    SCRIPT_STRING_ANALYSIS_FLAGS_INVALID = 0x2,
};

Function Documentation

_ItemizeInternal()

static HRESULT _ItemizeInternal ( const WCHAR *  pwcInChars, int  cInChars, int  cMaxItems, const SCRIPT_CONTROL *  psControl, const SCRIPT_STATE *  psState, SCRIPT_ITEM *  pItems, OPENTYPE_TAG *  pScriptTags, int *  pcItems  )

static

Definition at line 1344 of file usp10.c.

{
 
#define Numeric_space 0x0020
#define ZWSP 0x200B
#define ZWNJ 0x200C
#define ZWJ  0x200D
 
    enum usp10_script last_indic = Script_Undefined;
    int   cnt = 0, index = 0, str = 0;
    enum usp10_script New_Script = -1;
    int   i;
    WORD  *levels = NULL;
    WORD  *layout_levels = NULL;
    WORD  *overrides = NULL;
    WORD  *strength = NULL;
    enum usp10_script *scripts;
    WORD  baselevel = 0;
    WORD  baselayout = 0;
    BOOL  new_run;
    WORD layoutRTL = 0;
    BOOL forceLevels = FALSE;
    unsigned int consumed = 0;
    HRESULT res = E_OUTOFMEMORY;
 
    TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars, cInChars), cInChars, cMaxItems, 
          psControl, psState, pItems, pcItems);
 
    if (!pwcInChars || !cInChars || !pItems || cMaxItems < 2)
        return E_INVALIDARG;
 
    if (!(scripts = heap_calloc(cInChars, sizeof(*scripts))))
        return E_OUTOFMEMORY;
 
    for (i = 0; i < cInChars; i++)
    {
        if (!consumed)
        {
            scripts[i] = get_char_script(pwcInChars,i,cInChars,&consumed);
            consumed --;
        }
        else
        {
            scripts[i] = scripts[i-1];
            consumed --;
        }
        /* Devanagari danda (U+0964) and double danda (U+0965) are used for
           all Indic scripts */
        if ((pwcInChars[i] == 0x964 || pwcInChars[i] ==0x965) && last_indic != Script_Undefined)
            scripts[i] = last_indic;
        else if (is_indic(scripts[i]))
            last_indic = base_indic(scripts[i]);
 
        /* Some unicode points :
           (Zero Width Space U+200B - Right-to-Left Mark U+200F)
           (Left Right Embed U+202A - Left Right Override U+202D)
           (Left Right Isolate U+2066 - Pop Directional Isolate U+2069)
           will force us into bidi mode */
        if (!forceLevels && ((pwcInChars[i] >= 0x200B && pwcInChars[i] <= 0x200F) ||
            (pwcInChars[i] >= 0x202A && pwcInChars[i] <= 0x202E) ||
            (pwcInChars[i] >= 0x2066 && pwcInChars[i] <= 0x2069)))
 
            forceLevels = TRUE;
 
        /* Diacritical marks merge with other scripts */
        if (scripts[i] == Script_Diacritical)
        {
            if (i > 0)
            {
                if (pScriptTags)
                    scripts[i] = scripts[i-1];
                else
                {
                    int j;
                    BOOL asian = FALSE;
                    enum usp10_script first_script = scripts[i-1];
                    for (j = i-1; j >= 0 &&  scripts[j] == first_script && pwcInChars[j] != Numeric_space; j--)
                    {
                        enum usp10_script original = scripts[j];
                        if (original == Script_Ideograph || original == Script_Kana || original == Script_Yi || original == Script_CJK_Han || original == Script_Bopomofo)
                        {
                            asian = TRUE;
                            break;
                        }
                        if (original != Script_MathAlpha && scriptInformation[scripts[j]].props.fComplex)
                            break;
                        scripts[j] = scripts[i];
                        if (original == Script_Punctuation2)
                            break;
                    }
                    if (j >= 0 && (scriptInformation[scripts[j]].props.fComplex || asian))
                        scripts[i] = scripts[j];
                }
            }
        }
    }
 
    for (i = 0; i < cInChars; i++)
    {
        /* Joiners get merged preferencially right */
        if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ || pwcInChars[i] == ZWSP))
        {
            int j;
            if (i+1 == cInChars)
                scripts[i] = scripts[i-1];
            else
            {
                for (j = i+1; j < cInChars; j++)
                {
                    if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ
                            && pwcInChars[j] != ZWSP && pwcInChars[j] != Numeric_space)
                    {
                        scripts[i] = scripts[j];
                        break;
                    }
                }
            }
        }
    }
 
    if (psState && psControl)
    {
        if (!(levels = heap_calloc(cInChars, sizeof(*levels))))
            goto nomemory;
 
        if (!(overrides = heap_calloc(cInChars, sizeof(*overrides))))
            goto nomemory;
 
        if (!(layout_levels = heap_calloc(cInChars, sizeof(*layout_levels))))
            goto nomemory;
 
        if (psState->fOverrideDirection)
        {
            if (!forceLevels)
            {
                SCRIPT_STATE s = *psState;
                s.fOverrideDirection = FALSE;
                BIDI_DetermineLevels(pwcInChars, cInChars, &s, psControl, layout_levels, overrides);
                if (odd(layout_levels[0]))
                    forceLevels = TRUE;
                else for (i = 0; i < cInChars; i++)
                    if (layout_levels[i]!=layout_levels[0])
                    {
                        forceLevels = TRUE;
                        break;
                    }
            }
 
            BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels, overrides);
        }
        else
        {
            BIDI_DetermineLevels(pwcInChars, cInChars, psState, psControl, levels, overrides);
            memcpy(layout_levels, levels, cInChars * sizeof(WORD));
        }
        baselevel = levels[0];
        baselayout = layout_levels[0];
        for (i = 0; i < cInChars; i++)
            if (levels[i]!=levels[0])
                break;
        if (i >= cInChars && !odd(baselevel) && !odd(psState->uBidiLevel) && !forceLevels)
        {
            heap_free(levels);
            heap_free(overrides);
            heap_free(layout_levels);
            overrides = NULL;
            levels = NULL;
            layout_levels = NULL;
        }
        else
        {
            static const WCHAR math_punc[] = {'#','$','%','+',',','-','.','/',':',0x2212, 0x2044, 0x00a0,0};
            static const WCHAR repeatable_math_punc[] = {'#','$','%','+','-','/',0x2212, 0x2044,0};
 
            if (!(strength = heap_calloc(cInChars, sizeof(*strength))))
                goto nomemory;
            BIDI_GetStrengths(pwcInChars, cInChars, psControl, strength);
 
            /* We currently mis-level leading Diacriticals */
            if (scripts[0] == Script_Diacritical)
                for (i = 0; i < cInChars && scripts[0] == Script_Diacritical; i++)
                {
                    levels[i] = odd(levels[i])?levels[i]+1:levels[i];
                    strength[i] = BIDI_STRONG;
                }
 
            /* Math punctuation bordered on both sides by numbers can be
               merged into the number */
            for (i = 0; i < cInChars; i++)
            {
                if (i > 0 && i < cInChars-1 &&
                    script_is_numeric(scripts[i-1]) &&
                    wcschr(math_punc, pwcInChars[i]))
                {
                    if (script_is_numeric(scripts[i+1]))
                    {
                        scripts[i] = scripts[i+1];
                        levels[i] = levels[i-1];
                        strength[i] = strength[i-1];
                        i++;
                    }
                    else if (wcschr(repeatable_math_punc, pwcInChars[i]))
                    {
                        int j;
                        for (j = i+1; j < cInChars; j++)
                        {
                            if (script_is_numeric(scripts[j]))
                            {
                                for(;i<j; i++)
                                {
                                    scripts[i] = scripts[j];
                                    levels[i] = levels[i-1];
                                    strength[i] = strength[i-1];
                                }
                            }
                            else if (pwcInChars[i] != pwcInChars[j]) break;
                        }
                    }
                }
            }
 
            for (i = 0; i < cInChars; i++)
            {
                /* Numerics at level 0 get bumped to level 2 */
                if (!overrides[i] && (levels[i] == 0 || (odd(psState->uBidiLevel)
                        && levels[i] == psState->uBidiLevel + 1)) && script_is_numeric(scripts[i]))
                {
                    levels[i] = 2;
                }
 
                /* Joiners get merged preferencially right */
                if (i > 0 && (pwcInChars[i] == ZWJ || pwcInChars[i] == ZWNJ || pwcInChars[i] == ZWSP))
                {
                    int j;
                    if (i+1 == cInChars && levels[i-1] == levels[i])
                        strength[i] = strength[i-1];
                    else
                        for (j = i+1; j < cInChars && levels[i] == levels[j]; j++)
                            if (pwcInChars[j] != ZWJ && pwcInChars[j] != ZWNJ
                                    && pwcInChars[j] != ZWSP && pwcInChars[j] != Numeric_space)
                            {
                                strength[i] = strength[j];
                                break;
                            }
                }
            }
            if (psControl->fMergeNeutralItems)
            {
                /* Merge the neutrals */
                for (i = 0; i < cInChars; i++)
                {
                    if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
                    {
                        int j;
                        for (j = i; j > 0; j--)
                        {
                            if (levels[i] != levels[j])
                                break;
                            if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
                            {
                                scripts[i] = scripts[j];
                                strength[i] = strength[j];
                                break;
                            }
                        }
                    }
                    /* Try going the other way */
                    if (strength[i] == BIDI_NEUTRAL || strength[i] == BIDI_WEAK)
                    {
                        int j;
                        for (j = i; j < cInChars; j++)
                        {
                            if (levels[i] != levels[j])
                                break;
                            if ((strength[j] == BIDI_STRONG) || (strength[i] == BIDI_NEUTRAL && strength[j] == BIDI_WEAK))
                            {
                                scripts[i] = scripts[j];
                                strength[i] = strength[j];
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
 
    while ((!levels || (levels && cnt+1 < cInChars && levels[cnt+1] == levels[0]))
            && (cnt < cInChars && pwcInChars[cnt] == Numeric_space))
        cnt++;
 
    if (cnt == cInChars) /* All Spaces */
    {
        cnt = 0;
        New_Script = scripts[cnt];
    }
 
    pItems[index].iCharPos = 0;
    pItems[index].a = scriptInformation[scripts[cnt]].a;
    if (pScriptTags)
        pScriptTags[index] = scriptInformation[scripts[cnt]].scriptTag;
 
    if (strength && strength[cnt] == BIDI_STRONG)
        str = strength[cnt];
    else if (strength)
        str = strength[0];
 
    cnt = 0;
 
    if (levels)
    {
        if (strength[cnt] == BIDI_STRONG)
            layoutRTL = odd(layout_levels[cnt]);
        else
            layoutRTL = (psState->uBidiLevel || odd(layout_levels[cnt]));
        if (overrides)
            pItems[index].a.s.fOverrideDirection = (overrides[cnt] != 0);
        pItems[index].a.fRTL = odd(levels[cnt]);
        if (script_is_numeric(pItems[index].a.eScript))
            pItems[index].a.fLayoutRTL = layoutRTL;
        else
            pItems[index].a.fLayoutRTL = pItems[index].a.fRTL;
        pItems[index].a.s.uBidiLevel = levels[cnt];
    }
    else if (!pItems[index].a.s.uBidiLevel || (overrides && overrides[cnt]))
    {
        if (pItems[index].a.s.uBidiLevel != baselevel)
            pItems[index].a.s.fOverrideDirection = TRUE;
        layoutRTL = odd(baselayout);
        pItems[index].a.s.uBidiLevel = baselevel;
        pItems[index].a.fRTL = odd(baselevel);
        if (script_is_numeric(pItems[index].a.eScript))
            pItems[index].a.fLayoutRTL = odd(baselayout);
        else
            pItems[index].a.fLayoutRTL = pItems[index].a.fRTL;
    }
 
    TRACE("New_Level=%i New_Strength=%i New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
          levels?levels[cnt]:-1, str, New_Script, pItems[index].a.eScript, index, cnt,
          pItems[index].iCharPos);
 
    for (cnt=1; cnt < cInChars; cnt++)
    {
        if(pwcInChars[cnt] != Numeric_space)
            New_Script = scripts[cnt];
        else if (levels)
        {
            int j = 1;
            while (cnt + j < cInChars - 1 && pwcInChars[cnt+j] == Numeric_space && levels[cnt] == levels[cnt+j])
                j++;
            if (cnt + j < cInChars && levels[cnt] == levels[cnt+j])
                New_Script = scripts[cnt+j];
            else
                New_Script = scripts[cnt];
        }
 
        new_run = FALSE;
        /* merge space strengths*/
        if (strength && strength[cnt] == BIDI_STRONG && str != BIDI_STRONG && New_Script == pItems[index].a.eScript)
            str = BIDI_STRONG;
 
        if (strength && strength[cnt] == BIDI_NEUTRAL && str == BIDI_STRONG && pwcInChars[cnt] != Numeric_space && New_Script == pItems[index].a.eScript)
            str = BIDI_NEUTRAL;
 
        /* changes in level */
        if (levels && (levels[cnt] != pItems[index].a.s.uBidiLevel))
        {
            TRACE("Level break(%i/%i)\n",pItems[index].a.s.uBidiLevel,levels[cnt]);
            new_run = TRUE;
        }
        /* changes in strength */
        else if (strength && pwcInChars[cnt] != Numeric_space && str != strength[cnt])
        {
            TRACE("Strength break (%i/%i)\n",str,strength[cnt]);
            new_run = TRUE;
        }
        /* changes in script */
        else if (((pwcInChars[cnt] != Numeric_space) && (New_Script != -1) && (New_Script != pItems[index].a.eScript)) || (New_Script == Script_Control))
        {
            TRACE("Script break(%i/%i)\n",pItems[index].a.eScript,New_Script);
            new_run = TRUE;
        }
 
        if (!new_run && strength && str == BIDI_STRONG)
        {
            layoutRTL = odd(layout_levels[cnt]);
            if (script_is_numeric(pItems[index].a.eScript))
                pItems[index].a.fLayoutRTL = layoutRTL;
        }
 
        if (new_run)
        {
            TRACE("New_Level = %i, New_Strength = %i, New_Script=%d, eScript=%d\n", levels?levels[cnt]:-1, strength?strength[cnt]:str, New_Script, pItems[index].a.eScript);
 
            index++;
            if  (index+1 > cMaxItems)
                goto nomemory;
 
            if (strength)
                str = strength[cnt];
 
            pItems[index].iCharPos = cnt;
            memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
 
            pItems[index].a = scriptInformation[New_Script].a;
            if (pScriptTags)
                pScriptTags[index] = scriptInformation[New_Script].scriptTag;
            if (levels)
            {
                if (overrides)
                    pItems[index].a.s.fOverrideDirection = (overrides[cnt] != 0);
                if (layout_levels[cnt] == 0)
                    layoutRTL = 0;
                else
                    layoutRTL = (layoutRTL || odd(layout_levels[cnt]));
                pItems[index].a.fRTL = odd(levels[cnt]);
                if (script_is_numeric(pItems[index].a.eScript))
                    pItems[index].a.fLayoutRTL = layoutRTL;
                else
                    pItems[index].a.fLayoutRTL = pItems[index].a.fRTL;
                pItems[index].a.s.uBidiLevel = levels[cnt];
            }
            else if (!pItems[index].a.s.uBidiLevel || (overrides && overrides[cnt]))
            {
                if (pItems[index].a.s.uBidiLevel != baselevel)
                    pItems[index].a.s.fOverrideDirection = TRUE;
                pItems[index].a.s.uBidiLevel = baselevel;
                pItems[index].a.fRTL = odd(baselevel);
                if (script_is_numeric(pItems[index].a.eScript))
                    pItems[index].a.fLayoutRTL = layoutRTL;
                else
                    pItems[index].a.fLayoutRTL = pItems[index].a.fRTL;
            }
 
            TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
        }
    }
 
    /* While not strictly necessary according to the spec, make sure the n+1
     * item is set up to prevent random behaviour if the caller erroneously
     * checks the n+1 structure                                              */
    index++;
    if (index + 1 > cMaxItems) goto nomemory;
    memset(&pItems[index].a, 0, sizeof(SCRIPT_ANALYSIS));
 
    TRACE("index=%d cnt=%d iCharPos=%d\n", index, cnt, pItems[index].iCharPos);
 
    /*  Set one SCRIPT_STATE item being returned  */
    if (pcItems) *pcItems = index;
 
    /*  Set SCRIPT_ITEM                                     */
    pItems[index].iCharPos = cnt;         /* the last item contains the ptr to the lastchar */
    res = S_OK;
nomemory:
    heap_free(levels);
    heap_free(overrides);
    heap_free(layout_levels);
    heap_free(strength);
    heap_free(scripts);
    return res;
}

Referenced by ScriptItemize(), and ScriptItemizeOpenType().

base_indic()

static enum usp10_script base_indic ( enum usp10_script  script )

inlinestatic

Definition at line 1310 of file usp10.c.

{
    switch (script)
    {
        case Script_Devanagari:
        case Script_Devanagari_Numeric: return Script_Devanagari;
        case Script_Bengali:
        case Script_Bengali_Numeric:
        case Script_Bengali_Currency: return Script_Bengali;
        case Script_Gurmukhi:
        case Script_Gurmukhi_Numeric: return Script_Gurmukhi;
        case Script_Gujarati:
        case Script_Gujarati_Numeric:
        case Script_Gujarati_Currency: return Script_Gujarati;
        case Script_Oriya:
        case Script_Oriya_Numeric: return Script_Oriya;
        case Script_Tamil:
        case Script_Tamil_Numeric: return Script_Tamil;
        case Script_Telugu:
        case Script_Telugu_Numeric: return Script_Telugu;
        case Script_Kannada:
        case Script_Kannada_Numeric: return Script_Kannada;
        case Script_Malayalam:
        case Script_Malayalam_Numeric: return Script_Malayalam;
        default:
            return Script_Undefined;
    };
}

Referenced by _ItemizeInternal().

compare_FindGlyph()

static int __cdecl compare_FindGlyph ( const void *  a, const void *  b  )

static

Definition at line 1028 of file usp10.c.

{
    const FindGlyph_struct *find = (FindGlyph_struct*)a;
    const WORD *idx= (WORD*)b;
    int rc = 0;
 
    if ( find->target > *idx)
        rc = 1;
    else if (find->target < *idx)
        rc = -1;
 
    if (!find->ascending)
        rc *= -1;
    return rc;
}

Referenced by USP10_FindGlyphInLogClust().

decode_surrogate_pair()

static DWORD decode_surrogate_pair ( const WCHAR *  str, unsigned int  index, unsigned int  end  )

static

Definition at line 946 of file usp10.c.

{
    if (index < end-1 && IS_SURROGATE_PAIR(str[index],str[index+1]))
    {
        DWORD ch = 0x10000 + ((str[index] - 0xd800) << 10) + (str[index+1] - 0xdc00);
        TRACE("Surrogate Pair %x %x => %x\n",str[index], str[index+1], ch);
        return ch;
    }
    return 0;
}

Referenced by get_char_script(), and ScriptShapeOpenType().

does_glyph_start_cluster()

static BOOL does_glyph_start_cluster ( const SCRIPT_VISATTR *  pva, const WORD *  pwLogClust, int  cChars, int  glyph, int  direction  )

inlinestatic

Definition at line 2210 of file usp10.c.

{
    if (pva[glyph].fClusterStart)
        return TRUE;
    if (USP10_FindGlyphInLogClust(pwLogClust, cChars, glyph) >= 0)
        return TRUE;
 
    return FALSE;
}

Referenced by get_glyph_cluster_advance(), and SS_ItemOut().

find_fallback_font()

static void find_fallback_font ( enum usp10_script  scriptid, WCHAR *  FaceName  )

static

Definition at line 1961 of file usp10.c.

{
    HKEY hkey;
 
    if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Uniscribe\\Fallback", &hkey))
    {
        static const WCHAR szFmt[] = {'%','x',0};
        WCHAR value[10];
        DWORD count = LF_FACESIZE * sizeof(WCHAR);
        DWORD type;
 
        swprintf(value, szFmt, scriptInformation[scriptid].scriptTag);
        if (RegQueryValueExW(hkey, value, 0, &type, (BYTE *)FaceName, &count))
            lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
        RegCloseKey(hkey);
    }
    else
        lstrcpyW(FaceName,scriptInformation[scriptid].fallbackFont);
}

Referenced by ScriptStringAnalyse().

get_cache_font_properties()

static void get_cache_font_properties ( SCRIPT_FONTPROPERTIES *  sfp, ScriptCache *  sc  )

inlinestatic

Definition at line 810 of file usp10.c.

{
    *sfp = sc->sfp;
}

Referenced by ScriptGetFontProperties().

get_cache_glyph()

static WORD get_cache_glyph ( SCRIPT_CACHE *  psc, DWORD  c  )

inlinestatic

Definition at line 825 of file usp10.c.

{
    CacheGlyphPage *page = ((ScriptCache *)*psc)->page[c / 0x10000];
    WORD *block;
 
    if (!page) return 0;
    block = page->glyphs[(c % 0x10000) >> GLYPH_BLOCK_SHIFT];
    if (!block) return 0;
    return block[(c % 0x10000) & GLYPH_BLOCK_MASK];
}

Referenced by ScriptGetCMap(), and ScriptShapeOpenType().

get_cache_glyph_widths()

static BOOL get_cache_glyph_widths ( SCRIPT_CACHE *  psc, WORD  glyph, ABC *  abc  )

inlinestatic

Definition at line 847 of file usp10.c.

{
    static const ABC nil;
    ABC *block = ((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 
    if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(ABC))) return FALSE;
    memcpy(abc, &block[glyph & GLYPH_BLOCK_MASK], sizeof(ABC));
    return TRUE;
}

Referenced by ScriptGetGlyphABCWidth(), and ScriptPlaceOpenType().

get_cache_height()

static LONG get_cache_height ( SCRIPT_CACHE *  psc )

inlinestatic

Definition at line 815 of file usp10.c.

{
    return ((ScriptCache *)*psc)->tm.tmHeight;
}

Referenced by ScriptCacheGetHeight().

get_cache_pitch_family()

static BYTE get_cache_pitch_family ( SCRIPT_CACHE *  psc )

inlinestatic

Definition at line 820 of file usp10.c.

{
    return ((ScriptCache *)*psc)->tm.tmPitchAndFamily;
}

Referenced by ScriptGetGlyphABCWidth(), and ScriptPlaceOpenType().

get_char_script()

static enum usp10_script get_char_script ( const WCHAR *  str, unsigned int  index, unsigned int  end, unsigned int *  consumed  )

static

Definition at line 969 of file usp10.c.

{
    static const WCHAR latin_punc[] = {'#','$','&','\'',',',';','<','>','?','@','\\','^','_','`','{','|','}','~', 0x00a0, 0};
    struct usp10_script_range *range;
    WORD type = 0, type2 = 0;
    DWORD ch;
 
    *consumed = 1;
 
    if (str[index] == 0xc || str[index] == 0x20 || str[index] == 0x202f)
        return Script_CR;
 
    /* These punctuation characters are separated out as Latin punctuation */
    if (wcschr(latin_punc,str[index]))
        return Script_Punctuation2;
 
    /* These chars are itemized as Punctuation by Windows */
    if (str[index] == 0x2212 || str[index] == 0x2044)
        return Script_Punctuation;
 
    /* Currency Symbols by Unicode point */
    switch (str[index])
    {
        case 0x09f2:
        case 0x09f3: return Script_Bengali_Currency;
        case 0x0af1: return Script_Gujarati_Currency;
        case 0x0e3f: return Script_Thai_Currency;
        case 0x20aa: return Script_Hebrew_Currency;
        case 0x20ab: return Script_Vietnamese_Currency;
        case 0xfb29: return Script_Hebrew_Currency;
    }
 
    GetStringTypeW(CT_CTYPE1, &str[index], 1, &type);
    GetStringTypeW(CT_CTYPE2, &str[index], 1, &type2);
 
    if (type == 0)
        return SCRIPT_UNDEFINED;
 
    if (type & C1_CNTRL)
        return Script_Control;
 
    ch = decode_surrogate_pair(str, index, end);
    if (ch)
        *consumed = 2;
    else
        ch = str[index];
 
    if (!(range = bsearch(&ch, script_ranges, ARRAY_SIZE(script_ranges),
            sizeof(*script_ranges), usp10_compare_script_range)))
        return (*consumed == 2) ? Script_Surrogates : Script_Undefined;
 
    if (range->numericScript && (type & C1_DIGIT || type2 == C2_ARABICNUMBER))
        return range->numericScript;
    if (range->punctScript && type & C1_PUNCT)
        return range->punctScript;
    return range->script;
}

Referenced by _ItemizeInternal(), and ScriptIsComplex().

get_cluster_advance()

static int get_cluster_advance ( const int *  piAdvance, const SCRIPT_VISATTR *  psva, const WORD *  pwLogClust, int  cGlyphs, int  cChars, int  cluster, int  direction  )

inlinestatic

Definition at line 2814 of file usp10.c.

{
    int glyph_start;
    int glyph_end;
    int i, advance;
 
    if (direction > 0)
        i = 0;
    else
        i = (cChars - 1);
 
    for (glyph_start = -1, glyph_end = -1; i < cChars && i >= 0 && (glyph_start < 0 || glyph_end < 0); i+=direction)
    {
        if (glyph_start < 0 && pwLogClust[i] != cluster) continue;
        if (pwLogClust[i] == cluster && glyph_start < 0) glyph_start = pwLogClust[i];
        if (glyph_start >= 0 && glyph_end < 0 && pwLogClust[i] != cluster) glyph_end = pwLogClust[i];
    }
    if (glyph_end < 0)
    {
        if (direction > 0)
            glyph_end = cGlyphs;
        else
        {
            /* Don't fully understand multi-glyph reversed clusters yet,
             * do they occur for real or just in our test? */
            FIXME("multi-glyph reversed clusters found\n");
            glyph_end = glyph_start + 1;
        }
    }
 
    /* Check for fClusterStart, finding this generally would mean a malformed set of data */
    for (i = glyph_start+1; i< glyph_end; i++)
    {
        if (psva[i].fClusterStart)
        {
            glyph_end = i;
            break;
        }
    }
 
    for (advance = 0, i = glyph_start; i < glyph_end; i++)
        advance += piAdvance[i];
 
    return advance;
}

Referenced by ScriptXtoCP().

get_cluster_data()

static BOOL get_cluster_data ( const WORD *  pwLogClust, int  cChars, int  cluster_index, int *  cluster_size, int *  start_index  )

inlinestatic

Definition at line 2781 of file usp10.c.

{
    int size = 0;
    int i;
 
    for (i = 0; i < cChars; i++)
    {
        if (pwLogClust[i] == cluster_index)
        {
            if (!size && start_index)
            {
                *start_index = i;
                if (!cluster_size)
                    return TRUE;
            }
            size++;
        }
        else if (size) break;
    }
    if (cluster_size)
        *cluster_size = size;
 
    return (size > 0);
}

Referenced by ScriptXtoCP().

get_cluster_size()

static int get_cluster_size ( const WORD *  pwLogClust, int  cChars, int  item, int  direction, int *  iCluster, int *  check_out  )

inlinestatic

Definition at line 2615 of file usp10.c.

{
    int clust_size = 1;
    int check;
    WORD clust = pwLogClust[item];
 
    for (check = item+direction; check < cChars && check >= 0; check+=direction)
    {
        if (pwLogClust[check] == clust)
        {
            clust_size ++;
            if (iCluster && *iCluster == -1)
                *iCluster = item;
        }
        else break;
    }
 
    if (check_out)
        *check_out = check;
 
    return clust_size;
}

Referenced by ScriptCPtoX(), ScriptGetLogicalWidths(), and ScriptStringGetLogicalWidths().

get_glyph_cluster_advance()

static int get_glyph_cluster_advance ( const int *  piAdvance, const SCRIPT_VISATTR *  pva, const WORD *  pwLogClust, int  cGlyphs, int  cChars, int  glyph, int  direction  )

inlinestatic

Definition at line 2639 of file usp10.c.

{
    int advance;
    int log_clust_max;
 
    advance = piAdvance[glyph];
 
    if (pwLogClust[0] > pwLogClust[cChars-1])
        log_clust_max = pwLogClust[0];
    else
        log_clust_max = pwLogClust[cChars-1];
 
    if (glyph > log_clust_max)
        return advance;
 
    for (glyph+=direction; glyph < cGlyphs && glyph >= 0; glyph +=direction)
    {
 
        if (does_glyph_start_cluster(pva, pwLogClust, cChars, glyph, direction))
            break;
        if (glyph > log_clust_max)
            break;
        advance += piAdvance[glyph];
    }
 
    return advance;
}

Referenced by ScriptCPtoX(), ScriptGetLogicalWidths(), and ScriptStringGetLogicalWidths().

getGivenTabWidth()

static int getGivenTabWidth ( ScriptCache *  psc, SCRIPT_TABDEF *  pTabdef, int  charPos, int  current_x  )

inlinestatic

Definition at line 1860 of file usp10.c.

{
    int defWidth;
    int cTabStops=0;
    INT *lpTabPos = NULL;
    INT nTabOrg = 0;
    INT x = 0;
 
    if (pTabdef)
        lpTabPos = pTabdef->pTabStops;
 
    if (pTabdef && pTabdef->iTabOrigin)
    {
        if (pTabdef->iScale)
            nTabOrg = (pTabdef->iTabOrigin * pTabdef->iScale)/4;
        else
            nTabOrg = pTabdef->iTabOrigin * psc->tm.tmAveCharWidth;
    }
 
    if (pTabdef)
        cTabStops = pTabdef->cTabStops;
 
    if (cTabStops == 1)
    {
        if (pTabdef->iScale)
            defWidth = ((pTabdef->pTabStops[0])*pTabdef->iScale) / 4;
        else
            defWidth = (pTabdef->pTabStops[0])*psc->tm.tmAveCharWidth;
        cTabStops = 0;
    }
    else
    {
        if (pTabdef->iScale)
            defWidth = (32 * pTabdef->iScale) / 4;
        else
            defWidth = 8 * psc->tm.tmAveCharWidth;
    }
 
    for (; cTabStops>0 ; lpTabPos++, cTabStops--)
    {
        int position = *lpTabPos;
        if (position < 0)
            position = -1 * position;
        if (pTabdef->iScale)
            position = (position * pTabdef->iScale) / 4;
        else
            position = position * psc->tm.tmAveCharWidth;
 
        if( nTabOrg + position > current_x)
        {
            if( position >= 0)
            {
                /* a left aligned tab */
                x = (nTabOrg + position) - current_x;
                break;
            }
            else
            {
                FIXME("Negative tabstop\n");
                break;
            }
        }
    }
    if ((!cTabStops) && (defWidth > 0))
        x =((((current_x - nTabOrg) / defWidth)+1) * defWidth) - current_x;
    else if ((!cTabStops) && (defWidth < 0))
        FIXME("TODO: Negative defWidth\n");
 
    return x;
}

Referenced by ScriptStringAnalyse().

init_script_cache()

static HRESULT init_script_cache ( const HDC  hdc, SCRIPT_CACHE *  psc  )

static

Definition at line 866 of file usp10.c.

{
    ScriptCache *sc;
    unsigned size;
    LOGFONTW lf;
 
    if (!psc) return E_INVALIDARG;
    if (*psc) return S_OK;
    if (!hdc) return E_PENDING;
 
    if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf))
    {
        return E_INVALIDARG;
    }
    /* Ensure canonical result by zeroing extra space in lfFaceName */
    size = lstrlenW(lf.lfFaceName);
    memset(lf.lfFaceName + size, 0, sizeof(lf.lfFaceName) - size * sizeof(WCHAR));
 
    EnterCriticalSection(&cs_script_cache);
    LIST_FOR_EACH_ENTRY(sc, &script_cache_list, ScriptCache, entry)
    {
        if (!memcmp(&sc->lf, &lf, sizeof(lf)))
        {
            sc->refcount++;
            LeaveCriticalSection(&cs_script_cache);
            *psc = sc;
            return S_OK;
        }
    }
    LeaveCriticalSection(&cs_script_cache);
 
    if (!(sc = heap_alloc_zero(sizeof(ScriptCache)))) return E_OUTOFMEMORY;
    if (!GetTextMetricsW(hdc, &sc->tm))
    {
        heap_free(sc);
        return E_INVALIDARG;
    }
    size = GetOutlineTextMetricsW(hdc, 0, NULL);
    if (size)
    {
        sc->otm = heap_alloc(size);
        sc->otm->otmSize = size;
        GetOutlineTextMetricsW(hdc, size, sc->otm);
    }
    sc->sfnt = (GetFontData(hdc, MS_MAKE_TAG('h','e','a','d'), 0, NULL, 0)!=GDI_ERROR);
    if (!set_cache_font_properties(hdc, sc))
    {
        heap_free(sc);
        return E_INVALIDARG;
    }
    sc->lf = lf;
    sc->refcount = 1;
    *psc = sc;
 
    EnterCriticalSection(&cs_script_cache);
    list_add_head(&script_cache_list, &sc->entry);
    LIST_FOR_EACH_ENTRY(sc, &script_cache_list, ScriptCache, entry)
    {
        if (sc != *psc && !memcmp(&sc->lf, &lf, sizeof(lf)))
        {
            /* Another thread won the race. Use their cache instead of ours */
            list_remove(&sc->entry);
            sc->refcount++;
            LeaveCriticalSection(&cs_script_cache);
            heap_free(*psc);
            *psc = sc;
            return S_OK;
        }
    }
    LeaveCriticalSection(&cs_script_cache);
    TRACE("<- %p\n", sc);
    return S_OK;
}

Referenced by requires_fallback(), ScriptCacheGetHeight(), ScriptGetCMap(), ScriptGetFontFeatureTags(), ScriptGetFontLanguageTags(), ScriptGetFontProperties(), ScriptGetFontScriptTags(), ScriptGetGlyphABCWidth(), ScriptPlaceOpenType(), and ScriptShapeOpenType().

is_indic()

static BOOL is_indic ( enum usp10_script  script )

inlinestatic

Definition at line 1305 of file usp10.c.

{
    return (script >= Script_Devanagari && script <= Script_Malayalam_Numeric);
}

Referenced by _ItemizeInternal().

mirror_char()

static WCHAR mirror_char ( WCHAR  ch )

static

Definition at line 940 of file usp10.c.

{
    extern const WCHAR wine_mirror_map[] DECLSPEC_HIDDEN;
    return ch + wine_mirror_map[wine_mirror_map[ch >> 8] + (ch & 0xff)];
}

Referenced by ScriptGetCMap(), and ScriptShapeOpenType().

requires_fallback()

static BOOL requires_fallback ( HDC  hdc, SCRIPT_CACHE *  psc, SCRIPT_ANALYSIS *  psa, const WCHAR *  pwcInChars, int  cChars  )

static

Definition at line 1934 of file usp10.c.

{
    /* FIXME: When to properly fallback is still a bit of a mystery */
    WORD *glyphs;
 
    if (psa->fNoGlyphIndex)
        return FALSE;
 
    if (init_script_cache(hdc, psc) != S_OK)
        return FALSE;
 
    if (SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa) != S_OK)
        return TRUE;
 
    if (!(glyphs = heap_calloc(cChars, sizeof(*glyphs))))
        return FALSE;
    if (ScriptGetCMap(hdc, psc, pwcInChars, cChars, 0, glyphs) != S_OK)
    {
        heap_free(glyphs);
        return TRUE;
    }
    heap_free(glyphs);
 
    return FALSE;
}

Referenced by ScriptStringAnalyse().

script_is_numeric()

static BOOL script_is_numeric ( enum usp10_script  script )

static

Definition at line 1339 of file usp10.c.

{
    return scriptInformation[script].props.fNumeric;
}

Referenced by _ItemizeInternal().

ScriptApplyDigitSubstitution()

HRESULT WINAPI ScriptApplyDigitSubstitution	(	const SCRIPT_DIGITSUBSTITUTE *	sds,
		SCRIPT_CONTROL *	sc,
		SCRIPT_STATE *	ss
	)

Definition at line 1275 of file usp10.c.

{
    SCRIPT_DIGITSUBSTITUTE psds;
 
    TRACE("%p, %p, %p\n", sds, sc, ss);
 
    if (!sc || !ss) return E_POINTER;
    if (!sds)
    {
        sds = &psds;
        if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &psds) != S_OK)
            return E_INVALIDARG;
    }
 
    sc->uDefaultLanguage = LANG_ENGLISH;
    sc->fContextDigits = 0;
    ss->fDigitSubstitute = 0;
 
    switch (sds->DigitSubstitute) {
        case SCRIPT_DIGITSUBSTITUTE_CONTEXT:
        case SCRIPT_DIGITSUBSTITUTE_NATIONAL:
        case SCRIPT_DIGITSUBSTITUTE_NONE:
        case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL:
            return S_OK;
        default:
            return E_INVALIDARG;
    }
}

Referenced by enum_proc().

ScriptApplyLogicalWidth()

HRESULT WINAPI ScriptApplyLogicalWidth	(	const int *	dx,
		int	num_chars,
		int	num_glyphs,
		const WORD *	log_clust,
		const SCRIPT_VISATTR *	sva,
		const int *	advance,
		const SCRIPT_ANALYSIS *	sa,
		ABC *	abc,
		int *	justify
	)

Definition at line 4070 of file usp10.c.

{
    int i;
 
    FIXME("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n",
          dx, num_chars, num_glyphs, log_clust, sva, advance, sa, abc, justify);
 
    for (i = 0; i < num_chars; i++) justify[i] = advance[i];
    return S_OK;
}

ScriptBreak()

HRESULT WINAPI ScriptBreak	(	const WCHAR *	chars,
		int	count,
		const SCRIPT_ANALYSIS *	sa,
		SCRIPT_LOGATTR *	la
	)

Definition at line 3068 of file usp10.c.

{
    TRACE("(%s, %d, %p, %p)\n", debugstr_wn(chars, count), count, sa, la);
 
    if (count < 0 || !la) return E_INVALIDARG;
    if (count == 0) return E_FAIL;
 
    BREAK_line(chars, count, sa, la);
 
    return S_OK;
}

Referenced by EDIT_WordBreakProc(), ScriptStringAnalyse(), test_ScriptBreak(), test_ScriptTextOut(), and word_break().

ScriptCacheGetHeight()

HRESULT WINAPI ScriptCacheGetHeight	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		LONG *	height
	)

Definition at line 3701 of file usp10.c.

{
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", hdc, psc, height);
 
    if (!height) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    *height = get_cache_height(psc);
    return S_OK;
}

Referenced by test_script_cache_reuse(), and test_ScriptCacheGetHeight().

ScriptCPtoX()

HRESULT WINAPI ScriptCPtoX	(	int	iCP,
		BOOL	fTrailing,
		int	cChars,
		int	cGlyphs,
		const WORD *	pwLogClust,
		const SCRIPT_VISATTR *	psva,
		const int *	piAdvance,
		const SCRIPT_ANALYSIS *	psa,
		int *	piX
	)

Definition at line 2671 of file usp10.c.

{
    int item;
    float iPosX;
    int iSpecial = -1;
    int iCluster = -1;
    int clust_size = 1;
    float special_size = 0.0;
    int iMaxPos = 0;
    int advance = 0;
    BOOL rtl = FALSE;
 
    TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
          iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance,
          psa, piX);
 
    if (psa->fRTL && ! psa->fLogicalOrder)
        rtl = TRUE;
 
    if (fTrailing)
        iCP++;
 
    if (rtl)
    {
        int max_clust = pwLogClust[0];
 
        for (item=0; item < cGlyphs; item++)
            if (pwLogClust[item] > max_clust)
            {
                ERR("We do not handle non reversed clusters properly\n");
                break;
            }
 
        iMaxPos = 0;
        for (item = max_clust; item >=0; item --)
            iMaxPos += piAdvance[item];
    }
 
    iPosX = 0.0;
    for (item=0; item < iCP && item < cChars; item++)
    {
        if (iSpecial == -1 && (iCluster == -1 || iCluster+clust_size <= item))
        {
            int check;
            int clust = pwLogClust[item];
 
            iCluster = -1;
            clust_size = get_cluster_size(pwLogClust, cChars, item, 1, &iCluster,
                                          &check);
 
            advance = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, clust, 1);
 
            if (check >= cChars && !iMaxPos)
            {
                int glyph;
                for (glyph = clust; glyph < cGlyphs; glyph++)
                    special_size += get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, glyph, 1);
                iSpecial = item;
                special_size /= (cChars - item);
                iPosX += special_size;
            }
            else
            {
                if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
                {
                    clust_size --;
                    if (clust_size == 0)
                        iPosX += advance;
                }
                else
                    iPosX += advance / (float)clust_size;
            }
        }
        else if (iSpecial != -1)
            iPosX += special_size;
        else /* (iCluster != -1) */
        {
            int adv = get_glyph_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, pwLogClust[iCluster], 1);
            if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
            {
                clust_size --;
                if (clust_size == 0)
                    iPosX += adv;
            }
            else
                iPosX += adv / (float)clust_size;
        }
    }
 
    if (iMaxPos > 0)
    {
        iPosX = iMaxPos - iPosX;
        if (iPosX < 0)
            iPosX = 0;
    }
 
    *piX = iPosX;
    TRACE("*piX=%d\n", *piX);
    return S_OK;
}

Referenced by _test_item_ScriptXtoX(), ME_PointFromCharContext(), ScriptStringCPtoX(), ScriptStringXtoCP(), and test_ScriptTextOut().

ScriptFreeCache()

HRESULT WINAPI ScriptFreeCache

(

SCRIPT_CACHE *

psc

)

Definition at line 1080 of file usp10.c.

{
    TRACE("%p\n", psc);
 
    if (psc && *psc)
    {
        unsigned int i;
        INT n;
 
        EnterCriticalSection(&cs_script_cache);
        if (--((ScriptCache *)*psc)->refcount > 0)
        {
            LeaveCriticalSection(&cs_script_cache);
            *psc = NULL;
            return S_OK;
        }
        list_remove(&((ScriptCache *)*psc)->entry);
        LeaveCriticalSection(&cs_script_cache);
 
        for (i = 0; i < GLYPH_MAX / GLYPH_BLOCK_SIZE; i++)
        {
            heap_free(((ScriptCache *)*psc)->widths[i]);
        }
        for (i = 0; i < NUM_PAGES; i++)
        {
            unsigned int j;
            if (((ScriptCache *)*psc)->page[i])
                for (j = 0; j < GLYPH_MAX / GLYPH_BLOCK_SIZE; j++)
                    heap_free(((ScriptCache *)*psc)->page[i]->glyphs[j]);
            heap_free(((ScriptCache *)*psc)->page[i]);
        }
        heap_free(((ScriptCache *)*psc)->GSUB_Table);
        heap_free(((ScriptCache *)*psc)->GDEF_Table);
        heap_free(((ScriptCache *)*psc)->CMAP_Table);
        heap_free(((ScriptCache *)*psc)->GPOS_Table);
        for (n = 0; n < ((ScriptCache *)*psc)->script_count; n++)
        {
            int j;
            for (j = 0; j < ((ScriptCache *)*psc)->scripts[n].language_count; j++)
            {
                int k;
                for (k = 0; k < ((ScriptCache *)*psc)->scripts[n].languages[j].feature_count; k++)
                    heap_free(((ScriptCache *)*psc)->scripts[n].languages[j].features[k].lookups);
                heap_free(((ScriptCache *)*psc)->scripts[n].languages[j].features);
            }
            for (j = 0; j < ((ScriptCache *)*psc)->scripts[n].default_language.feature_count; j++)
                heap_free(((ScriptCache *)*psc)->scripts[n].default_language.features[j].lookups);
            heap_free(((ScriptCache *)*psc)->scripts[n].default_language.features);
            heap_free(((ScriptCache *)*psc)->scripts[n].languages);
        }
        heap_free(((ScriptCache *)*psc)->scripts);
        heap_free(((ScriptCache *)*psc)->otm);
        heap_free(*psc);
        *psc = NULL;
    }
    return S_OK;
}

Referenced by _test_shape_ok(), BIDI_Reorder(), ME_DestroyStyle(), ME_SetDefaultCharFormat(), ScriptStringAnalyse(), ScriptStringFree(), test_script_cache_reuse(), test_ScriptCacheGetHeight(), test_ScriptGetCMap(), test_ScriptGetFontFunctions(), test_ScriptGetFontProperties(), test_ScriptGetGlyphABCWidth(), test_ScriptItemIzeShapePlace(), test_ScriptPlace(), test_ScriptShape(), test_ScriptShapeOpenType(), test_ScriptTextOut(), test_ScriptTextOut2(), and test_ScriptTextOut3().

ScriptGetCMap()

HRESULT WINAPI ScriptGetCMap	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		const WCHAR *	pwcInChars,
		int	cChars,
		DWORD	dwFlags,
		WORD *	pwOutGlyphs
	)

Definition at line 3575 of file usp10.c.

{
    HRESULT hr;
    int i;
 
    TRACE("(%p,%p,%s,%d,0x%x,%p)\n", hdc, psc, debugstr_wn(pwcInChars, cChars),
          cChars, dwFlags, pwOutGlyphs);
 
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    hr = S_OK;
 
    for (i = 0; i < cChars; i++)
    {
        WCHAR inChar;
        if (dwFlags == SGCM_RTL)
            inChar = mirror_char(pwcInChars[i]);
        else
            inChar = pwcInChars[i];
        if (!(pwOutGlyphs[i] = get_cache_glyph(psc, inChar)))
        {
            WORD glyph;
            if (!hdc) return E_PENDING;
            if (GetGlyphIndicesW(hdc, &inChar, 1, &glyph, GGI_MARK_NONEXISTING_GLYPHS) == GDI_ERROR) return S_FALSE;
            if (glyph == 0xffff)
            {
                hr = S_FALSE;
                glyph = 0x0;
            }
            pwOutGlyphs[i] = set_cache_glyph(psc, inChar, glyph);
        }
    }
 
    return hr;
}

Referenced by requires_fallback(), ScriptPlaceOpenType(), and test_ScriptGetCMap().

ScriptGetFontFeatureTags()

HRESULT WINAPI ScriptGetFontFeatureTags	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		SCRIPT_ANALYSIS *	psa,
		OPENTYPE_TAG	tagScript,
		OPENTYPE_TAG	tagLangSys,
		int	cMaxTags,
		OPENTYPE_TAG *	pFeatureTags,
		int *	pcTags
	)

Definition at line 4113 of file usp10.c.

{
    HRESULT hr;
    if (!pFeatureTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    return SHAPE_GetFontFeatureTags(hdc, (ScriptCache *)*psc, psa, tagScript, tagLangSys, cMaxTags, pFeatureTags, pcTags);
}

ScriptGetFontLanguageTags()

HRESULT WINAPI ScriptGetFontLanguageTags	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		SCRIPT_ANALYSIS *	psa,
		OPENTYPE_TAG	tagScript,
		int	cMaxTags,
		OPENTYPE_TAG *	pLangSysTags,
		int *	pcTags
	)

Definition at line 4104 of file usp10.c.

{
    HRESULT hr;
    if (!pLangSysTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    return SHAPE_GetFontLanguageTags(hdc, (ScriptCache *)*psc, psa, tagScript, cMaxTags, pLangSysTags, pcTags);
}

ScriptGetFontProperties()

HRESULT WINAPI ScriptGetFontProperties	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		SCRIPT_FONTPROPERTIES *	sfp
	)

Definition at line 1176 of file usp10.c.

{
    HRESULT hr;
 
    TRACE("%p,%p,%p\n", hdc, psc, sfp);
 
    if (!sfp) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    if (sfp->cBytes != sizeof(SCRIPT_FONTPROPERTIES))
        return E_INVALIDARG;
 
    get_cache_font_properties(sfp, *psc);
 
    return S_OK;
}

Referenced by test_ScriptGetFontProperties().

ScriptGetFontScriptTags()

HRESULT WINAPI ScriptGetFontScriptTags	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		SCRIPT_ANALYSIS *	psa,
		int	cMaxTags,
		OPENTYPE_TAG *	pScriptTags,
		int *	pcTags
	)

Definition at line 4095 of file usp10.c.

{
    HRESULT hr;
    if (!pScriptTags || !pcTags || cMaxTags == 0) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    return SHAPE_GetFontScriptTags(hdc, (ScriptCache *)*psc, psa, cMaxTags, pScriptTags, pcTags);
}

ScriptGetGlyphABCWidth()

HRESULT WINAPI ScriptGetGlyphABCWidth	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		WORD	glyph,
		ABC *	abc
	)

Definition at line 3729 of file usp10.c.

{
    HRESULT hr;
 
    TRACE("(%p, %p, 0x%04x, %p)\n", hdc, psc, glyph, abc);
 
    if (!abc) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
 
    if (!get_cache_glyph_widths(psc, glyph, abc))
    {
        if (!hdc) return E_PENDING;
        if (get_cache_pitch_family(psc) & TMPF_TRUETYPE)
        {
            if (!GetCharABCWidthsI(hdc, 0, 1, &glyph, abc)) return S_FALSE;
        }
        else
        {
            INT width;
            if (!GetCharWidthI(hdc, glyph, 1, NULL, &width)) return S_FALSE;
            abc->abcB = width;
            abc->abcA = abc->abcC = 0;
        }
        set_cache_glyph_widths(psc, glyph, abc);
    }
    return S_OK;
}

Referenced by test_ScriptGetGlyphABCWidth().

ScriptGetLogicalWidths()

HRESULT WINAPI ScriptGetLogicalWidths	(	const SCRIPT_ANALYSIS *	sa,
		int	nbchars,
		int	nbglyphs,
		const int *	advances,
		const WORD *	log_clust,
		const SCRIPT_VISATTR *	sva,
		int *	widths
	)

Definition at line 4019 of file usp10.c.

{
    int i, next = 0, direction;
 
    TRACE("(%p, %d, %d, %p, %p, %p, %p)\n",
          sa, nbchars, nbglyphs, advances, log_clust, sva, widths);
 
    if (sa->fRTL && !sa->fLogicalOrder)
        direction = -1;
    else
        direction = 1;
 
    for (i = 0; i < nbchars; i++)
    {
        int clust_size = get_cluster_size(log_clust, nbchars, i, direction, NULL, NULL);
        int advance = get_glyph_cluster_advance(advances, sva, log_clust, nbglyphs, nbchars, log_clust[i], direction);
        int j;
 
        for (j = 0; j < clust_size; j++)
        {
            widths[next] = advance / clust_size;
            next++;
            if (j) i++;
        }
    }
 
    return S_OK;
}

Referenced by test_ScriptGetLogicalWidths().

ScriptGetProperties()

HRESULT WINAPI ScriptGetProperties	(	const SCRIPT_PROPERTIES ***	props,
		int *	num
	)

Definition at line 1154 of file usp10.c.

{
    TRACE("(%p,%p)\n", props, num);
 
    if (!props && !num) return E_INVALIDARG;
 
    if (num) *num = ARRAY_SIZE(script_props);
    if (props) *props = script_props;
 
    return S_OK;
}

Referenced by _test_shape_ok(), test_ScriptGetProperties(), test_ScriptItemIzeShapePlace(), and test_ScriptXtoX().

ScriptIsComplex()

HRESULT WINAPI ScriptIsComplex	(	const WCHAR *	chars,
		int	len,
		DWORD	flag
	)

Definition at line 3095 of file usp10.c.

{
    enum usp10_script script;
    unsigned int i, consumed;
 
    TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars, len), len, flag);
 
    if (!chars || len < 0)
        return E_INVALIDARG;
 
    for (i = 0; i < len; i+=consumed)
    {
        if ((flag & SIC_ASCIIDIGIT) && chars[i] >= 0x30 && chars[i] <= 0x39)
            return S_OK;
 
        script = get_char_script(chars,i,len, &consumed);
        if ((scriptInformation[script].props.fComplex && (flag & SIC_COMPLEX))||
            (!scriptInformation[script].props.fComplex && (flag & SIC_NEUTRAL)))
            return S_OK;
    }
    return S_FALSE;
}

Referenced by LPK_DrawUnderscore(), LpkExtTextOut(), LpkGetTextExtentExPoint(), and test_ScriptIsComplex().

ScriptItemize()

HRESULT WINAPI ScriptItemize	(	const WCHAR *	pwcInChars,
		int	cInChars,
		int	cMaxItems,
		const SCRIPT_CONTROL *	psControl,
		const SCRIPT_STATE *	psState,
		SCRIPT_ITEM *	pItems,
		int *	pcItems
	)

Definition at line 1853 of file usp10.c.

{
    return _ItemizeInternal(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, NULL, pcItems);
}

Referenced by _test_items_ok(), BIDI_Reorder(), itemize_para(), ScriptStringAnalyse(), test_newlines(), test_ScriptBreak(), test_ScriptGetFontFunctions(), test_ScriptItemize(), test_ScriptItemize_surrogates(), test_ScriptItemIzeShapePlace(), test_ScriptPlace(), test_ScriptShape(), test_ScriptTextOut(), test_ScriptTextOut2(), test_ScriptTextOut3(), and test_ScriptXtoX().

ScriptItemizeOpenType()

HRESULT WINAPI ScriptItemizeOpenType	(	const WCHAR *	pwcInChars,
		int	cInChars,
		int	cMaxItems,
		const SCRIPT_CONTROL *	psControl,
		const SCRIPT_STATE *	psState,
		SCRIPT_ITEM *	pItems,
		OPENTYPE_TAG *	pScriptTags,
		int *	pcItems
	)

Definition at line 1828 of file usp10.c.

{
    return _ItemizeInternal(pwcInChars, cInChars, cMaxItems, psControl, psState, pItems, pScriptTags, pcItems);
}

ScriptJustify()

HRESULT WINAPI ScriptJustify	(	const SCRIPT_VISATTR *	sva,
		const int *	advance,
		int	num_glyphs,
		int	dx,
		int	min_kashida,
		int *	justify
	)

Definition at line 4084 of file usp10.c.

{
    int i;
 
    FIXME("(%p, %p, %d, %d, %d, %p)\n", sva, advance, num_glyphs, dx, min_kashida, justify);
 
    for (i = 0; i < num_glyphs; i++) justify[i] = advance[i];
    return S_OK;
}

ScriptLayout()

HRESULT WINAPI ScriptLayout	(	int	runs,
		const BYTE *	level,
		int *	vistolog,
		int *	logtovis
	)

Definition at line 3773 of file usp10.c.

{
    int* indexs;
    int ich;
 
    TRACE("(%d, %p, %p, %p)\n", runs, level, vistolog, logtovis);
 
    if (!level || (!vistolog && !logtovis))
        return E_INVALIDARG;
 
    if (!(indexs = heap_calloc(runs, sizeof(*indexs))))
        return E_OUTOFMEMORY;
 
    if (vistolog)
    {
        for( ich = 0; ich < runs; ich++)
            indexs[ich] = ich;
 
        ich = 0;
        while (ich < runs)
            ich += BIDI_ReorderV2lLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
        memcpy(vistolog, indexs, runs * sizeof(*vistolog));
    }
 
    if (logtovis)
    {
        for( ich = 0; ich < runs; ich++)
            indexs[ich] = ich;
 
        ich = 0;
        while (ich < runs)
            ich += BIDI_ReorderL2vLevel(0, indexs+ich, level+ich, runs - ich, FALSE);
        memcpy(logtovis, indexs, runs * sizeof(*logtovis));
    }
    heap_free(indexs);
 
    return S_OK;
}

Referenced by BIDI_Reorder(), BidiLines(), layout_row(), ScriptStringAnalyse(), and test_ScriptLayout().

ScriptPlace()

HRESULT WINAPI ScriptPlace	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		const WORD *	pwGlyphs,
		int	cGlyphs,
		const SCRIPT_VISATTR *	psva,
		SCRIPT_ANALYSIS *	psa,
		int *	piAdvance,
		GOFFSET *	pGoffset,
		ABC *	pABC
	)

Definition at line 3531 of file usp10.c.

{
    HRESULT hr;
    SCRIPT_GLYPHPROP *glyphProps;
    int i;
 
    TRACE("(%p, %p, %p, %d, %p, %p, %p, %p, %p)\n",  hdc, psc, pwGlyphs, cGlyphs, psva, psa,
          piAdvance, pGoffset, pABC);
 
    if (!psva) return E_INVALIDARG;
    if (!pGoffset) return E_FAIL;
 
    if (!(glyphProps = heap_calloc(cGlyphs, sizeof(*glyphProps))))
        return E_OUTOFMEMORY;
 
    for (i = 0; i < cGlyphs; i++)
        glyphProps[i].sva = psva[i];
 
    hr = ScriptPlaceOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, NULL, NULL, NULL, 0, pwGlyphs, glyphProps, cGlyphs, piAdvance, pGoffset, pABC);
 
    heap_free(glyphProps);
 
    return hr;
}

Referenced by ScriptStringAnalyse(), shape_run(), test_ScriptItemIzeShapePlace(), test_ScriptPlace(), test_ScriptTextOut(), test_ScriptTextOut2(), and test_ScriptTextOut3().

ScriptPlaceOpenType()

HRESULT WINAPI ScriptPlaceOpenType	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		SCRIPT_ANALYSIS *	psa,
		OPENTYPE_TAG	tagScript,
		OPENTYPE_TAG	tagLangSys,
		int *	rcRangeChars,
		TEXTRANGE_PROPERTIES **	rpRangeProperties,
		int	cRanges,
		const WCHAR *	pwcChars,
		WORD *	pwLogClust,
		SCRIPT_CHARPROP *	pCharProps,
		int	cChars,
		const WORD *	pwGlyphs,
		const SCRIPT_GLYPHPROP *	pGlyphProps,
		int	cGlyphs,
		int *	piAdvance,
		GOFFSET *	pGoffset,
		ABC *	pABC
	)

Definition at line 3408 of file usp10.c.

{
    HRESULT hr;
    int i;
    static int once = 0;
 
    TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %p, %p, %d, %p, %p, %d, %p %p %p)\n",
     hdc, psc, psa,
     debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
     rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
     pwLogClust, pCharProps, cChars, pwGlyphs, pGlyphProps, cGlyphs, piAdvance,
     pGoffset, pABC);
 
    if (!pGlyphProps) return E_INVALIDARG;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
    if (!pGoffset) return E_FAIL;
 
    if (cRanges)
        if (!once++) FIXME("Ranges not supported yet\n");
 
    ((ScriptCache *)*psc)->userScript = tagScript;
    ((ScriptCache *)*psc)->userLang = tagLangSys;
 
    if (pABC) memset(pABC, 0, sizeof(ABC));
    for (i = 0; i < cGlyphs; i++)
    {
        WORD glyph;
        ABC abc;
 
        /* FIXME: set to more reasonable values */
        pGoffset[i].du = pGoffset[i].dv = 0;
 
        if (pGlyphProps[i].sva.fZeroWidth)
        {
            abc.abcA = abc.abcB = abc.abcC = 0;
            if (piAdvance) piAdvance[i] = 0;
            continue;
        }
 
        if (psa->fNoGlyphIndex)
        {
            if (FAILED(hr = ScriptGetCMap(hdc, psc, &pwGlyphs[i], 1, 0, &glyph))) return hr;
        }
        else
        {
            hr = S_OK;
            glyph = pwGlyphs[i];
        }
 
        if (hr == S_FALSE)
        {
            if (!hdc) return E_PENDING;
            if (get_cache_pitch_family(psc) & TMPF_TRUETYPE)
            {
                if (!GetCharABCWidthsW(hdc, pwGlyphs[i], pwGlyphs[i], &abc)) return S_FALSE;
            }
            else
            {
                INT width;
                if (!GetCharWidthW(hdc, pwGlyphs[i], pwGlyphs[i], &width)) return S_FALSE;
                abc.abcB = width;
                abc.abcA = abc.abcC = 0;
            }
        }
        else if (!get_cache_glyph_widths(psc, glyph, &abc))
        {
            if (!hdc) return E_PENDING;
            if (get_cache_pitch_family(psc) & TMPF_TRUETYPE)
            {
                if (!GetCharABCWidthsI(hdc, glyph, 1, NULL, &abc)) return S_FALSE;
            }
            else
            {
                INT width;
                if (!GetCharWidthI(hdc, glyph, 1, NULL, &width)) return S_FALSE;
                abc.abcB = width;
                abc.abcA = abc.abcC = 0;
            }
            set_cache_glyph_widths(psc, glyph, &abc);
        }
        if (pABC)
        {
            pABC->abcA += abc.abcA;
            pABC->abcB += abc.abcB;
            pABC->abcC += abc.abcC;
        }
        if (piAdvance) piAdvance[i] = abc.abcA + abc.abcB + abc.abcC;
    }
 
    SHAPE_ApplyOpenTypePositions(hdc, (ScriptCache *)*psc, psa, pwGlyphs, cGlyphs, piAdvance, pGoffset);
 
    if (pABC) TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC->abcA, pABC->abcB, pABC->abcC);
    return S_OK;
}

Referenced by ScriptPlace().

ScriptRecordDigitSubstitution()

HRESULT WINAPI ScriptRecordDigitSubstitution	(	LCID	locale,
		SCRIPT_DIGITSUBSTITUTE *	sds
	)

Definition at line 1209 of file usp10.c.

{
    DWORD plgid, sub;
 
    TRACE("0x%x, %p\n", locale, sds);
 
    /* This implementation appears to be correct for all languages, but it's
     * not clear if sds->DigitSubstitute is ever set to anything except 
     * CONTEXT or NONE in reality */
 
    if (!sds) return E_POINTER;
 
    locale = ConvertDefaultLocale(locale);
 
    if (!IsValidLocale(locale, LCID_INSTALLED))
        return E_INVALIDARG;
 
    plgid = PRIMARYLANGID(LANGIDFROMLCID(locale));
    sds->TraditionalDigitLanguage = plgid;
 
    if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
        sds->NationalDigitLanguage = plgid;
    else
        sds->NationalDigitLanguage = LANG_ENGLISH;
 
    if (!GetLocaleInfoW(locale, LOCALE_IDIGITSUBSTITUTION | LOCALE_RETURN_NUMBER,
            (WCHAR *)&sub, sizeof(sub) / sizeof(WCHAR)))
        return E_INVALIDARG;
 
    switch (sub)
    {
    case 0: 
        if (plgid == LANG_ARABIC || plgid == LANG_FARSI)
            sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_CONTEXT;
        else
            sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
        break;
    case 1:
        sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NONE;
        break;
    case 2:
        sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_NATIONAL;
        break;
    default:
        sds->DigitSubstitute = SCRIPT_DIGITSUBSTITUTE_TRADITIONAL;
        break;
    }
 
    sds->dwReserved = 0;
    return S_OK;
}

Referenced by enum_proc(), and ScriptApplyDigitSubstitution().

ScriptShape()

HRESULT WINAPI ScriptShape	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		const WCHAR *	pwcChars,
		int	cChars,
		int	cMaxGlyphs,
		SCRIPT_ANALYSIS *	psa,
		WORD *	pwOutGlyphs,
		WORD *	pwLogClust,
		SCRIPT_VISATTR *	psva,
		int *	pcGlyphs
	)

Definition at line 3342 of file usp10.c.

{
    HRESULT hr;
    int i;
    SCRIPT_CHARPROP *charProps;
    SCRIPT_GLYPHPROP *glyphProps;
 
    if (!psva || !pcGlyphs) return E_INVALIDARG;
    if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
 
    if (!(charProps = heap_calloc(cChars, sizeof(*charProps))))
        return E_OUTOFMEMORY;
 
    if (!(glyphProps = heap_calloc(cMaxGlyphs, sizeof(*glyphProps))))
    {
        heap_free(charProps);
        return E_OUTOFMEMORY;
    }
 
    hr = ScriptShapeOpenType(hdc, psc, psa, scriptInformation[psa->eScript].scriptTag, 0, NULL, NULL, 0, pwcChars, cChars, cMaxGlyphs, pwLogClust, charProps, pwOutGlyphs, glyphProps, pcGlyphs);
 
    if (SUCCEEDED(hr))
    {
        for (i = 0; i < *pcGlyphs; i++)
            psva[i] = glyphProps[i].sva;
    }
 
    heap_free(charProps);
    heap_free(glyphProps);
 
    return hr;
}

Referenced by BIDI_Reorder(), ScriptStringAnalyse(), shape_run(), test_ScriptItemIzeShapePlace(), test_ScriptPlace(), test_ScriptShape(), test_ScriptTextOut(), test_ScriptTextOut2(), and test_ScriptTextOut3().

ScriptShapeOpenType()

HRESULT WINAPI ScriptShapeOpenType	(	HDC	hdc,
		SCRIPT_CACHE *	psc,
		SCRIPT_ANALYSIS *	psa,
		OPENTYPE_TAG	tagScript,
		OPENTYPE_TAG	tagLangSys,
		int *	rcRangeChars,
		TEXTRANGE_PROPERTIES **	rpRangeProperties,
		int	cRanges,
		const WCHAR *	pwcChars,
		int	cChars,
		int	cMaxGlyphs,
		WORD *	pwLogClust,
		SCRIPT_CHARPROP *	pCharProps,
		WORD *	pwOutGlyphs,
		SCRIPT_GLYPHPROP *	pOutGlyphProps,
		int *	pcGlyphs
	)

Definition at line 3145 of file usp10.c.

{
    HRESULT hr;
    int i;
    unsigned int g;
    BOOL rtl;
    int cluster;
    static int once = 0;
 
    TRACE("(%p, %p, %p, %s, %s, %p, %p, %d, %s, %d, %d, %p, %p, %p, %p, %p )\n",
     hdc, psc, psa,
     debugstr_an((char*)&tagScript,4), debugstr_an((char*)&tagLangSys,4),
     rcRangeChars, rpRangeProperties, cRanges, debugstr_wn(pwcChars, cChars),
     cChars, cMaxGlyphs, pwLogClust, pCharProps, pwOutGlyphs, pOutGlyphProps, pcGlyphs);
 
    if (psa) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa->eScript, psa->fRTL, psa->fLayoutRTL,
                   psa->fLinkBefore, psa->fLinkAfter, psa->fLogicalOrder, psa->fNoGlyphIndex);
 
    if (!pOutGlyphProps || !pcGlyphs || !pCharProps) return E_INVALIDARG;
    if (cChars > cMaxGlyphs) return E_OUTOFMEMORY;
 
    if (cRanges)
        if(!once++) FIXME("Ranges not supported yet\n");
 
    rtl = (psa && !psa->fLogicalOrder && psa->fRTL);
 
    *pcGlyphs = cChars;
    if ((hr = init_script_cache(hdc, psc)) != S_OK) return hr;
    if (!pwLogClust) return E_FAIL;
 
    ((ScriptCache *)*psc)->userScript = tagScript;
    ((ScriptCache *)*psc)->userLang = tagLangSys;
 
    /* Initialize a SCRIPT_VISATTR and LogClust for each char in this run */
    for (i = 0; i < cChars; i++)
    {
        int idx = i;
        if (rtl) idx = cChars - 1 - i;
        /* FIXME: set to better values */
        pOutGlyphProps[i].sva.uJustification = (pwcChars[idx] == ' ') ? SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
        pOutGlyphProps[i].sva.fClusterStart  = 1;
        pOutGlyphProps[i].sva.fDiacritic     = 0;
        pOutGlyphProps[i].sva.fZeroWidth     = 0;
        pOutGlyphProps[i].sva.fReserved      = 0;
        pOutGlyphProps[i].sva.fShapeReserved = 0;
 
        /* FIXME: have the shaping engine set this */
        pCharProps[i].fCanGlyphAlone = 0;
 
        pwLogClust[i] = idx;
    }
 
    if (psa && !psa->fNoGlyphIndex && ((ScriptCache *)*psc)->sfnt)
    {
        WCHAR *rChars;
        if ((hr = SHAPE_CheckFontForRequiredFeatures(hdc, (ScriptCache *)*psc, psa)) != S_OK) return hr;
 
        if (!(rChars = heap_calloc(cChars, sizeof(*rChars))))
            return E_OUTOFMEMORY;
 
        for (i = 0, g = 0, cluster = 0; i < cChars; i++)
        {
            int idx = i;
            DWORD chInput;
 
            if (rtl) idx = cChars - 1 - i;
            if (!cluster)
            {
                chInput = decode_surrogate_pair(pwcChars, idx, cChars);
                if (!chInput)
                {
                    if (psa->fRTL)
                        chInput = mirror_char(pwcChars[idx]);
                    else
                        chInput = pwcChars[idx];
                    rChars[i] = chInput;
                }
                else
                {
                    rChars[i] = pwcChars[idx];
                    rChars[i+1] = pwcChars[(rtl)?idx-1:idx+1];
                    cluster = 1;
                }
                if (!(pwOutGlyphs[g] = get_cache_glyph(psc, chInput)))
                {
                    WORD glyph;
                    if (!hdc)
                    {
                        heap_free(rChars);
                        return E_PENDING;
                    }
                    if (OpenType_CMAP_GetGlyphIndex(hdc, (ScriptCache *)*psc, chInput, &glyph, 0) == GDI_ERROR)
                    {
                        heap_free(rChars);
                        return S_FALSE;
                    }
                    pwOutGlyphs[g] = set_cache_glyph(psc, chInput, glyph);
                }
                g++;
            }
            else
            {
                int k;
                cluster--;
                pwLogClust[idx] = (rtl)?pwLogClust[idx+1]:pwLogClust[idx-1];
                for (k = (rtl)?idx-1:idx+1; k >= 0 && k < cChars; (rtl)?k--:k++)
                    pwLogClust[k]--;
            }
        }
        *pcGlyphs = g;
 
        SHAPE_ContextualShaping(hdc, (ScriptCache *)*psc, psa, rChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
        SHAPE_ApplyDefaultOpentypeFeatures(hdc, (ScriptCache *)*psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, pwLogClust);
        SHAPE_CharGlyphProp(hdc, (ScriptCache *)*psc, psa, pwcChars, cChars, pwOutGlyphs, *pcGlyphs, pwLogClust, pCharProps, pOutGlyphProps);
 
        for (i = 0; i < cChars; ++i)
        {
            /* Special case for tabs and joiners. As control characters, ZWNJ
             * and ZWJ would in principle get handled by the corresponding
             * shaping functions. However, since ZWNJ and ZWJ can get merged
             * into adjoining runs during itemisation, these don't generally
             * get classified as Script_Control. */
            if (pwcChars[i] == 0x0009 || pwcChars[i] == ZWSP || pwcChars[i] == ZWNJ || pwcChars[i] == ZWJ)
            {
                pwOutGlyphs[pwLogClust[i]] = ((ScriptCache *)*psc)->sfp.wgBlank;
                pOutGlyphProps[pwLogClust[i]].sva.fZeroWidth = 1;
            }
        }
        heap_free(rChars);
    }
    else
    {
        TRACE("no glyph translation\n");
        for (i = 0; i < cChars; i++)
        {
            int idx = i;
            /* No mirroring done here */
            if (rtl) idx = cChars - 1 - i;
            pwOutGlyphs[i] = pwcChars[idx];
 
            if (!psa)
                continue;
 
            /* overwrite some basic control glyphs to blank */
            if (psa->fNoGlyphIndex)
            {
                if (pwcChars[idx] == ZWSP || pwcChars[idx] == ZWNJ || pwcChars[idx] == ZWJ)
                {
                    pwOutGlyphs[i] = 0x20;
                    pOutGlyphProps[i].sva.fZeroWidth = 1;
                }
            }
            else if (psa->eScript == Script_Control || pwcChars[idx] == ZWSP
                    || pwcChars[idx] == ZWNJ || pwcChars[idx] == ZWJ)
            {
                if (pwcChars[idx] == 0x0009 || pwcChars[idx] == 0x000A ||
                    pwcChars[idx] == 0x000D || pwcChars[idx] >= 0x001C)
                {
                    pwOutGlyphs[i] = ((ScriptCache *)*psc)->sfp.wgBlank;
                    pOutGlyphProps[i].sva.fZeroWidth = 1;
                }
            }
        }
    }
 
    return S_OK;
}

Referenced by ScriptShape().

ScriptString_pcOutChars()

const int *WINAPI ScriptString_pcOutChars

(

SCRIPT_STRING_ANALYSIS

ssa

)

Definition at line 3959 of file usp10.c.

{
    StringAnalysis *analysis = ssa;
 
    TRACE("(%p)\n", ssa);
 
    if (!analysis) return NULL;
    return &analysis->clip_len;
}

Referenced by EDIT_BuildLineDefs_ML(), and test_ScriptString().

ScriptString_pLogAttr()

const SCRIPT_LOGATTR *WINAPI ScriptString_pLogAttr

(

SCRIPT_STRING_ANALYSIS

ssa

)

Definition at line 3936 of file usp10.c.

{
    StringAnalysis *analysis = ssa;
 
    TRACE("(%p)\n", ssa);
 
    if (!analysis) return NULL;
    if (!(analysis->ssa_flags & SSA_BREAK)) return NULL;
    return analysis->logattrs;
}

ScriptString_pSize()

const SIZE *WINAPI ScriptString_pSize

(

SCRIPT_STRING_ANALYSIS

ssa

)

Definition at line 3897 of file usp10.c.

{
    int i, j;
    StringAnalysis *analysis = ssa;
 
    TRACE("(%p)\n", ssa);
 
    if (!analysis) return NULL;
    if (!(analysis->ssa_flags & SSA_GLYPHS)) return NULL;
 
    if (!(analysis->flags & SCRIPT_STRING_ANALYSIS_FLAGS_SIZE))
    {
        analysis->sz.cy = analysis->glyphs[0].sc->tm.tmHeight;
 
        analysis->sz.cx = 0;
        for (i = 0; i < analysis->numItems; i++)
        {
            if (analysis->glyphs[i].sc->tm.tmHeight > analysis->sz.cy)
                analysis->sz.cy = analysis->glyphs[i].sc->tm.tmHeight;
            for (j = 0; j < analysis->glyphs[i].numGlyphs; j++)
                analysis->sz.cx += analysis->glyphs[i].piAdvance[j];
        }
        analysis->flags |= SCRIPT_STRING_ANALYSIS_FLAGS_SIZE;
    }
    return &analysis->sz;
}

Referenced by EDIT_BuildLineDefs_ML(), EDIT_CalcLineWidth_SL(), EDIT_CharFromPos(), EDIT_EM_PosFromChar(), and test_ScriptString_pSize().

ScriptStringAnalyse()

HRESULT WINAPI ScriptStringAnalyse	(	HDC	hdc,
		const void *	pString,
		int	cString,
		int	cGlyphs,
		int	iCharset,
		DWORD	dwFlags,
		int	iReqWidth,
		SCRIPT_CONTROL *	psControl,
		SCRIPT_STATE *	psState,
		const int *	piDx,
		SCRIPT_TABDEF *	pTabdef,
		const BYTE *	pbInClass,
		SCRIPT_STRING_ANALYSIS *	pssa
	)

Definition at line 1985 of file usp10.c.

{
    HRESULT hr = E_OUTOFMEMORY;
    StringAnalysis *analysis = NULL;
    SCRIPT_CONTROL sControl;
    SCRIPT_STATE sState;
#ifdef __REACTOS__  // CORE-20176 & CORE-20177
    int i, num_items = cString + 1;
#else
    int i, num_items = 255;
#endif
    BYTE   *BidiLevel;
    WCHAR *iString = NULL;
#ifdef __REACTOS__  // CORE-20176 & CORE-20177
    SCRIPT_ITEM *items;
#endif
 
    TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
          hdc, pString, cString, cGlyphs, iCharset, dwFlags, iReqWidth,
          psControl, psState, piDx, pTabdef, pbInClass, pssa);
 
    if (iCharset != -1)
    {
        FIXME("Only Unicode strings are supported\n");
        return E_INVALIDARG;
    }
    if (cString < 1 || !pString) return E_INVALIDARG;
    if ((dwFlags & SSA_GLYPHS) && !hdc) return E_PENDING;
 
    if (!(analysis = heap_alloc_zero(sizeof(*analysis))))
        return E_OUTOFMEMORY;
#ifdef __REACTOS__  // CORE-20176 & CORE-20177
    if (!(analysis->pItem = heap_calloc(num_items, sizeof(*analysis->pItem))))
#else
    if (!(analysis->pItem = heap_calloc(num_items + 1, sizeof(*analysis->pItem))))
#endif
        goto error;
 
    /* FIXME: handle clipping */
    analysis->clip_len = cString;
    analysis->hdc = hdc;
    analysis->ssa_flags = dwFlags;
 
    if (psState)
        sState = *psState;
    else
        memset(&sState, 0, sizeof(SCRIPT_STATE));
 
    if (psControl)
        sControl = *psControl;
    else
        memset(&sControl, 0, sizeof(SCRIPT_CONTROL));
 
    if (dwFlags & SSA_PASSWORD)
    {
        if (!(iString = heap_calloc(cString, sizeof(*iString))))
        {
            hr = E_OUTOFMEMORY;
            goto error;
        }
        for (i = 0; i < cString; i++)
            iString[i] = *((const WCHAR *)pString);
        pString = iString;
    }
 
    hr = ScriptItemize(pString, cString, num_items, &sControl, &sState, analysis->pItem,
                       &analysis->numItems);
 
    if (FAILED(hr))
#ifdef __REACTOS__  // CORE-20176 & CORE-20177
        goto error;
#else
    {
        if (hr == E_OUTOFMEMORY)
            hr = E_INVALIDARG;
        goto error;
    }
#endif
 
#ifdef __REACTOS__  // CORE-20176 & CORE-20177
    /* Having as many items as codepoints is the worst case scenario, try to reclaim some memory. */
    if ((items = heap_realloc(analysis->pItem, (analysis->numItems + 1) * sizeof(*analysis->pItem))))
        analysis->pItem = items;
#endif
 
    /* set back to out of memory for default goto error behaviour */
    hr = E_OUTOFMEMORY;
 
    if (dwFlags & SSA_BREAK)
    {
        if (!(analysis->logattrs = heap_calloc(cString, sizeof(*analysis->logattrs))))
            goto error;
 
        for (i = 0; i < analysis->numItems; ++i)
            ScriptBreak(&((const WCHAR *)pString)[analysis->pItem[i].iCharPos],
                    analysis->pItem[i + 1].iCharPos - analysis->pItem[i].iCharPos,
                    &analysis->pItem[i].a, &analysis->logattrs[analysis->pItem[i].iCharPos]);
    }
 
    if (!(analysis->logical2visual = heap_calloc(analysis->numItems, sizeof(*analysis->logical2visual))))
        goto error;
    if (!(BidiLevel = heap_alloc_zero(analysis->numItems)))
        goto error;
 
    if (dwFlags & SSA_GLYPHS)
    {
        int tab_x = 0;
 
        if (!(analysis->glyphs = heap_calloc(analysis->numItems, sizeof(*analysis->glyphs))))
        {
            heap_free(BidiLevel);
            goto error;
        }
 
        for (i = 0; i < analysis->numItems; i++)
        {
            SCRIPT_CACHE *sc = (SCRIPT_CACHE*)&analysis->glyphs[i].sc;
            int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
            int numGlyphs = 1.5 * cChar + 16;
            WORD *glyphs = heap_calloc(numGlyphs, sizeof(*glyphs));
            WORD *pwLogClust = heap_calloc(cChar, sizeof(*pwLogClust));
            int *piAdvance = heap_calloc(numGlyphs, sizeof(*piAdvance));
            SCRIPT_VISATTR *psva = heap_calloc(numGlyphs, sizeof(*psva));
            GOFFSET *pGoffset = heap_calloc(numGlyphs, sizeof(*pGoffset));
            int numGlyphsReturned;
            HFONT originalFont = 0x0;
 
            /* FIXME: non unicode strings */
            const WCHAR* pStr = (const WCHAR*)pString;
            analysis->glyphs[i].fallbackFont = NULL;
 
            if (!glyphs || !pwLogClust || !piAdvance || !psva || !pGoffset)
            {
                heap_free (BidiLevel);
                heap_free (glyphs);
                heap_free (pwLogClust);
                heap_free (piAdvance);
                heap_free (psva);
                heap_free (pGoffset);
                hr = E_OUTOFMEMORY;
                goto error;
            }
 
            if ((dwFlags & SSA_FALLBACK) && requires_fallback(hdc, sc, &analysis->pItem[i].a, &pStr[analysis->pItem[i].iCharPos], cChar))
            {
                LOGFONTW lf;
                GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), & lf);
                lf.lfCharSet = scriptInformation[analysis->pItem[i].a.eScript].props.bCharSet;
                lf.lfFaceName[0] = 0;
                find_fallback_font(analysis->pItem[i].a.eScript, lf.lfFaceName);
                if (lf.lfFaceName[0])
                {
                    analysis->glyphs[i].fallbackFont = CreateFontIndirectW(&lf);
                    if (analysis->glyphs[i].fallbackFont)
                    {
                        ScriptFreeCache(sc);
                        originalFont = SelectObject(hdc, analysis->glyphs[i].fallbackFont);
                    }
                }
            }
 
            /* FIXME: When we properly shape Hangul remove this check */
            if ((dwFlags & SSA_LINK) && !analysis->glyphs[i].fallbackFont && analysis->pItem[i].a.eScript == Script_Hangul)
                analysis->pItem[i].a.fNoGlyphIndex = TRUE;
 
            if ((dwFlags & SSA_LINK) && !analysis->glyphs[i].fallbackFont && !scriptInformation[analysis->pItem[i].a.eScript].props.fComplex && !analysis->pItem[i].a.fRTL)
                analysis->pItem[i].a.fNoGlyphIndex = TRUE;
 
            ScriptShape(hdc, sc, &pStr[analysis->pItem[i].iCharPos], cChar, numGlyphs,
                        &analysis->pItem[i].a, glyphs, pwLogClust, psva, &numGlyphsReturned);
            hr = ScriptPlace(hdc, sc, glyphs, numGlyphsReturned, psva, &analysis->pItem[i].a,
                        piAdvance, pGoffset, &analysis->glyphs[i].abc);
            if (originalFont)
                SelectObject(hdc,originalFont);
 
            if (dwFlags & SSA_TAB)
            {
                int tabi = 0;
                for (tabi = 0; tabi < cChar; tabi++)
                {
                    if (pStr[analysis->pItem[i].iCharPos+tabi] == 0x0009)
                        piAdvance[tabi] = getGivenTabWidth(analysis->glyphs[i].sc, pTabdef, analysis->pItem[i].iCharPos+tabi, tab_x);
                    tab_x+=piAdvance[tabi];
                }
            }
 
            analysis->glyphs[i].numGlyphs = numGlyphsReturned;
            analysis->glyphs[i].glyphs = glyphs;
            analysis->glyphs[i].pwLogClust = pwLogClust;
            analysis->glyphs[i].piAdvance = piAdvance;
            analysis->glyphs[i].psva = psva;
            analysis->glyphs[i].pGoffset = pGoffset;
            analysis->glyphs[i].iMaxPosX= -1;
 
            BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
        }
    }
    else
    {
        for (i = 0; i < analysis->numItems; i++)
            BidiLevel[i] = analysis->pItem[i].a.s.uBidiLevel;
    }
 
    ScriptLayout(analysis->numItems, BidiLevel, NULL, analysis->logical2visual);
    heap_free(BidiLevel);
 
    *pssa = analysis;
    heap_free(iString);
    return S_OK;
 
error:
    heap_free(iString);
    heap_free(analysis->glyphs);
    heap_free(analysis->logattrs);
    heap_free(analysis->pItem);
    heap_free(analysis->logical2visual);
    heap_free(analysis);
    return hr;
}

Referenced by EDIT_UpdateUniscribeData(), EDIT_UpdateUniscribeData_linedef(), LPK_DrawUnderscore(), LpkGetCharacterPlacement(), LpkGetTextExtentExPoint(), test_ScriptString(), test_ScriptString_pSize(), and test_ScriptStringXtoCP_CPtoX().

ScriptStringCPtoX()

HRESULT WINAPI ScriptStringCPtoX	(	SCRIPT_STRING_ANALYSIS	ssa,
		int	icp,
		BOOL	fTrailing,
		int *	pX
	)

Definition at line 2432 of file usp10.c.

{
    int item;
    int runningX = 0;
    StringAnalysis* analysis = ssa;
 
    TRACE("(%p), %d, %d, (%p)\n", ssa, icp, fTrailing, pX);
 
    if (!ssa || !pX) return S_FALSE;
    if (!(analysis->ssa_flags & SSA_GLYPHS)) return S_FALSE;
 
    /* icp out of range */
    if(icp < 0)
    {
        analysis->flags |= SCRIPT_STRING_ANALYSIS_FLAGS_INVALID;
        return E_INVALIDARG;
    }
 
    for(item=0; item<analysis->numItems; item++)
    {
        int CP, i;
        int offset;
 
        i = analysis->logical2visual[item];
        CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
        /* initialize max extents for uninitialized runs */
        if (analysis->glyphs[i].iMaxPosX == -1)
        {
            if (analysis->pItem[i].a.fRTL)
                ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
                            analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
                            &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
            else
                ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
                            analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
                            &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
        }
 
        if (icp >= analysis->pItem[i+1].iCharPos || icp < analysis->pItem[i].iCharPos)
        {
            runningX += analysis->glyphs[i].iMaxPosX;
            continue;
        }
 
        icp -= analysis->pItem[i].iCharPos;
        ScriptCPtoX(icp, fTrailing, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
                    analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
                    &analysis->pItem[i].a, &offset);
        runningX += offset;
 
        *pX = runningX;
        return S_OK;
    }
 
    /* icp out of range */
    analysis->flags |= SCRIPT_STRING_ANALYSIS_FLAGS_INVALID;
    return E_INVALIDARG;
}

Referenced by EDIT_CharFromPos(), EDIT_EM_PosFromChar(), EDIT_GetLineRect(), LPK_DrawUnderscore(), LpkGetCharacterPlacement(), SS_ItemOut(), and test_ScriptStringXtoCP_CPtoX().

ScriptStringFree()

HRESULT WINAPI ScriptStringFree

(

SCRIPT_STRING_ANALYSIS *

pssa

)

Definition at line 2577 of file usp10.c.

{
    StringAnalysis* analysis;
    BOOL invalid;
    int i;
 
    TRACE("(%p)\n", pssa);
 
    if (!pssa || !(analysis = *pssa)) return E_INVALIDARG;
 
    invalid = analysis->flags & SCRIPT_STRING_ANALYSIS_FLAGS_INVALID;
 
    if (analysis->glyphs)
    {
        for (i = 0; i < analysis->numItems; i++)
        {
            heap_free(analysis->glyphs[i].glyphs);
            heap_free(analysis->glyphs[i].pwLogClust);
            heap_free(analysis->glyphs[i].piAdvance);
            heap_free(analysis->glyphs[i].psva);
            heap_free(analysis->glyphs[i].pGoffset);
            if (analysis->glyphs[i].fallbackFont)
                DeleteObject(analysis->glyphs[i].fallbackFont);
            ScriptFreeCache((SCRIPT_CACHE *)&analysis->glyphs[i].sc);
            heap_free(analysis->glyphs[i].sc);
        }
        heap_free(analysis->glyphs);
    }
 
    heap_free(analysis->pItem);
    heap_free(analysis->logattrs);
    heap_free(analysis->logical2visual);
    heap_free(analysis);
 
    if (invalid) return E_INVALIDARG;
    return S_OK;
}

Referenced by EDIT_InvalidateUniscribeData(), EDIT_InvalidateUniscribeData_linedef(), LPK_DrawUnderscore(), LpkGetCharacterPlacement(), LpkGetTextExtentExPoint(), test_ScriptString(), test_ScriptString_pSize(), and test_ScriptStringXtoCP_CPtoX().

ScriptStringGetLogicalWidths()

HRESULT WINAPI ScriptStringGetLogicalWidths	(	SCRIPT_STRING_ANALYSIS	ssa,
		int *	piDx
	)

Definition at line 3825 of file usp10.c.

{
    int i, j, next = 0;
    StringAnalysis *analysis = ssa;
 
    TRACE("%p, %p\n", ssa, piDx);
 
    if (!analysis) return S_FALSE;
    if (!(analysis->ssa_flags & SSA_GLYPHS)) return S_FALSE;
 
    for (i = 0; i < analysis->numItems; i++)
    {
        int cChar = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
        int direction = 1;
 
        if (analysis->pItem[i].a.fRTL && ! analysis->pItem[i].a.fLogicalOrder)
            direction = -1;
 
        for (j = 0; j < cChar; j++)
        {
            int k;
            int glyph = analysis->glyphs[i].pwLogClust[j];
            int clust_size = get_cluster_size(analysis->glyphs[i].pwLogClust,
                                              cChar, j, direction, NULL, NULL);
            int advance = get_glyph_cluster_advance(analysis->glyphs[i].piAdvance, analysis->glyphs[i].psva, analysis->glyphs[i].pwLogClust, analysis->glyphs[i].numGlyphs, cChar, glyph, direction);
 
            for (k = 0; k < clust_size; k++)
            {
                piDx[next] = advance / clust_size;
                next++;
                if (k) j++;
            }
        }
    }
    return S_OK;
}

Referenced by EDIT_BuildLineDefs_ML(), and LpkGetTextExtentExPoint().

ScriptStringGetOrder()

HRESULT WINAPI ScriptStringGetOrder	(	SCRIPT_STRING_ANALYSIS	ssa,
		UINT *	order
	)

Definition at line 3982 of file usp10.c.

{
    int i, j;
    unsigned int k;
    StringAnalysis *analysis = ssa;
 
    TRACE("(%p)\n", ssa);
 
    if (!analysis) return S_FALSE;
    if (!(analysis->ssa_flags & SSA_GLYPHS)) return S_FALSE;
 
    /* FIXME: handle RTL scripts */
    for (i = 0, k = 0; i < analysis->numItems; i++)
        for (j = 0; j < analysis->glyphs[i].numGlyphs; j++, k++)
            order[k] = k;
 
    return S_OK;
}

Referenced by test_ScriptString().

ScriptStringOut()

HRESULT WINAPI ScriptStringOut	(	SCRIPT_STRING_ANALYSIS	ssa,
		int	iX,
		int	iY,
		UINT	uOptions,
		const RECT *	prc,
		int	iMinSel,
		int	iMaxSel,
		BOOL	fDisabled
	)

Definition at line 2387 of file usp10.c.

{
    StringAnalysis *analysis;
    int   item;
    HRESULT hr;
 
    TRACE("(%p,%d,%d,0x%08x,%s,%d,%d,%d)\n",
         ssa, iX, iY, uOptions, wine_dbgstr_rect(prc), iMinSel, iMaxSel, fDisabled);
 
    if (!(analysis = ssa)) return E_INVALIDARG;
    if (!(analysis->ssa_flags & SSA_GLYPHS)) return E_INVALIDARG;
 
    for (item = 0; item < analysis->numItems; item++)
    {
        hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], -1, -1, uOptions, prc, FALSE, fDisabled);
        if (FAILED(hr))
            return hr;
    }
 
    if (iMinSel < iMaxSel && (iMinSel > 0 || iMaxSel > 0))
    {
        if (iMaxSel > 0 &&  iMinSel < 0)
            iMinSel = 0;
        for (item = 0; item < analysis->numItems; item++)
        {
            hr = SS_ItemOut( ssa, iX, iY, analysis->logical2visual[item], iMinSel, iMaxSel, uOptions, prc, TRUE, fDisabled);
            if (FAILED(hr))
                return hr;
        }
    }
 
    return S_OK;
}

Referenced by EDIT_PaintLine(), and test_ScriptString().

ScriptStringValidate()

HRESULT WINAPI ScriptStringValidate

(

SCRIPT_STRING_ANALYSIS

ssa

)

Definition at line 3875 of file usp10.c.

{
    StringAnalysis *analysis = ssa;
 
    TRACE("(%p)\n", ssa);
 
    if (!analysis) return E_INVALIDARG;
    return analysis->flags & SCRIPT_STRING_ANALYSIS_FLAGS_INVALID ? S_FALSE : S_OK;
}

ScriptStringXtoCP()

HRESULT WINAPI ScriptStringXtoCP	(	SCRIPT_STRING_ANALYSIS	ssa,
		int	iX,
		int *	piCh,
		int *	piTrailing
	)

Definition at line 2495 of file usp10.c.

{
    StringAnalysis* analysis = ssa;
    int item;
 
    TRACE("(%p), %d, (%p), (%p)\n", ssa, iX, piCh, piTrailing);
 
    if (!ssa || !piCh || !piTrailing) return S_FALSE;
    if (!(analysis->ssa_flags & SSA_GLYPHS)) return S_FALSE;
 
    /* out of range */
    if(iX < 0)
    {
        if (analysis->pItem[0].a.fRTL)
        {
            *piCh = 1;
            *piTrailing = FALSE;
        }
        else
        {
            *piCh = -1;
            *piTrailing = TRUE;
        }
        return S_OK;
    }
 
    for(item=0; item<analysis->numItems; item++)
    {
        int i;
        int CP;
 
        for (i = 0; i < analysis->numItems && analysis->logical2visual[i] != item; i++)
        /* nothing */;
 
        CP = analysis->pItem[i+1].iCharPos - analysis->pItem[i].iCharPos;
        /* initialize max extents for uninitialized runs */
        if (analysis->glyphs[i].iMaxPosX == -1)
        {
            if (analysis->pItem[i].a.fRTL)
                ScriptCPtoX(0, FALSE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
                            analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
                            &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
            else
                ScriptCPtoX(CP, TRUE, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
                            analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
                            &analysis->pItem[i].a, &analysis->glyphs[i].iMaxPosX);
        }
 
        if (iX > analysis->glyphs[i].iMaxPosX)
        {
            iX -= analysis->glyphs[i].iMaxPosX;
            continue;
        }
 
        ScriptXtoCP(iX, CP, analysis->glyphs[i].numGlyphs, analysis->glyphs[i].pwLogClust,
                    analysis->glyphs[i].psva, analysis->glyphs[i].piAdvance,
                    &analysis->pItem[i].a, piCh, piTrailing);
        *piCh += analysis->pItem[i].iCharPos;
 
        return S_OK;
    }
 
    /* out of range */
    *piCh = analysis->pItem[analysis->numItems].iCharPos;
    *piTrailing = FALSE;
 
    return S_OK;
}

Referenced by EDIT_CharFromPos(), and test_ScriptStringXtoCP_CPtoX().

ScriptTextOut()

HRESULT WINAPI ScriptTextOut	(	const HDC	hdc,
		SCRIPT_CACHE *	psc,
		int	x,
		int	y,
		UINT	fuOptions,
		const RECT *	lprc,
		const SCRIPT_ANALYSIS *	psa,
		const WCHAR *	pwcReserved,
		int	iReserved,
		const WORD *	pwGlyphs,
		int	cGlyphs,
		const int *	piAdvance,
		const int *	piJustify,
		const GOFFSET *	pGoffset
	)

Definition at line 3616 of file usp10.c.

{
    HRESULT hr = S_OK;
    INT i, dir = 1;
    INT *lpDx;
    WORD *reordered_glyphs = (WORD *)pwGlyphs;
 
    TRACE("(%p, %p, %d, %d, %08x, %s, %p, %p, %d, %p, %d, %p, %p, %p)\n",
         hdc, psc, x, y, fuOptions, wine_dbgstr_rect(lprc), psa, pwcReserved, iReserved, pwGlyphs, cGlyphs,
         piAdvance, piJustify, pGoffset);
 
    if (!hdc || !psc) return E_INVALIDARG;
    if (!piAdvance || !psa || !pwGlyphs) return E_INVALIDARG;
 
    fuOptions &= ETO_CLIPPED + ETO_OPAQUE;
    fuOptions |= ETO_IGNORELANGUAGE;
    if  (!psa->fNoGlyphIndex)                                     /* Have Glyphs?                      */
        fuOptions |= ETO_GLYPH_INDEX;                             /* Say don't do translation to glyph */
 
    if (!(lpDx = heap_calloc(cGlyphs, 2 * sizeof(*lpDx))))
        return E_OUTOFMEMORY;
    fuOptions |= ETO_PDY;
 
    if (psa->fRTL && psa->fLogicalOrder)
    {
        if (!(reordered_glyphs = heap_calloc(cGlyphs, sizeof(*reordered_glyphs))))
        {
            heap_free( lpDx );
            return E_OUTOFMEMORY;
        }
 
        for (i = 0; i < cGlyphs; i++)
            reordered_glyphs[i] = pwGlyphs[cGlyphs - 1 - i];
        dir = -1;
    }
 
    for (i = 0; i < cGlyphs; i++)
    {
        int orig_index = (dir > 0) ? i : cGlyphs - 1 - i;
        lpDx[i * 2] = piAdvance[orig_index];
        lpDx[i * 2 + 1] = 0;
 
        if (pGoffset)
        {
            if (i == 0)
            {
                x += pGoffset[orig_index].du * dir;
                y += pGoffset[orig_index].dv;
            }
            else
            {
                lpDx[(i - 1) * 2]     += pGoffset[orig_index].du * dir;
                lpDx[(i - 1) * 2 + 1] += pGoffset[orig_index].dv;
            }
            lpDx[i * 2]     -= pGoffset[orig_index].du * dir;
            lpDx[i * 2 + 1] -= pGoffset[orig_index].dv;
        }
    }
 
    if (!ExtTextOutW(hdc, x, y, fuOptions, lprc, reordered_glyphs, cGlyphs, lpDx))
        hr = S_FALSE;
 
    if (reordered_glyphs != pwGlyphs) heap_free( reordered_glyphs );
    heap_free(lpDx);
 
    return hr;
}

Referenced by draw_text(), SS_ItemOut(), test_ScriptTextOut(), test_ScriptTextOut2(), and test_ScriptTextOut3().

ScriptXtoCP()

HRESULT WINAPI ScriptXtoCP	(	int	iX,
		int	cChars,
		int	cGlyphs,
		const WORD *	pwLogClust,
		const SCRIPT_VISATTR *	psva,
		const int *	piAdvance,
		const SCRIPT_ANALYSIS *	psa,
		int *	piCP,
		int *	piTrailing
	)

Definition at line 2875 of file usp10.c.

{
    int direction = 1;
    int iPosX;
    int i;
    int glyph_index, cluster_index;
    int cluster_size;
 
    TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
          iX, cChars, cGlyphs, pwLogClust, psva, piAdvance,
          psa, piCP, piTrailing);
 
    if (psa->fRTL && ! psa->fLogicalOrder)
        direction = -1;
 
    /* Handle an iX < 0 */
    if (iX < 0)
    {
        if (direction < 0)
        {
            *piCP = cChars;
            *piTrailing = 0;
        }
        else
        {
            *piCP = -1;
            *piTrailing = 1;
        }
        return S_OK;
    }
 
    /* Looking for non-reversed clusters in a reversed string */
    if (direction < 0)
    {
        int max_clust = pwLogClust[0];
        for (i=0; i< cChars; i++)
            if (pwLogClust[i] > max_clust)
            {
                FIXME("We do not handle non reversed clusters properly\n");
                break;
            }
    }
 
    /* find the glyph_index based in iX */
    if (direction > 0)
    {
        for (glyph_index = -1, iPosX = iX; iPosX >=0 && glyph_index < cGlyphs; iPosX -= piAdvance[glyph_index+1], glyph_index++)
            ;
    }
    else
    {
        for (glyph_index = -1, iPosX = iX; iPosX > 0 && glyph_index < cGlyphs; iPosX -= piAdvance[glyph_index+1], glyph_index++)
            ;
    }
 
    TRACE("iPosX %i ->  glyph_index %i (%i)\n", iPosX, glyph_index, cGlyphs);
 
    *piTrailing = 0;
    if (glyph_index >= 0 && glyph_index < cGlyphs)
    {
        /* find the cluster */
        if (direction > 0 )
            for (i = 0, cluster_index = pwLogClust[0]; i < cChars && pwLogClust[i] <= glyph_index; cluster_index=pwLogClust[i++])
                ;
        else
            for (i = 0, cluster_index = pwLogClust[0]; i < cChars && pwLogClust[i] >= glyph_index; cluster_index=pwLogClust[i++])
                ;
 
        TRACE("cluster_index %i\n", cluster_index);
 
        if (direction < 0 && iPosX >= 0 && glyph_index != cluster_index)
        {
            /* We are off the end of the string */
            *piCP = -1;
            *piTrailing = 1;
            return S_OK;
        }
 
        get_cluster_data(pwLogClust, cChars, cluster_index, &cluster_size, &i);
 
        TRACE("first char index %i\n",i);
        if (scriptInformation[psa->eScript].props.fNeedsCaretInfo)
        {
            /* Check trailing */
            if (glyph_index != cluster_index ||
                (direction > 0 && abs(iPosX) <= (piAdvance[glyph_index] / 2)) ||
                (direction < 0 && abs(iPosX) >= (piAdvance[glyph_index] / 2)))
                *piTrailing = cluster_size;
        }
        else
        {
            if (cluster_size > 1)
            {
                /* Be part way through the glyph cluster based on size and position */
                int cluster_advance = get_cluster_advance(piAdvance, psva, pwLogClust, cGlyphs, cChars, cluster_index, direction);
                double cluster_part_width = cluster_advance / (float)cluster_size;
                double adv;
                int part_index;
 
                /* back up to the beginning of the cluster */
                for (adv = iPosX, part_index = cluster_index; part_index <= glyph_index; part_index++)
                    adv += piAdvance[part_index];
                if (adv > iX) adv = iX;
 
                TRACE("Multi-char cluster, no snap\n");
                TRACE("cluster size %i, pre-cluster iPosX %f\n",cluster_size, adv);
                TRACE("advance %i divides into %f per char\n", cluster_advance, cluster_part_width);
                if (direction > 0)
                {
                    for (part_index = 0; adv >= 0; adv-=cluster_part_width, part_index++)
                        ;
                    if (part_index) part_index--;
                }
                else
                {
                    for (part_index = 0; adv > 0; adv-=cluster_part_width, part_index++)
                        ;
                    if (part_index > cluster_size)
                    {
                        adv += cluster_part_width;
                        part_index=cluster_size;
                    }
                }
 
                TRACE("base_char %i part_index %i, leftover advance %f\n",i, part_index, adv);
 
                if (direction > 0)
                    i += part_index;
                else
                    i += (cluster_size - part_index);
 
                /* Check trailing */
                if ((direction > 0 && fabs(adv) <= (cluster_part_width / 2.0)) ||
                    (direction < 0 && adv && fabs(adv) >= (cluster_part_width / 2.0)))
                    *piTrailing = 1;
            }
            else
            {
                /* Check trailing */
                if ((direction > 0 && abs(iPosX) <= (piAdvance[glyph_index] / 2)) ||
                    (direction < 0 && abs(iPosX) >= (piAdvance[glyph_index] / 2)))
                    *piTrailing = 1;
            }
        }
    }
    else
    {
        TRACE("Point falls outside of string\n");
        if (glyph_index < 0)
            i = cChars-1;
        else /* (glyph_index >= cGlyphs) */
            i = cChars;
 
        /* If not snaping in the reverse direction (such as Hebrew) Then 0
           point flow to the next character */
        if (direction < 0)
        {
            if (!scriptInformation[psa->eScript].props.fNeedsCaretInfo && abs(iPosX) == piAdvance[glyph_index])
                i++;
            else
                *piTrailing = 1;
        }
    }
 
    *piCP = i;
 
    TRACE("*piCP=%d\n", *piCP);
    TRACE("*piTrailing=%d\n", *piTrailing);
    return S_OK;
}

Referenced by _test_caret_item_ScriptXtoCP(), _test_item_ScriptXtoX(), ME_CharFromPointContext(), ScriptStringXtoCP(), and test_ScriptXtoX().

set_cache_font_properties()

static BOOL set_cache_font_properties ( const HDC  hdc, ScriptCache *  sc  )

inlinestatic

Definition at line 761 of file usp10.c.

{
    sc->sfp.cBytes = sizeof(sc->sfp);
 
    if (!sc->sfnt)
    {
        sc->sfp.wgBlank = sc->tm.tmBreakChar;
        sc->sfp.wgDefault = sc->tm.tmDefaultChar;
        sc->sfp.wgInvalid = sc->sfp.wgBlank;
        sc->sfp.wgKashida = 0xFFFF;
        sc->sfp.iKashidaWidth = 0;
    }
    else
    {
        static const WCHAR chars[4] = {0x0020, 0x200B, 0xF71B, 0x0640};
        /* U+0020: numeric space
           U+200B: zero width space
           U+F71B: unknown char found by black box testing
           U+0640: kashida */
        WORD gi[4];
 
        if (GetGlyphIndicesW(hdc, chars, 4, gi, GGI_MARK_NONEXISTING_GLYPHS) != GDI_ERROR)
        {
            if(gi[0] != 0xFFFF) /* 0xFFFF: index of default non exist char */
                sc->sfp.wgBlank = gi[0];
            else
                sc->sfp.wgBlank = 0;
 
            sc->sfp.wgDefault = 0;
 
            if (gi[2] != 0xFFFF)
                sc->sfp.wgInvalid = gi[2];
            else if (gi[1] != 0xFFFF)
                sc->sfp.wgInvalid = gi[1];
            else if (gi[0] != 0xFFFF)
                sc->sfp.wgInvalid = gi[0];
            else
                sc->sfp.wgInvalid = 0;
 
            sc->sfp.wgKashida = gi[3];
 
            sc->sfp.iKashidaWidth = 0; /* TODO */
        }
        else
            return FALSE;
    }
    return TRUE;
}

Referenced by init_script_cache().

set_cache_glyph()

static WORD set_cache_glyph ( SCRIPT_CACHE *  psc, WCHAR  c, WORD  glyph  )

inlinestatic

Definition at line 836 of file usp10.c.

{
    CacheGlyphPage **page = &((ScriptCache *)*psc)->page[c / 0x10000];
    WORD **block;
    if (!*page && !(*page = heap_alloc_zero(sizeof(CacheGlyphPage)))) return 0;
 
    block = &(*page)->glyphs[(c % 0x10000) >> GLYPH_BLOCK_SHIFT];
    if (!*block && !(*block = heap_alloc_zero(sizeof(WORD) * GLYPH_BLOCK_SIZE))) return 0;
    return ((*block)[(c % 0x10000) & GLYPH_BLOCK_MASK] = glyph);
}

Referenced by ScriptGetCMap(), and ScriptShapeOpenType().

set_cache_glyph_widths()

static BOOL set_cache_glyph_widths ( SCRIPT_CACHE *  psc, WORD  glyph, ABC *  abc  )

inlinestatic

Definition at line 857 of file usp10.c.

{
    ABC **block = &((ScriptCache *)*psc)->widths[glyph >> GLYPH_BLOCK_SHIFT];
 
    if (!*block && !(*block = heap_alloc_zero(sizeof(ABC) * GLYPH_BLOCK_SIZE))) return FALSE;
    memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], abc, sizeof(ABC));
    return TRUE;
}

Referenced by ScriptGetGlyphABCWidth(), and ScriptPlaceOpenType().

SS_ItemOut()

static HRESULT SS_ItemOut ( SCRIPT_STRING_ANALYSIS  ssa, int  iX, int  iY, int  iItem, int  cStart, int  cEnd, UINT  uOptions, const RECT *  prc, BOOL  fSelected, BOOL  fDisabled  )

static

Definition at line 2221 of file usp10.c.

{
    StringAnalysis *analysis;
    int off_x = 0;
    HRESULT hr;
    COLORREF BkColor = 0x0;
    COLORREF TextColor = 0x0;
    INT BkMode = 0;
    INT runStart, runEnd;
    INT iGlyph, cGlyphs;
    HFONT oldFont = 0x0;
    RECT  crc;
    int i;
 
    TRACE("(%p,%d,%d,%d,%d,%d, 0x%1x, %d, %d)\n",
         ssa, iX, iY, iItem, cStart, cEnd, uOptions, fSelected, fDisabled);
 
    if (!(analysis = ssa)) return E_INVALIDARG;
 
    if ((cStart >= 0 && analysis->pItem[iItem+1].iCharPos <= cStart) ||
         (cEnd >= 0 && analysis->pItem[iItem].iCharPos >= cEnd))
            return S_OK;
 
    CopyRect(&crc,prc);
    if (fSelected)
    {
        BkMode = GetBkMode(analysis->hdc);
        SetBkMode( analysis->hdc, OPAQUE);
        BkColor = GetBkColor(analysis->hdc);
        SetBkColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHT));
        if (!fDisabled)
        {
            TextColor = GetTextColor(analysis->hdc);
            SetTextColor(analysis->hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
        }
    }
    if (analysis->glyphs[iItem].fallbackFont)
        oldFont = SelectObject(analysis->hdc, analysis->glyphs[iItem].fallbackFont);
 
    if (cStart >= 0 && analysis->pItem[iItem+1].iCharPos > cStart && analysis->pItem[iItem].iCharPos <= cStart)
        runStart = cStart - analysis->pItem[iItem].iCharPos;
    else
        runStart =  0;
    if (cEnd >= 0 && analysis->pItem[iItem+1].iCharPos > cEnd && analysis->pItem[iItem].iCharPos <= cEnd)
        runEnd = (cEnd-1) - analysis->pItem[iItem].iCharPos;
    else
        runEnd = (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos) - 1;
 
    if (analysis->pItem[iItem].a.fRTL)
    {
        if (cEnd >= 0 && cEnd < analysis->pItem[iItem+1].iCharPos)
            ScriptStringCPtoX(ssa, cEnd, FALSE, &off_x);
        else
            ScriptStringCPtoX(ssa, analysis->pItem[iItem+1].iCharPos-1, TRUE, &off_x);
        crc.left = iX + off_x;
    }
    else
    {
        if (cStart >=0 && runStart)
            ScriptStringCPtoX(ssa, cStart, FALSE, &off_x);
        else
            ScriptStringCPtoX(ssa, analysis->pItem[iItem].iCharPos, FALSE, &off_x);
        crc.left = iX + off_x;
    }
 
    if (analysis->pItem[iItem].a.fRTL)
        iGlyph = analysis->glyphs[iItem].pwLogClust[runEnd];
    else
        iGlyph = analysis->glyphs[iItem].pwLogClust[runStart];
 
    if (analysis->pItem[iItem].a.fRTL)
        cGlyphs = analysis->glyphs[iItem].pwLogClust[runStart] - iGlyph;
    else
        cGlyphs = analysis->glyphs[iItem].pwLogClust[runEnd] - iGlyph;
 
    cGlyphs++;
 
    /* adjust for cluster glyphs when starting */
    if (analysis->pItem[iItem].a.fRTL)
        i = analysis->pItem[iItem+1].iCharPos - 1;
    else
        i = analysis->pItem[iItem].iCharPos;
 
    for (; i >=analysis->pItem[iItem].iCharPos && i < analysis->pItem[iItem+1].iCharPos; (analysis->pItem[iItem].a.fRTL)?i--:i++)
    {
        if (analysis->glyphs[iItem].pwLogClust[i - analysis->pItem[iItem].iCharPos] == iGlyph)
        {
            if (analysis->pItem[iItem].a.fRTL)
                ScriptStringCPtoX(ssa, i, TRUE, &off_x);
            else
                ScriptStringCPtoX(ssa, i, FALSE, &off_x);
            break;
        }
    }
 
    if (cEnd < 0 || scriptInformation[analysis->pItem[iItem].a.eScript].props.fNeedsCaretInfo)
    {
        INT direction;
        INT clust_glyph;
 
        clust_glyph = iGlyph + cGlyphs;
        if (analysis->pItem[iItem].a.fRTL)
            direction = -1;
        else
            direction = 1;
 
        while(clust_glyph < analysis->glyphs[iItem].numGlyphs &&
              !does_glyph_start_cluster(analysis->glyphs[iItem].psva, analysis->glyphs[iItem].pwLogClust, (analysis->pItem[iItem+1].iCharPos - analysis->pItem[iItem].iCharPos), clust_glyph, direction))
        {
            cGlyphs++;
            clust_glyph++;
        }
    }
 
    hr = ScriptTextOut(analysis->hdc,
                       (SCRIPT_CACHE *)&analysis->glyphs[iItem].sc, iX + off_x,
                       iY, uOptions, &crc, &analysis->pItem[iItem].a, NULL, 0,
                       &analysis->glyphs[iItem].glyphs[iGlyph], cGlyphs,
                       &analysis->glyphs[iItem].piAdvance[iGlyph], NULL,
                       &analysis->glyphs[iItem].pGoffset[iGlyph]);
 
    TRACE("ScriptTextOut hr=%08x\n", hr);
 
    if (fSelected)
    {
        SetBkColor(analysis->hdc, BkColor);
        SetBkMode( analysis->hdc, BkMode);
        if (!fDisabled)
            SetTextColor(analysis->hdc, TextColor);
    }
    if (analysis->glyphs[iItem].fallbackFont)
        SelectObject(analysis->hdc, oldFont);
 
    return hr;
}

Referenced by ScriptStringOut().

usp10_array_reserve()

BOOL usp10_array_reserve	(	void **	elements,
		SIZE_T *	capacity,
		SIZE_T	count,
		SIZE_T	size
	)

Definition at line 730 of file usp10.c.

{
    SIZE_T max_capacity, new_capacity;
    void *new_elements;
 
    if (count <= *capacity)
        return TRUE;
 
    max_capacity = ~(SIZE_T)0 / size;
    if (count > max_capacity)
        return FALSE;
 
    new_capacity = max(1, *capacity);
    while (new_capacity < count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
    if (new_capacity < count)
        new_capacity = count;
 
    if (!*elements)
        new_elements = heap_alloc_zero(new_capacity * size);
    else
        new_elements = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *elements, new_capacity * size);
    if (!new_elements)
        return FALSE;
 
    *elements = new_elements;
    *capacity = new_capacity;
    return TRUE;
}

Referenced by computeBracketPairs(), usp10_language_add_feature_list(), usp10_script_add_language(), and usp10_script_cache_add_script().

usp10_compare_script_range()

static int __cdecl usp10_compare_script_range ( const void *  key, const void *  value  )

static

Definition at line 957 of file usp10.c.

{
    const struct usp10_script_range *range = value;
    const DWORD *ch = key;
 
    if (*ch < range->rangeFirst)
        return -1;
    if (*ch > range->rangeLast)
        return 1;
    return 0;
}

Referenced by get_char_script().

USP10_FindGlyphInLogClust()

int USP10_FindGlyphInLogClust	(	const WORD *	pwLogClust,
		int	cChars,
		WORD	target
	)

Definition at line 1044 of file usp10.c.

{
    FindGlyph_struct fgs;
    WORD *ptr;
    INT k;
 
    if (pwLogClust[0] < pwLogClust[cChars-1])
        fgs.ascending = TRUE;
    else
        fgs.ascending = FALSE;
 
    fgs.target = target;
    ptr = bsearch(&fgs, pwLogClust, cChars, sizeof(WORD), compare_FindGlyph);
 
    if (!ptr)
        return -1;
 
    for (k = (ptr - pwLogClust)-1; k >= 0 && pwLogClust[k] == target; k--)
    ;
    k++;
 
    return k;
}

Referenced by does_glyph_start_cluster(), OpenType_GDEF_UpdateGlyphProps(), ShapeCharGlyphProp_Arabic(), ShapeCharGlyphProp_BaseIndic(), ShapeCharGlyphProp_Default(), ShapeCharGlyphProp_Hebrew(), ShapeCharGlyphProp_None(), ShapeCharGlyphProp_Thai(), ShapeCharGlyphProp_Tibet(), and UpdateClusters().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

uniscribe

)

Variable Documentation

cs_script_cache

static CRITICAL_SECTION cs_script_cache = { &cs_script_cache_dbg, -1, 0, 0, 0, 0 }

static

Definition at line 681 of file usp10.c.

Referenced by init_script_cache(), and ScriptFreeCache().

cs_script_cache_dbg

CRITICAL_SECTION_DEBUG cs_script_cache_dbg

static

Initial value:

=
{
    0, 0, &cs_script_cache,
    { &cs_script_cache_dbg.ProcessLocksList, &cs_script_cache_dbg.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": script_cache") }
}

Definition at line 682 of file usp10.c.

script_cache_list

struct list script_cache_list = LIST_INIT(script_cache_list)

static

Definition at line 689 of file usp10.c.

Referenced by init_script_cache().

script_props

const SCRIPT_PROPERTIES* script_props[]

static

Definition at line 636 of file usp10.c.

Referenced by ScriptGetProperties().

script_ranges

const struct usp10_script_range script_ranges[]

static

Referenced by get_char_script().

scriptInformation

const scriptData scriptInformation[]

Definition at line 305 of file usp10.c.

Referenced by _ItemizeInternal(), find_fallback_font(), get_opentype_script(), script_is_numeric(), ScriptCPtoX(), ScriptIsComplex(), ScriptPlace(), ScriptShape(), ScriptStringAnalyse(), ScriptXtoCP(), SHAPE_ApplyOpenTypeFeatures(), SHAPE_GetFontFeatureTags(), SHAPE_GetFontScriptTags(), and SS_ItemOut().