2 * Implementation of Uniscribe Script Processor (usp10.dll)
4 * Copyright 2005 Steven Edwards for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 * Uniscribe allows for processing of complex scripts such as joining
22 * and filtering characters and bi-directional text with custom line breaks.
34 #include "wine/debug.h"
37 * some documentation here:
38 * http://www.microsoft.com/typography/developers/uniscribe/uniscribe.htm
41 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe
);
45 /* Set up a default for ScriptGetProperties */
46 static const SCRIPT_PROPERTIES Default_Script_0
= {0, 0, 0, 0, 0, 0, 0, 0,
48 static const SCRIPT_PROPERTIES Default_Script_1
= {0, 0, 0, 0, 0, 0, 0, 0,
50 static const SCRIPT_PROPERTIES Default_Script_2
= {0, 0, 0, 0, 0, 0, 0, 0,
52 static const SCRIPT_PROPERTIES Default_Script_3
= {9, 0, 0, 0, 0, 0, 0, 0,
54 static const SCRIPT_PROPERTIES Default_Script_4
= {9, 1, 0, 0, 0, 0, 0, 0,
56 static const SCRIPT_PROPERTIES Default_Script_5
= {9, 0, 0, 0, 0, 0, 0, 0,
58 static const SCRIPT_PROPERTIES Default_Script_6
= {9, 1, 0, 0, 0, 0, 0, 0,
60 static const SCRIPT_PROPERTIES Default_Script_7
= {8, 0, 0, 0, 0, 161, 0, 0,
62 static const SCRIPT_PROPERTIES
*Global_Script
[MAX_SCRIPTS
] =
72 typedef struct scriptcache
{
97 /***********************************************************************
101 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID lpv
)
104 case DLL_PROCESS_ATTACH
:
105 DisableThreadLibraryCalls(hInstDLL
);
107 case DLL_PROCESS_DETACH
:
113 /***********************************************************************
114 * ScriptFreeCache (USP10.@)
117 HRESULT WINAPI
ScriptFreeCache(SCRIPT_CACHE
*psc
)
122 HeapFree ( GetProcessHeap(), 0, *psc
);
128 /***********************************************************************
129 * ScriptGetProperties (USP10.@)
132 HRESULT WINAPI
ScriptGetProperties(const SCRIPT_PROPERTIES
***ppSp
, int *piNumScripts
)
134 TRACE("%p,%p\n", ppSp
, piNumScripts
);
136 if (!ppSp
&& !piNumScripts
) return E_INVALIDARG
;
138 /* Set up a sensible default and intialise pointers */
139 if (piNumScripts
) *piNumScripts
= MAX_SCRIPTS
;
140 if (ppSp
) *ppSp
= Global_Script
;
141 TRACE("ppSp:%p, *ppSp:%p, **ppSp:%p, %d\n",
142 ppSp
, ppSp
? *ppSp
: NULL
, (ppSp
&& *ppSp
) ? **ppSp
: NULL
,
143 piNumScripts
? *piNumScripts
: -1);
147 /***********************************************************************
148 * ScriptGetFontProperties (USP10.@)
151 HRESULT WINAPI
ScriptGetFontProperties(HDC hdc
, SCRIPT_CACHE
*psc
, SCRIPT_FONTPROPERTIES
*sfp
)
154 Scriptcache
*pScriptcache
;
157 TRACE("%p,%p,%p\n", hdc
, psc
, sfp
);
162 TRACE("No Script_Cache (psc) and no hdc. Ask for one. Hdc=%p, psc=%p\n", hdc
, *psc
);
166 pScriptcache
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(Scriptcache
) );
167 pScriptcache
->hdc
= (HDC
) hdc
;
169 *psc
= (Scriptcache
*) pScriptcache
;
172 pScriptcache
= (Scriptcache
*) *psc
;
173 phdc
= pScriptcache
->hdc
;
176 if (sfp
->cBytes
!= sizeof(SCRIPT_FONTPROPERTIES
))
179 /* return something sensible? */
181 if (GetTextMetricsW(phdc
, &ptm
))
182 sfp
->wgDefault
= ptm
.tmDefaultChar
;
186 sfp
->wgKashida
= 0xffff;
187 sfp
->iKashidaWidth
= 0;
191 /***********************************************************************
192 * ScriptRecordDigitSubstitution (USP10.@)
194 * Record digit substitution settings for a given locale.
197 * locale [I] Locale identifier.
198 * sds [I] Structure to record substitution settings.
202 * Failure: E_POINTER if sds is NULL, E_INVALIDARG otherwise.
205 * http://blogs.msdn.com/michkap/archive/2006/02/22/536877.aspx
207 HRESULT WINAPI
ScriptRecordDigitSubstitution(LCID locale
, SCRIPT_DIGITSUBSTITUTE
*sds
)
211 TRACE("0x%x, %p\n", locale
, sds
);
213 /* This implementation appears to be correct for all languages, but it's
214 * not clear if sds->DigitSubstitute is ever set to anything except
215 * CONTEXT or NONE in reality */
217 if (!sds
) return E_POINTER
;
219 locale
= ConvertDefaultLocale(locale
);
221 if (!IsValidLocale(locale
, LCID_INSTALLED
))
224 plgid
= PRIMARYLANGID(LANGIDFROMLCID(locale
));
225 sds
->TraditionalDigitLanguage
= plgid
;
227 if (plgid
== LANG_ARABIC
|| plgid
== LANG_FARSI
)
228 sds
->NationalDigitLanguage
= plgid
;
230 sds
->NationalDigitLanguage
= LANG_ENGLISH
;
232 if (!GetLocaleInfoW(locale
, LOCALE_IDIGITSUBSTITUTION
| LOCALE_RETURN_NUMBER
,
233 (LPWSTR
)&sub
, sizeof(sub
)/sizeof(WCHAR
))) return E_INVALIDARG
;
238 if (plgid
== LANG_ARABIC
|| plgid
== LANG_FARSI
)
239 sds
->DigitSubstitute
= SCRIPT_DIGITSUBSTITUTE_CONTEXT
;
241 sds
->DigitSubstitute
= SCRIPT_DIGITSUBSTITUTE_NONE
;
244 sds
->DigitSubstitute
= SCRIPT_DIGITSUBSTITUTE_NONE
;
247 sds
->DigitSubstitute
= SCRIPT_DIGITSUBSTITUTE_NATIONAL
;
250 sds
->DigitSubstitute
= SCRIPT_DIGITSUBSTITUTE_TRADITIONAL
;
258 /***********************************************************************
259 * ScriptApplyDigitSubstitution (USP10.@)
261 * Apply digit substitution settings.
264 * sds [I] Structure with recorded substitution settings.
265 * sc [I] Script control structure.
266 * ss [I] Script state structure.
270 * Failure: E_INVALIDARG if sds is invalid. Otherwise an HRESULT.
272 HRESULT WINAPI
ScriptApplyDigitSubstitution(const SCRIPT_DIGITSUBSTITUTE
*sds
,
273 SCRIPT_CONTROL
*sc
, SCRIPT_STATE
*ss
)
275 SCRIPT_DIGITSUBSTITUTE psds
;
277 TRACE("%p, %p, %p\n", sds
, sc
, ss
);
279 if (!sc
|| !ss
) return E_POINTER
;
283 if (ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT
, &psds
) != S_OK
)
287 sc
->uDefaultLanguage
= LANG_ENGLISH
;
288 sc
->fContextDigits
= 0;
289 ss
->fDigitSubstitute
= 0;
291 switch (sds
->DigitSubstitute
) {
292 case SCRIPT_DIGITSUBSTITUTE_CONTEXT
:
293 case SCRIPT_DIGITSUBSTITUTE_NATIONAL
:
294 case SCRIPT_DIGITSUBSTITUTE_NONE
:
295 case SCRIPT_DIGITSUBSTITUTE_TRADITIONAL
:
302 /***********************************************************************
303 * ScriptItemize (USP10.@)
306 HRESULT WINAPI
ScriptItemize(const WCHAR
*pwcInChars
, int cInChars
, int cMaxItems
,
307 const SCRIPT_CONTROL
*psControl
, const SCRIPT_STATE
*psState
,
308 SCRIPT_ITEM
*pItems
, int *pcItems
)
311 #define Numeric_start 0x0030
312 #define Numeric_stop 0x0039
313 #define Numeric_space 0x0020
314 #define Arabic_start 0x0600
315 #define Arabic_stop 0x06ff
316 #define Latin_start 0x0001
317 #define Latin_stop 0x024f
318 #define Script_Arabic 6
319 #define Script_Latin 1
320 #define Script_Numeric 5
322 int cnt
= 0, index
= 0;
323 int New_Script
= SCRIPT_UNDEFINED
;
325 TRACE("%s,%d,%d,%p,%p,%p,%p\n", debugstr_wn(pwcInChars
, cInChars
), cInChars
, cMaxItems
,
326 psControl
, psState
, pItems
, pcItems
);
328 if (!pwcInChars
|| !cInChars
|| !pItems
|| cMaxItems
< 2)
331 if (pwcInChars
[cnt
] >= Numeric_start
&& pwcInChars
[cnt
] <= Numeric_stop
)
332 pItems
[index
].a
.eScript
= Script_Numeric
;
334 if (pwcInChars
[cnt
] >= Arabic_start
&& pwcInChars
[cnt
] <= Arabic_stop
)
335 pItems
[index
].a
.eScript
= Script_Arabic
;
337 if (pwcInChars
[cnt
] >= Latin_start
&& pwcInChars
[cnt
] <= Latin_stop
)
338 pItems
[index
].a
.eScript
= Script_Latin
;
340 pItems
[index
].a
.eScript
= SCRIPT_UNDEFINED
;
341 pItems
[index
].iCharPos
= 0;
342 /* Set the SCRIPT_ANALYSIS */
343 pItems
[index
].a
.fRTL
= 0;
344 pItems
[index
].a
.fLayoutRTL
= 0;
345 pItems
[index
].a
.fLinkBefore
= 0;
346 pItems
[index
].a
.fLinkAfter
= 0;
347 pItems
[index
].a
.fLogicalOrder
= 0;
348 pItems
[index
].a
.fNoGlyphIndex
= 0;
349 /* set the SCRIPT_STATE */
350 if (pItems
[index
].a
.eScript
== Script_Arabic
)
351 pItems
[index
].a
.s
.uBidiLevel
= 1;
353 pItems
[index
].a
.s
.uBidiLevel
= 0;
354 pItems
[index
].a
.s
.fOverrideDirection
= 0;
355 pItems
[index
].a
.s
.fInhibitSymSwap
= FALSE
;
356 pItems
[index
].a
.s
.fCharShape
= 0;
357 pItems
[index
].a
.s
.fDigitSubstitute
= 0;
358 pItems
[index
].a
.s
.fInhibitLigate
= 0;
359 pItems
[index
].a
.s
.fDisplayZWG
= 0;
360 pItems
[index
].a
.s
.fArabicNumContext
= 0;
361 pItems
[index
].a
.s
.fGcpClusters
= 0;
362 pItems
[index
].a
.s
.fReserved
= 0;
363 pItems
[index
].a
.s
.fEngineReserved
= 0;
364 TRACE("New_Script=%d, eScript=%d index=%d cnt=%d iCharPos=%d\n",
365 New_Script
, pItems
[index
].a
.eScript
, index
, cnt
,
366 pItems
[index
].iCharPos
= cnt
);
368 for (cnt
=0; cnt
< cInChars
; cnt
++)
370 if ((pwcInChars
[cnt
] >= Numeric_start
&& pwcInChars
[cnt
] <= Numeric_stop
)
371 || (New_Script
== Script_Numeric
&& pwcInChars
[cnt
] == Numeric_space
))
372 New_Script
= Script_Numeric
;
374 if ((pwcInChars
[cnt
] >= Arabic_start
&& pwcInChars
[cnt
] <= Arabic_stop
)
375 || (New_Script
== Script_Arabic
&& pwcInChars
[cnt
] == Numeric_space
))
376 New_Script
= Script_Arabic
;
378 if ((WCHAR
) pwcInChars
[cnt
] >= Latin_start
&& (WCHAR
) pwcInChars
[cnt
] <= Latin_stop
)
379 New_Script
= Script_Latin
;
381 New_Script
= SCRIPT_UNDEFINED
;
383 if (New_Script
!= pItems
[index
].a
.eScript
)
385 TRACE("New_Script=%d, eScript=%d ", New_Script
, pItems
[index
].a
.eScript
);
387 if (index
+1 > cMaxItems
)
388 return E_OUTOFMEMORY
;
389 pItems
[index
].iCharPos
= cnt
;
390 if (New_Script
== Script_Arabic
)
391 pItems
[index
].a
.s
.uBidiLevel
= 1;
392 /* Set SCRIPT_ITEM */
393 pItems
[index
].iCharPos
= cnt
;
394 /* Set the SCRIPT_ANALYSIS */
395 pItems
[index
].a
.eScript
= New_Script
;
396 pItems
[index
].a
.fRTL
= 0;
397 pItems
[index
].a
.fLayoutRTL
= 0;
398 pItems
[index
].a
.fLinkBefore
= 0;
399 pItems
[index
].a
.fLinkAfter
= 0;
400 pItems
[index
].a
.fLogicalOrder
= 0;
401 pItems
[index
].a
.fNoGlyphIndex
= 0;
402 /* set the SCRIPT_STATE */
403 if (New_Script
== Script_Arabic
)
404 pItems
[index
].a
.s
.uBidiLevel
= 1;
406 pItems
[index
].a
.s
.uBidiLevel
= 0;
407 pItems
[index
].a
.s
.fOverrideDirection
= 0;
408 pItems
[index
].a
.s
.fInhibitSymSwap
= FALSE
;
409 pItems
[index
].a
.s
.fCharShape
= 0;
410 pItems
[index
].a
.s
.fDigitSubstitute
= 0;
411 pItems
[index
].a
.s
.fInhibitLigate
= 0;
412 pItems
[index
].a
.s
.fDisplayZWG
= 0;
413 pItems
[index
].a
.s
.fArabicNumContext
= 0;
414 pItems
[index
].a
.s
.fGcpClusters
= 0;
415 pItems
[index
].a
.s
.fReserved
= 0;
416 pItems
[index
].a
.s
.fEngineReserved
= 0;
417 TRACE("index=%d cnt=%d iCharPos=%d\n", index
, cnt
, pItems
[index
].iCharPos
= cnt
);
421 /* While not strictly necessary according to the spec, make sure the n+1
422 * item is set up to prevent random behaviour if the caller erroneously
423 * checks the n+1 structure */
424 pItems
[index
+1].a
.eScript
= 0;
425 pItems
[index
+1].a
.fRTL
= 0;
426 pItems
[index
+1].a
.fLayoutRTL
= 0;
427 pItems
[index
+1].a
.fLinkBefore
= 0;
428 pItems
[index
+1].a
.fLinkAfter
= 0;
429 pItems
[index
+1].a
.fLogicalOrder
= 0;
430 pItems
[index
+1].a
.fNoGlyphIndex
= 0;
431 /* set the SCRIPT_STATE */
432 pItems
[index
+1].a
.s
.uBidiLevel
= 0;
433 pItems
[index
+1].a
.s
.fOverrideDirection
= 0;
434 pItems
[index
+1].a
.s
.fInhibitSymSwap
= FALSE
;
435 pItems
[index
+1].a
.s
.fCharShape
= 0;
436 pItems
[index
+1].a
.s
.fDigitSubstitute
= 0;
437 pItems
[index
+1].a
.s
.fInhibitLigate
= 0;
438 pItems
[index
+1].a
.s
.fDisplayZWG
= 0;
439 pItems
[index
+1].a
.s
.fArabicNumContext
= 0;
440 pItems
[index
+1].a
.s
.fGcpClusters
= 0;
441 pItems
[index
+1].a
.s
.fReserved
= 0;
442 pItems
[index
+1].a
.s
.fEngineReserved
= 0;
443 TRACE("index=%d cnt=%d iCharPos=%d\n", index
+1, cnt
, pItems
[index
+1].iCharPos
= cnt
);
445 /* Set one SCRIPT_STATE item being returned */
446 *pcItems
= index
+ 1;
448 /* Set SCRIPT_ITEM */
449 pItems
[index
+1].iCharPos
= cnt
; /* the last + 1 item
450 contains the ptr to the lastchar */
454 /***********************************************************************
455 * ScriptStringAnalyse (USP10.@)
458 HRESULT WINAPI
ScriptStringAnalyse(HDC hdc
,
465 SCRIPT_CONTROL
*psControl
,
466 SCRIPT_STATE
*psState
,
468 SCRIPT_TABDEF
*pTabdef
,
469 const BYTE
*pbInClass
,
470 SCRIPT_STRING_ANALYSIS
*pssa
)
473 StringAnalysis
* analysis
;
474 int numItemizedItems
;
476 SCRIPT_CACHE
* sc
= 0;
478 TRACE("(%p,%p,%d,%d,%d,0x%x,%d,%p,%p,%p,%p,%p,%p)\n",
479 hdc
, pString
, cString
, cGlyphs
, iCharset
, dwFlags
,
480 iReqWidth
, psControl
, psState
, piDx
, pTabdef
, pbInClass
, pssa
);
482 if (1 > cString
|| NULL
== pString
) {
485 if ((dwFlags
& SSA_GLYPHS
) && NULL
== hdc
) {
489 analysis
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
490 sizeof(StringAnalysis
));
493 numItemizedItems
= 255;
494 analysis
->pItem
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
495 numItemizedItems
*sizeof(SCRIPT_ITEM
)+1);
497 hr
= ScriptItemize(pString
, cString
, numItemizedItems
, psControl
,
498 psState
, analysis
->pItem
, &analysis
->numItems
);
500 while(hr
== E_OUTOFMEMORY
)
502 numItemizedItems
*= 2;
503 HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, analysis
->pItem
,
504 numItemizedItems
*sizeof(SCRIPT_ITEM
)+1);
505 hr
= ScriptItemize(pString
, cString
, numItemizedItems
, psControl
,
506 psState
, analysis
->pItem
, &analysis
->numItems
);
509 analysis
->glyphs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
510 sizeof(StringGlyphs
)*analysis
->numItems
);
511 sc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SCRIPT_CACHE
));
513 for(i
=0; i
<analysis
->numItems
; i
++)
515 int cChar
= analysis
->pItem
[i
+1].iCharPos
- analysis
->pItem
[i
].iCharPos
;
516 int numGlyphs
= 1.5 * cChar
+ 16;
517 WORD
* glyphs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WORD
)*numGlyphs
);
518 WORD
* pwLogClust
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WORD
)*cChar
);
519 int* piAdvance
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(int)*numGlyphs
);
520 SCRIPT_VISATTR
* psva
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SCRIPT_VISATTR
)*cChar
);
521 GOFFSET
* pGoffset
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GOFFSET
)*numGlyphs
);
522 ABC
* abc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(ABC
));
523 int numGlyphsReturned
;
525 /* FIXME: non unicode strings */
526 WCHAR
* pStr
= (WCHAR
*)pString
;
527 hr
= ScriptShape(hdc
, sc
, &pStr
[analysis
->pItem
[i
].iCharPos
],
528 cChar
, numGlyphs
, &analysis
->pItem
[i
].a
,
529 glyphs
, pwLogClust
, psva
, &numGlyphsReturned
);
530 hr
= ScriptPlace(hdc
, sc
, glyphs
, numGlyphsReturned
, psva
, &analysis
->pItem
[i
].a
,
531 piAdvance
, pGoffset
, abc
);
533 analysis
->glyphs
[i
].numGlyphs
= numGlyphsReturned
;
534 analysis
->glyphs
[i
].glyphs
= glyphs
;
535 analysis
->glyphs
[i
].pwLogClust
= pwLogClust
;
536 analysis
->glyphs
[i
].piAdvance
= piAdvance
;
537 analysis
->glyphs
[i
].psva
= psva
;
538 analysis
->glyphs
[i
].pGoffset
= pGoffset
;
539 analysis
->glyphs
[i
].abc
= abc
;
542 HeapFree(GetProcessHeap(), 0, sc
);
549 /***********************************************************************
550 * ScriptStringOut (USP10.@)
553 HRESULT WINAPI
ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa
,
562 FIXME("(%p,%d,%d,0x%1x,%p,%d,%d,%d): stub\n",
563 ssa
, iX
, iY
, uOptions
, prc
, iMinSel
, iMaxSel
, fDisabled
);
571 /***********************************************************************
572 * ScriptStringCPtoX (USP10.@)
575 HRESULT WINAPI
ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa
, int icp
, BOOL fTrailing
, int* pX
)
580 StringAnalysis
* analysis
= ssa
;
581 TRACE("(%p), %d, %d, (%p)\n", ssa
, icp
, fTrailing
, pX
);
588 /* icp out of range */
591 analysis
->invalid
= TRUE
;
595 for(i
=0; i
<analysis
->numItems
; i
++)
597 for(j
=0; j
<analysis
->glyphs
[i
].numGlyphs
; j
++)
599 if(runningCp
== icp
&& fTrailing
== FALSE
)
604 runningX
+= analysis
->glyphs
[i
].piAdvance
[j
];
605 if(runningCp
== icp
&& fTrailing
== TRUE
)
614 /* icp out of range */
615 analysis
->invalid
= TRUE
;
619 /***********************************************************************
620 * ScriptStringXtoCP (USP10.@)
623 HRESULT WINAPI
ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa
, int iX
, int* piCh
, int* piTrailing
)
625 StringAnalysis
* analysis
= ssa
;
632 TRACE("(%p), %d, (%p), (%p)\n", ssa
, iX
, piCh
, piTrailing
);
634 if(!ssa
|| !piCh
|| !piTrailing
)
647 for(i
=0; i
<analysis
->numItems
; i
++)
649 for(j
=0; j
<analysis
->glyphs
[i
].numGlyphs
; j
++)
651 width
= analysis
->glyphs
[i
].piAdvance
[j
];
652 if(iX
< (runningX
+ width
))
655 if((iX
- runningX
) > width
/2)
667 *piCh
= analysis
->pItem
[analysis
->numItems
].iCharPos
;
674 /***********************************************************************
675 * ScriptStringFree (USP10.@)
678 HRESULT WINAPI
ScriptStringFree(SCRIPT_STRING_ANALYSIS
*pssa
)
680 StringAnalysis
* analysis
;
683 TRACE("(%p)\n",pssa
);
692 invalid
= analysis
->invalid
;
694 for(i
=0; i
<analysis
->numItems
; i
++)
696 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
[i
].glyphs
);
697 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
[i
].pwLogClust
);
698 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
[i
].piAdvance
);
699 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
[i
].psva
);
700 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
[i
].pGoffset
);
701 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
[i
].abc
);
704 HeapFree(GetProcessHeap(), 0, analysis
->glyphs
);
705 HeapFree(GetProcessHeap(), 0, analysis
->pItem
);
706 HeapFree(GetProcessHeap(), 0, analysis
->sz
);
707 HeapFree(GetProcessHeap(), 0, analysis
);
715 /***********************************************************************
716 * ScriptCPtoX (USP10.@)
719 HRESULT WINAPI
ScriptCPtoX(int iCP
,
723 const WORD
*pwLogClust
,
724 const SCRIPT_VISATTR
*psva
,
725 const int *piAdvance
,
726 const SCRIPT_ANALYSIS
*psa
,
732 TRACE("(%d,%d,%d,%d,%p,%p,%p,%p,%p)\n",
733 iCP
, fTrailing
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
,
735 for (item
=0; item
< cGlyphs
; item
++) /* total piAdvance */
736 fMaxPosX
+= piAdvance
[item
];
737 iPosX
= (fMaxPosX
/cGlyphs
)*(iCP
+fTrailing
);
738 if (iPosX
> fMaxPosX
)
740 *piX
= iPosX
; /* Return something in range */
742 TRACE("*piX=%d\n", *piX
);
746 /***********************************************************************
747 * ScriptXtoCP (USP10.@)
750 HRESULT WINAPI
ScriptXtoCP(int iX
,
753 const WORD
*pwLogClust
,
754 const SCRIPT_VISATTR
*psva
,
755 const int *piAdvance
,
756 const SCRIPT_ANALYSIS
*psa
,
764 TRACE("(%d,%d,%d,%p,%p,%p,%p,%p,%p)\n",
765 iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
,
766 psa
, piCP
, piTrailing
);
767 if (iX
< 0) /* iX is before start of run */
774 for (item
=0; item
< cGlyphs
; item
++) /* total piAdvance */
775 fMaxPosX
+= piAdvance
[item
];
777 if (iX
>= fMaxPosX
) /* iX too large */
784 fAvePosX
= fMaxPosX
/ cGlyphs
;
786 for (item
= 1; item
< cGlyphs
&& iPosX
< iX
; item
++)
788 if (iPosX
- iX
> fAvePosX
/2)
791 *piTrailing
= 1; /* yep we are over halfway */
793 *piCP
= item
-1; /* Return character position */
794 TRACE("*piCP=%d iPposX=%d\n", *piCP
, iPosX
);
798 /***********************************************************************
799 * ScriptBreak (USP10.@)
802 HRESULT WINAPI
ScriptBreak(const WCHAR
*pwcChars
, int cChars
, const SCRIPT_ANALYSIS
*psa
,
803 SCRIPT_LOGATTR
*psla
)
805 FIXME("(%p,%d,%p,%p): stub\n",
806 pwcChars
, cChars
, psa
, psla
);
819 { 0, 0x0b, SIC_COMPLEX
},
820 { 0x0c, 0x0c, SIC_NEUTRAL
},
821 { 0x0d, 0x1f, SIC_COMPLEX
},
822 { 0x20, 0x2f, SIC_NEUTRAL
},
823 { 0x30, 0x39, SIC_ASCIIDIGIT
},
824 { 0x3a, 0x40, SIC_NEUTRAL
},
825 { 0x5b, 0x60, SIC_NEUTRAL
},
826 { 0x7b, 0x7e, SIC_NEUTRAL
},
827 { 0x7f, 0x9f, SIC_COMPLEX
},
828 { 0xa0, 0xa5, SIC_NEUTRAL
},
829 { 0xa7, 0xa8, SIC_NEUTRAL
},
830 { 0xab, 0xab, SIC_NEUTRAL
},
831 { 0xad, 0xad, SIC_NEUTRAL
},
832 { 0xaf, 0xaf, SIC_NEUTRAL
},
833 { 0xb0, 0xb1, SIC_NEUTRAL
},
834 { 0xb4, 0xb4, SIC_NEUTRAL
},
835 { 0xb6, 0xb8, SIC_NEUTRAL
},
836 { 0xbb, 0xbf, SIC_NEUTRAL
},
837 { 0xd7, 0xd7, SIC_NEUTRAL
},
838 { 0xf7, 0xf7, SIC_NEUTRAL
},
839 { 0x2b9, 0x2ba, SIC_NEUTRAL
},
840 { 0x2c2, 0x2cf, SIC_NEUTRAL
},
841 { 0x2d2, 0x2df, SIC_NEUTRAL
},
842 { 0x2e5, 0x2e9, SIC_COMPLEX
},
843 { 0x2ea, 0x2ed, SIC_NEUTRAL
},
844 { 0x300, 0x362, SIC_COMPLEX
},
845 { 0x530, 0x60b, SIC_COMPLEX
},
846 { 0x60c, 0x60d, SIC_NEUTRAL
},
847 { 0x60e, 0x669, SIC_COMPLEX
},
848 { 0x66a, 0x66a, SIC_NEUTRAL
},
849 { 0x66b, 0x6e8, SIC_COMPLEX
},
850 { 0x6e9, 0x6e9, SIC_NEUTRAL
},
851 { 0x6ea, 0x7bf, SIC_COMPLEX
},
852 { 0x900, 0x1360, SIC_COMPLEX
},
853 { 0x137d, 0x137f, SIC_COMPLEX
},
854 { 0x1680, 0x1680, SIC_NEUTRAL
},
855 { 0x1780, 0x18af, SIC_COMPLEX
},
856 { 0x2000, 0x200a, SIC_NEUTRAL
},
857 { 0x200b, 0x200f, SIC_COMPLEX
},
858 { 0x2010, 0x2016, SIC_NEUTRAL
},
859 { 0x2018, 0x2022, SIC_NEUTRAL
},
860 { 0x2024, 0x2028, SIC_NEUTRAL
},
861 { 0x2029, 0x202e, SIC_COMPLEX
},
862 { 0x202f, 0x2037, SIC_NEUTRAL
},
863 { 0x2039, 0x203c, SIC_NEUTRAL
},
864 { 0x2044, 0x2046, SIC_NEUTRAL
},
865 { 0x206a, 0x206f, SIC_COMPLEX
},
866 { 0x207a, 0x207e, SIC_NEUTRAL
},
867 { 0x208a, 0x20aa, SIC_NEUTRAL
},
868 { 0x20ac, 0x20cf, SIC_NEUTRAL
},
869 { 0x20d0, 0x20ff, SIC_COMPLEX
},
870 { 0x2103, 0x2103, SIC_NEUTRAL
},
871 { 0x2105, 0x2105, SIC_NEUTRAL
},
872 { 0x2109, 0x2109, SIC_NEUTRAL
},
873 { 0x2116, 0x2116, SIC_NEUTRAL
},
874 { 0x2121, 0x2122, SIC_NEUTRAL
},
875 { 0x212e, 0x212e, SIC_NEUTRAL
},
876 { 0x2153, 0x2154, SIC_NEUTRAL
},
877 { 0x215b, 0x215e, SIC_NEUTRAL
},
878 { 0x2190, 0x2199, SIC_NEUTRAL
},
879 { 0x21b8, 0x21b9, SIC_NEUTRAL
},
880 { 0x21d2, 0x21d2, SIC_NEUTRAL
},
881 { 0x21d4, 0x21d4, SIC_NEUTRAL
},
882 { 0x21e7, 0x21e7, SIC_NEUTRAL
},
883 { 0x2200, 0x2200, SIC_NEUTRAL
},
884 { 0x2202, 0x2203, SIC_NEUTRAL
},
885 { 0x2207, 0x2208, SIC_NEUTRAL
},
886 { 0x220b, 0x220b, SIC_NEUTRAL
},
887 { 0x220f, 0x220f, SIC_NEUTRAL
},
888 { 0x2211, 0x2213, SIC_NEUTRAL
},
889 { 0x2215, 0x2215, SIC_NEUTRAL
},
890 { 0x221a, 0x221a, SIC_NEUTRAL
},
891 { 0x221d, 0x2220, SIC_NEUTRAL
},
892 { 0x2223, 0x2223, SIC_NEUTRAL
},
893 { 0x2225, 0x2225, SIC_NEUTRAL
},
894 { 0x2227, 0x222c, SIC_NEUTRAL
},
895 { 0x222e, 0x222e, SIC_NEUTRAL
},
896 { 0x2234, 0x2237, SIC_NEUTRAL
},
897 { 0x223c, 0x223d, SIC_NEUTRAL
},
898 { 0x2248, 0x2248, SIC_NEUTRAL
},
899 { 0x224c, 0x224c, SIC_NEUTRAL
},
900 { 0x2252, 0x2252, SIC_NEUTRAL
},
901 { 0x2260, 0x2261, SIC_NEUTRAL
},
902 { 0x2264, 0x2267, SIC_NEUTRAL
},
903 { 0x226a, 0x226b, SIC_NEUTRAL
},
904 { 0x226e, 0x226f, SIC_NEUTRAL
},
905 { 0x2282, 0x2283, SIC_NEUTRAL
},
906 { 0x2286, 0x2287, SIC_NEUTRAL
},
907 { 0x2295, 0x2295, SIC_NEUTRAL
},
908 { 0x2299, 0x2299, SIC_NEUTRAL
},
909 { 0x22a5, 0x22a5, SIC_NEUTRAL
},
910 { 0x22bf, 0x22bf, SIC_NEUTRAL
},
911 { 0x2312, 0x2312, SIC_NEUTRAL
},
912 { 0x24ea, 0x24ea, SIC_COMPLEX
},
913 { 0x2500, 0x254b, SIC_NEUTRAL
},
914 { 0x2550, 0x256d, SIC_NEUTRAL
},
915 { 0x256e, 0x2574, SIC_NEUTRAL
},
916 { 0x2581, 0x258f, SIC_NEUTRAL
},
917 { 0x2592, 0x2595, SIC_NEUTRAL
},
918 { 0x25a0, 0x25a1, SIC_NEUTRAL
},
919 { 0x25a3, 0x25a9, SIC_NEUTRAL
},
920 { 0x25b2, 0x25b3, SIC_NEUTRAL
},
921 { 0x25b6, 0x25b7, SIC_NEUTRAL
},
922 { 0x25bc, 0x25bd, SIC_NEUTRAL
},
923 { 0x25c0, 0x25c1, SIC_NEUTRAL
},
924 { 0x25c6, 0x25c8, SIC_NEUTRAL
},
925 { 0x25cb, 0x25cb, SIC_NEUTRAL
},
926 { 0x25ce, 0x25d1, SIC_NEUTRAL
},
927 { 0x25e2, 0x25e5, SIC_NEUTRAL
},
928 { 0x25ef, 0x25ef, SIC_NEUTRAL
},
929 { 0x2605, 0x2606, SIC_NEUTRAL
},
930 { 0x2609, 0x2609, SIC_NEUTRAL
},
931 { 0x260e, 0x260f, SIC_NEUTRAL
},
932 { 0x261c, 0x261c, SIC_NEUTRAL
},
933 { 0x261e, 0x261e, SIC_NEUTRAL
},
934 { 0x2640, 0x2640, SIC_NEUTRAL
},
935 { 0x2642, 0x2642, SIC_NEUTRAL
},
936 { 0x2660, 0x2661, SIC_NEUTRAL
},
937 { 0x2663, 0x2665, SIC_NEUTRAL
},
938 { 0x2667, 0x266a, SIC_NEUTRAL
},
939 { 0x266c, 0x266d, SIC_NEUTRAL
},
940 { 0x266f, 0x266f, SIC_NEUTRAL
},
941 { 0x273d, 0x273d, SIC_NEUTRAL
},
942 { 0x2e80, 0x312f, SIC_COMPLEX
},
943 { 0x3190, 0x31bf, SIC_COMPLEX
},
944 { 0x31f0, 0x31ff, SIC_COMPLEX
},
945 { 0x3220, 0x325f, SIC_COMPLEX
},
946 { 0x3280, 0xa4ff, SIC_COMPLEX
},
947 { 0xd800, 0xdfff, SIC_COMPLEX
},
948 { 0xe000, 0xf8ff, SIC_NEUTRAL
},
949 { 0xf900, 0xfaff, SIC_COMPLEX
},
950 { 0xfb13, 0xfb28, SIC_COMPLEX
},
951 { 0xfb29, 0xfb29, SIC_NEUTRAL
},
952 { 0xfb2a, 0xfb4f, SIC_COMPLEX
},
953 { 0xfd3e, 0xfd3f, SIC_NEUTRAL
},
954 { 0xfdd0, 0xfdef, SIC_COMPLEX
},
955 { 0xfe20, 0xfe6f, SIC_COMPLEX
},
956 { 0xfeff, 0xfeff, SIC_COMPLEX
},
957 { 0xff01, 0xff5e, SIC_COMPLEX
},
958 { 0xff61, 0xff9f, SIC_COMPLEX
},
959 { 0xffe0, 0xffe6, SIC_COMPLEX
},
960 { 0xffe8, 0xffee, SIC_COMPLEX
},
961 { 0xfff9, 0xfffb, SIC_COMPLEX
},
962 { 0xfffe, 0xfffe, SIC_COMPLEX
}
965 /***********************************************************************
966 * ScriptIsComplex (USP10.@)
968 * Determine if a string is complex.
971 * chars [I] Array of characters to test.
972 * len [I] Length in characters.
980 * Behaviour matches that of WinXP.
982 HRESULT WINAPI
ScriptIsComplex(const WCHAR
*chars
, int len
, DWORD flag
)
986 TRACE("(%s,%d,0x%x)\n", debugstr_wn(chars
, len
), len
, flag
);
988 for (i
= 0; i
< len
; i
++)
990 for (j
= 0; j
< sizeof(complex_ranges
)/sizeof(complex_ranges
[0]); j
++)
992 if (chars
[i
] >= complex_ranges
[j
].start
&&
993 chars
[i
] <= complex_ranges
[j
].end
&&
994 (flag
& complex_ranges
[j
].flag
)) return S_OK
;
1000 /***********************************************************************
1001 * ScriptShape (USP10.@)
1004 HRESULT WINAPI
ScriptShape(HDC hdc
, SCRIPT_CACHE
*psc
, const WCHAR
*pwcChars
,
1005 int cChars
, int cMaxGlyphs
,
1006 SCRIPT_ANALYSIS
*psa
, WORD
*pwOutGlyphs
, WORD
*pwLogClust
,
1007 SCRIPT_VISATTR
*psva
, int *pcGlyphs
)
1009 /* Note SCRIPT_CACHE (*psc) appears to be a good place to save info that needs to be
1010 * passed between functions. */
1015 Scriptcache
*pScriptcache
;
1017 FIXME("(%p, %p, %p, %d, %d, %p): semi-stub\n", hdc
, psc
, pwcChars
,
1018 cChars
, cMaxGlyphs
, psa
);
1019 if (psa
) TRACE("psa values: %d, %d, %d, %d, %d, %d, %d\n", psa
->eScript
, psa
->fRTL
, psa
->fLayoutRTL
,
1020 psa
->fLinkBefore
, psa
->fLinkAfter
,
1021 psa
->fLogicalOrder
, psa
->fNoGlyphIndex
);
1023 if (cChars
> cMaxGlyphs
) return E_OUTOFMEMORY
;
1025 if (!hdc
&& !*psc
) {
1026 TRACE("No Script_Cache (psc) and no hdc. Ask for one. Hdc=%p, psc=%p\n", hdc
, *psc
);
1030 pScriptcache
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(Scriptcache
) );
1031 pScriptcache
->hdc
= (HDC
) hdc
;
1033 *psc
= (Scriptcache
*) pScriptcache
;
1036 pScriptcache
= (Scriptcache
*) *psc
;
1037 phdc
= pScriptcache
->hdc
;
1041 for (cnt
= 0; cnt
< cChars
; cnt
++)
1042 TRACE("%4x",pwcChars
[cnt
]);
1045 if (!psa
->fNoGlyphIndex
) { /* Glyph translate */
1046 hr
= GetGlyphIndicesW(phdc
, pwcChars
, cChars
, pwOutGlyphs
, 0);
1048 for (cnt
= 0; cnt
< cChars
; cnt
++) {
1049 TRACE("%04x",pwOutGlyphs
[cnt
]);
1055 for (cnt
= 0; cnt
< cChars
; cnt
++) { /* no translate so set up */
1056 pwOutGlyphs
[cnt
] = pwcChars
[cnt
]; /* copy in to out and */
1057 TRACE("%04x",pwOutGlyphs
[cnt
]);
1062 /* Set up a valid SCRIPT_VISATTR and LogClust for each char in this run */
1063 for (cnt
= 0; cnt
< cChars
; cnt
++) {
1064 psva
[cnt
].uJustification
= 2;
1065 psva
[cnt
].fClusterStart
= 1;
1066 psva
[cnt
].fDiacritic
= 0;
1067 psva
[cnt
].fZeroWidth
= 0;
1068 pwLogClust
[cnt
] = cnt
;
1073 /***********************************************************************
1074 * ScriptPlace (USP10.@)
1077 HRESULT WINAPI
ScriptPlace(HDC hdc
, SCRIPT_CACHE
*psc
, const WORD
*pwGlyphs
,
1078 int cGlyphs
, const SCRIPT_VISATTR
*psva
,
1079 SCRIPT_ANALYSIS
*psa
, int *piAdvance
, GOFFSET
*pGoffset
, ABC
*pABC
)
1084 Scriptcache
*pScriptcache
;
1085 FIXME("(%p, %p, %p, %s, %d, %p, %p, %p): semi-stub\n", hdc
, psc
, pwGlyphs
,
1086 debugstr_wn(pwGlyphs
, cGlyphs
),
1090 /* We need a valid hdc to do any of the font calls. The spec says that hdc is optional and
1091 * psc will be used first. If psc and hdc are not specified E_PENDING is returned to get
1092 * the caller to return the hdc. For convenience, the hdc is cached in SCRIPT_CACHE. */
1094 if (!hdc
&& !*psc
) {
1095 TRACE("No Script_Cache (psc) and no hdc. Ask for one. Hdc=%p, psc=%p\n", hdc
, *psc
);
1099 pScriptcache
= HeapAlloc( GetProcessHeap(), 0, sizeof(Scriptcache
) );
1100 pScriptcache
->hdc
= hdc
;
1102 *psc
= pScriptcache
;
1105 pScriptcache
= *psc
;
1106 phdc
= pScriptcache
->hdc
;
1109 /* Here we need to calculate the width of the run unit. At this point the input string
1110 * has been converted to glyphs and we still need to translate back to the original chars
1111 * to get the correct ABC widths. */
1113 lpABC
= HeapAlloc(GetProcessHeap(), 0 , sizeof(ABC
)*cGlyphs
);
1117 if (!GetCharABCWidthsI(phdc
, 0, cGlyphs
, (WORD
*) pwGlyphs
, lpABC
))
1119 WARN("Could not get ABC values\n");
1120 for (wcnt
= 0; wcnt
< cGlyphs
; wcnt
++) {
1121 piAdvance
[wcnt
] = 0;
1122 pGoffset
[wcnt
].du
= 0;
1123 pGoffset
[wcnt
].dv
= 0;
1128 for (wcnt
= 0; wcnt
< cGlyphs
; wcnt
++) { /* add up the char lengths */
1129 TRACE(" Glyph=%04x, abcA=%d, abcB=%d, abcC=%d wcnt=%d\n",
1133 lpABC
[wcnt
].abcC
, wcnt
);
1134 pABC
->abcA
+= lpABC
[wcnt
].abcA
;
1135 pABC
->abcB
+= lpABC
[wcnt
].abcB
;
1136 pABC
->abcC
+= lpABC
[wcnt
].abcC
;
1137 piAdvance
[wcnt
] = lpABC
[wcnt
].abcA
+ lpABC
[wcnt
].abcB
+ lpABC
[wcnt
].abcC
;
1138 pGoffset
[wcnt
].du
= 0;
1139 pGoffset
[wcnt
].dv
= 0;
1142 TRACE("Total for run: abcA=%d, abcB=%d, abcC=%d\n", pABC
->abcA
, pABC
->abcB
, pABC
->abcC
);
1144 HeapFree(GetProcessHeap(), 0, lpABC
);
1149 /***********************************************************************
1150 * ScriptGetCMap (USP10.@)
1153 HRESULT WINAPI
ScriptGetCMap(HDC hdc
, SCRIPT_CACHE
*psc
, const WCHAR
*pwcInChars
,
1154 int cChars
, DWORD dwFlags
, WORD
*pwOutGlyphs
)
1159 Scriptcache
*pScriptcache
;
1160 FIXME("(%p,%p,%s,%d,0x%x,%p): semi-stub\n", hdc
, psc
, debugstr_wn(pwcInChars
,cChars
),
1161 cChars
, dwFlags
, pwOutGlyphs
);
1164 return E_INVALIDARG
;
1166 if (!hdc
&& !*psc
) {
1167 TRACE("No Script_Cache (psc) and no hdc. Ask for one. Hdc=%p, psc=%p\n", hdc
, *psc
);
1171 pScriptcache
= HeapAlloc( GetProcessHeap(), 0, sizeof(Scriptcache
) );
1172 pScriptcache
->hdc
= hdc
;
1174 *psc
= pScriptcache
;
1177 pScriptcache
= *psc
;
1178 phdc
= pScriptcache
->hdc
;
1182 for (cnt
= 0; cnt
< cChars
; cnt
++)
1183 TRACE("%4x",pwcInChars
[cnt
]);
1186 hr
= GetGlyphIndicesW(phdc
, pwcInChars
, cChars
, pwOutGlyphs
, 0);
1188 for (cnt
= 0; cnt
< cChars
; cnt
++) {
1189 TRACE("%04x",pwOutGlyphs
[cnt
]);
1196 /***********************************************************************
1197 * ScriptTextOut (USP10.@)
1200 HRESULT WINAPI
ScriptTextOut(const HDC hdc
, SCRIPT_CACHE
*psc
, int x
, int y
, UINT fuOptions
,
1201 const RECT
*lprc
, const SCRIPT_ANALYSIS
*psa
, const WCHAR
*pwcReserved
,
1202 int iReserved
, const WORD
*pwGlyphs
, int cGlyphs
, const int *piAdvance
,
1203 const int *piJustify
, const GOFFSET
*pGoffset
)
1207 Scriptcache
*pScriptcache
;
1208 TRACE ("(%p, %p, %d, %d, %04x, %p, %p, %p, %d, %p, %d, %p, %p, %p): stub\n",
1209 hdc
, psc
, x
, y
, fuOptions
, lprc
, psa
, pwcReserved
, iReserved
, pwGlyphs
, cGlyphs
,
1210 piAdvance
, piJustify
, pGoffset
);
1212 if (!hdc
|| !psc
|| !piAdvance
|| !psa
|| !pwGlyphs
) /* hdc is mandatory */
1213 return E_INVALIDARG
;
1216 pScriptcache
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(Scriptcache
) );
1217 pScriptcache
->hdc
= hdc
;
1219 *psc
= pScriptcache
;
1221 pScriptcache
= *psc
;
1222 phdc
= pScriptcache
->hdc
;
1225 fuOptions
&= ETO_CLIPPED
+ ETO_OPAQUE
;
1226 if (!psa
->fNoGlyphIndex
) /* Have Glyphs? */
1227 fuOptions
|= ETO_GLYPH_INDEX
; /* Say don't do translation to glyph */
1229 hr
= ExtTextOutW(phdc
, x
, y
, fuOptions
, lprc
, pwGlyphs
, cGlyphs
, NULL
);
1231 if (hr
) return S_OK
;
1233 FIXME("ExtTextOut returned:=%d\n", hr
);
1238 /***********************************************************************
1239 * ScriptCacheGetHeight (USP10.@)
1241 * Retrieve the height of the font in the cache.
1244 * hdc [I] Device context.
1245 * psc [I/O] Opaque pointer to a script cache.
1246 * height [O] Receives font height.
1250 * Failure: Non-zero HRESULT value.
1252 HRESULT WINAPI
ScriptCacheGetHeight(HDC hdc
, SCRIPT_CACHE
*psc
, LONG
*height
)
1255 Scriptcache
*pScriptcache
;
1258 TRACE("(%p, %p, %p)\n", hdc
, psc
, height
);
1260 if (!psc
|| !height
)
1261 return E_INVALIDARG
;
1263 if (!hdc
) return E_PENDING
;
1266 pScriptcache
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(Scriptcache
));
1267 pScriptcache
->hdc
= hdc
;
1269 *psc
= pScriptcache
;
1271 pScriptcache
= *psc
;
1272 phdc
= pScriptcache
->hdc
;
1275 /* FIXME: get this from the cache */
1276 if (!GetTextMetricsW(phdc
, &metric
))
1277 return E_INVALIDARG
;
1279 *height
= metric
.tmHeight
;
1283 /***********************************************************************
1284 * ScriptGetGlyphABCWidth (USP10.@)
1286 * Retrieve the width of a glyph.
1289 * hdc [I] Device context.
1290 * psc [I/O] Opaque pointer to a script cache.
1291 * glyph [I] Glyph to retrieve the width for.
1292 * abc [O] ABC widths of the glyph.
1296 * Failure: Non-zero HRESULT value.
1298 HRESULT WINAPI
ScriptGetGlyphABCWidth(HDC hdc
, SCRIPT_CACHE
*psc
, WORD glyph
, ABC
*abc
)
1301 Scriptcache
*pScriptcache
;
1303 TRACE("(%p, %p, 0x%04x, %p)\n", hdc
, psc
, glyph
, abc
);
1306 return E_INVALIDARG
;
1308 if (!hdc
) return E_PENDING
;
1311 pScriptcache
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(Scriptcache
));
1312 pScriptcache
->hdc
= hdc
;
1314 *psc
= pScriptcache
;
1316 pScriptcache
= *psc
;
1317 phdc
= pScriptcache
->hdc
;
1320 /* FIXME: get this from the cache */
1321 if (!GetCharABCWidthsW(phdc
, glyph
, glyph
, abc
))
1327 /***********************************************************************
1328 * ScriptLayout (USP10.@)
1330 * Map embedding levels to visual and/or logical order.
1333 * runs [I] Size of level array.
1334 * level [I] Array of embedding levels.
1335 * vistolog [O] Map of embedding levels from visual to logical order.
1336 * logtovis [O] Map of embedding levels from logical to visual order.
1340 * Failure: Non-zero HRESULT value.
1343 * This stub works correctly for any sequence of a single
1344 * embedding level but not for sequences of different
1345 * embedding levels, i.e. mixtures of RTL and LTR scripts.
1347 HRESULT WINAPI
ScriptLayout(int runs
, const BYTE
*level
, int *vistolog
, int *logtovis
)
1349 int i
, j
= runs
- 1, k
= 0;
1351 FIXME("(%d, %p, %p, %p): stub\n", runs
, level
, vistolog
, logtovis
);
1353 if (!level
|| (!vistolog
&& !logtovis
))
1354 return E_INVALIDARG
;
1356 for (i
= 0; i
< runs
; i
++)
1360 if (vistolog
) *vistolog
++ = j
;
1361 if (logtovis
) *logtovis
++ = j
;
1366 if (vistolog
) *vistolog
++ = k
;
1367 if (logtovis
) *logtovis
++ = k
;
1374 /***********************************************************************
1375 * ScriptStringValidate (USP10.@)
1377 * Validate a string analysis.
1380 * ssa [I] string analysis.
1384 * Failure: S_FALSE if invalid sequences are found
1385 * or a non-zero HRESULT if it fails.
1387 HRESULT WINAPI
ScriptStringValidate(SCRIPT_STRING_ANALYSIS ssa
)
1389 FIXME("(%p): stub\n", ssa
);
1393 /***********************************************************************
1394 * ScriptString_pSize (USP10.@)
1396 * Retrieve width and height of an analysed string.
1399 * ssa [I] string analysis.
1402 * Success: Pointer to a SIZE structure.
1405 const SIZE
* WINAPI
ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa
)
1408 StringAnalysis
*analysis
= ssa
;
1411 TRACE("(%p)\n", ssa
);
1413 if (!analysis
) return NULL
;
1417 if (!(analysis
->sz
= HeapAlloc(GetProcessHeap(), 0, sizeof(SIZE
))))
1420 /* FIXME: These values should be calculated at a more
1421 * appropriate place so that we can just pass cached
1424 if (!GetTextMetricsW(analysis
->hdc
, &metric
))
1426 HeapFree(GetProcessHeap(), 0, analysis
->sz
);
1427 analysis
->sz
= NULL
;
1430 analysis
->sz
->cy
= metric
.tmHeight
;
1432 analysis
->sz
->cx
= 0;
1433 for (i
= 0; i
< analysis
->numItems
; i
++)
1434 for (j
= 0; j
< analysis
->glyphs
[i
].numGlyphs
; j
++)
1435 analysis
->sz
->cx
+= analysis
->glyphs
[i
].piAdvance
[j
];
1437 return analysis
->sz
;