ReceiveTempSMS/Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move DCFuncs ExtTextOut and GetTextExtentPoint to Unicode.

Browse Source 
Map a few Unicode chars to the first 0xff in psdrv.
Don't expect x11drv to display Unicode chars yet.
This commit is contained in:
Huw D M Davies 1999-12-26 00:47:03 +00:00 committed by Alexandre Julliard
parent e73b8b84ba
commit c553924ddd
21 changed files with 289 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
graphics/metafiledrv/text.c
View File

@ -34,7 +34,7 @@ static BOOL MFDRV_MetaExtTextOut(DC*dc, short x, short y, UINT16 flags,
len += sizeof(RECT16); len += sizeof(RECT16);
if (lpDx) if (lpDx)
len+=count*sizeof(INT16); len+=count*sizeof(INT16);
if (!(mr = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, len))) if (!(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len)))
return FALSE; return FALSE;
mr->rdSize = len / 2; mr->rdSize = len / 2;
@ -49,7 +49,7 @@ static BOOL MFDRV_MetaExtTextOut(DC*dc, short x, short y, UINT16 flags,
memcpy(mr->rdParm + (rect ? 8 : 4) + ((count + 1) >> 1),lpDx, memcpy(mr->rdParm + (rect ? 8 : 4) + ((count + 1) >> 1),lpDx,
count*sizeof(INT16)); count*sizeof(INT16));
ret = MFDRV_WriteRecord( dc, mr, mr->rdSize * 2); ret = MFDRV_WriteRecord( dc, mr, mr->rdSize * 2);
HeapFree( SystemHeap, 0, mr); HeapFree( GetProcessHeap(), 0, mr);
return ret; return ret;
} }
@ -60,23 +60,27 @@ static BOOL MFDRV_MetaExtTextOut(DC*dc, short x, short y, UINT16 flags,
*/ */
BOOL BOOL
MFDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags, MFDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCWSTR str, UINT count,
const INT *lpDx ) const INT *lpDx )
{ {
RECT16 rect16; RECT16 rect16;
LPINT16 lpdx16 = NULL; LPINT16 lpdx16 = NULL;
BOOL ret; BOOL ret;
int i; int i;
LPSTR ascii;
if(lpDx) if(lpDx)
lpdx16 = HeapAlloc( SystemHeap, 0, sizeof(INT16)*count ); lpdx16 = HeapAlloc( GetProcessHeap(), 0, sizeof(INT16)*count );
if (lprect) CONV_RECT32TO16(lprect,&rect16); if (lprect) CONV_RECT32TO16(lprect,&rect16);
if (lpdx16) if (lpdx16)
for (i=count;i--;) for (i=count;i--;)
lpdx16[i]=lpDx[i]; lpdx16[i]=lpDx[i];
ret = MFDRV_MetaExtTextOut(dc,x,y,flags,lprect?&rect16:NULL,str,count, ascii = HeapAlloc( GetProcessHeap(), 0, count+1 );
lstrcpynWtoA(ascii, str, count+1);
ret = MFDRV_MetaExtTextOut(dc,x,y,flags,lprect?&rect16:NULL,ascii,count,
lpdx16); lpdx16);
if (lpdx16) HeapFree( SystemHeap, 0, lpdx16 ); HeapFree( GetProcessHeap(), 0, ascii );
if (lpdx16) HeapFree( GetProcessHeap(), 0, lpdx16 );
return ret; return ret;
} }

33
graphics/psdrv/font.c
View File

@ -168,11 +168,37 @@ BOOL PSDRV_GetTextMetrics(DC *dc, TEXTMETRICA *metrics)
return TRUE; return TRUE;
} }
/***********************************************************************
* PSDRV_UnicodeToANSI
*/
char PSDRV_UnicodeToANSI(int u)
{
if((u & 0xff) == u)
return u;
switch(u) {
case 0x2013: /* endash */
return 0x96;
case 0x2014: /* emdash */
return 0x97;
case 0x2018: /* quoteleft */
return 0x91;
case 0x2019: /* quoteright */
return 0x92;
case 0x201c: /* quotedblleft */
return 0x93;
case 0x201d: /* quotedblright */
return 0x94;
case 0x2022: /* bullet */
return 0x95;
default:
WARN("Umapped unicode char U%04x\n", u);
return 0xff;
}
}
/*********************************************************************** /***********************************************************************
* PSDRV_GetTextExtentPoint * PSDRV_GetTextExtentPoint
*/ */
BOOL PSDRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count, BOOL PSDRV_GetTextExtentPoint( DC *dc, LPCWSTR str, INT count,
LPSIZE size ) LPSIZE size )
{ {
PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev; PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
@ -183,7 +209,8 @@ BOOL PSDRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count,
width = 0.0; width = 0.0;
for(i = 0; i < count && str[i]; i++) { for(i = 0; i < count && str[i]; i++) {
width += physDev->font.afm->CharWidths[ *((unsigned char *)str + i) ]; char c = PSDRV_UnicodeToANSI(str[i]);
width += physDev->font.afm->CharWidths[(int)(unsigned char)c];
/* TRACE(psdrv, "Width after %dth char '%c' = %f\n", i, str[i], width);*/ /* TRACE(psdrv, "Width after %dth char '%c' = %f\n", i, str[i], width);*/
} }
width *= physDev->font.scale; width *= physDev->font.scale;

13
graphics/psdrv/ps.c
View File

@ -631,7 +631,7 @@ BOOL PSDRV_WriteReencodeFont(DC *dc)
return TRUE; return TRUE;
} }
BOOL PSDRV_WriteShow(DC *dc, char *str, INT count) BOOL PSDRV_WriteShow(DC *dc, LPCWSTR str, INT count)
{ {
char *buf, *buf1; char *buf, *buf1;
INT buflen = count + 10, i, done; INT buflen = count + 10, i, done;
@ -639,20 +639,21 @@ BOOL PSDRV_WriteShow(DC *dc, char *str, INT count)
buf = (char *)HeapAlloc( PSDRV_Heap, 0, buflen ); buf = (char *)HeapAlloc( PSDRV_Heap, 0, buflen );
for(i = done = 0; i < count; i++) { for(i = done = 0; i < count; i++) {
if(!isprint(str[i])) { char c = PSDRV_UnicodeToANSI(str[i]);
if(!isprint(c)) {
if(done + 4 >= buflen) if(done + 4 >= buflen)
buf = HeapReAlloc( PSDRV_Heap, 0, buf, buflen += 10 ); buf = HeapReAlloc( PSDRV_Heap, 0, buf, buflen += 10 );
sprintf(buf + done, "\\%03o", (int)(unsigned char)str[i] ); sprintf(buf + done, "\\%03o", (int)(unsigned char)c);
done += 4; done += 4;
} else if(str[i] == '\\' || str[i] == '(' || str[i] == ')' ) { } else if(c == '\\' || c == '(' || c == ')' ) {
if(done + 2 >= buflen) if(done + 2 >= buflen)
buf = HeapReAlloc( PSDRV_Heap, 0, buf, buflen += 10 ); buf = HeapReAlloc( PSDRV_Heap, 0, buf, buflen += 10 );
buf[done++] = '\\'; buf[done++] = '\\';
buf[done++] = str[i]; buf[done++] = c;
} else { } else {
if(done + 1 >= buflen) if(done + 1 >= buflen)
buf = HeapReAlloc( PSDRV_Heap, 0, buf, buflen += 10 ); buf = HeapReAlloc( PSDRV_Heap, 0, buf, buflen += 10 );
buf[done++] = str[i]; buf[done++] = c;
} }
} }
buf[done] = '\0'; buf[done] = '\0';

22
graphics/psdrv/text.c
View File

@ -11,14 +11,14 @@
DEFAULT_DEBUG_CHANNEL(psdrv) DEFAULT_DEBUG_CHANNEL(psdrv)
static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCSTR str, UINT count, static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCWSTR str, UINT count,
BOOL bDrawBackground); BOOL bDrawBackground);
/*********************************************************************** /***********************************************************************
* PSDRV_ExtTextOut * PSDRV_ExtTextOut
*/ */
BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags, BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCWSTR str, UINT count,
const INT *lpDx ) const INT *lpDx )
{ {
PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev; PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
@ -27,8 +27,8 @@ BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
BOOL bOpaque = FALSE; BOOL bOpaque = FALSE;
RECT rect; RECT rect;
TRACE("(x=%d, y=%d, flags=0x%08x, str='%.*s', count=%d)\n", x, y, TRACE("(x=%d, y=%d, flags=0x%08x, str=%s, count=%d)\n", x, y,
flags, (int)count, str, count); flags, debugstr_wn(str, count), count);
/* write font if not already written */ /* write font if not already written */
PSDRV_SetFont(dc); PSDRV_SetFont(dc);
@ -74,14 +74,14 @@ BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
/*********************************************************************** /***********************************************************************
* PSDRV_Text * PSDRV_Text
*/ */
static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCSTR str, UINT count, static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCWSTR str, UINT count,
BOOL bDrawBackground) BOOL bDrawBackground)
{ {
PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev; PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
char *strbuf; LPWSTR strbuf;
SIZE sz; SIZE sz;
strbuf = (char *)HeapAlloc( PSDRV_Heap, 0, count + 1); strbuf = HeapAlloc( PSDRV_Heap, 0, (count + 1) * sizeof(WCHAR));
if(!strbuf) { if(!strbuf) {
WARN("HeapAlloc failed\n"); WARN("HeapAlloc failed\n");
return FALSE; return FALSE;
@ -95,7 +95,7 @@ static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCSTR str, UINT count,
x = XLPTODP(dc, x); x = XLPTODP(dc, x);
y = YLPTODP(dc, y); y = YLPTODP(dc, y);
GetTextExtentPoint32A(dc->hSelf, str, count, &sz); GetTextExtentPoint32W(dc->hSelf, str, count, &sz);
sz.cx = XLSTODS(dc, sz.cx); sz.cx = XLSTODS(dc, sz.cx);
sz.cy = YLSTODS(dc, sz.cy); sz.cy = YLSTODS(dc, sz.cy);
@ -129,7 +129,7 @@ static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCSTR str, UINT count,
break; break;
} }
memcpy(strbuf, str, count); memcpy(strbuf, str, count * sizeof(WCHAR));
*(strbuf + count) = '\0'; *(strbuf + count) = '\0';
if ((dc->w.backgroundMode != TRANSPARENT) && (bDrawBackground != FALSE)) if ((dc->w.backgroundMode != TRANSPARENT) && (bDrawBackground != FALSE))
@ -145,7 +145,7 @@ static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCSTR str, UINT count,
} }
PSDRV_WriteMoveTo(dc, x, y); PSDRV_WriteMoveTo(dc, x, y);
PSDRV_WriteShow(dc, strbuf, strlen(strbuf)); PSDRV_WriteShow(dc, strbuf, lstrlenW(strbuf));
/* /*
* Underline and strikeout attributes. * Underline and strikeout attributes.
@ -165,7 +165,7 @@ static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCSTR str, UINT count,
/* Get the width of the text */ /* Get the width of the text */
PSDRV_GetTextExtentPoint(dc, strbuf, strlen(strbuf), &size); PSDRV_GetTextExtentPoint(dc, strbuf, lstrlenW(strbuf), &size);
size.cx = XLSTODS(dc, size.cx); size.cx = XLSTODS(dc, size.cx);
/* Do the underline */ /* Do the underline */

4
graphics/ttydrv/font.c
View File

@ -32,12 +32,12 @@ BOOL TTYDRV_DC_GetCharWidth(DC *dc, UINT firstChar, UINT lastChar,
/*********************************************************************** /***********************************************************************
* TTYDRV_DC_GetTextExtentPoint * TTYDRV_DC_GetTextExtentPoint
*/ */
BOOL TTYDRV_DC_GetTextExtentPoint(DC *dc, LPCSTR str, INT count, BOOL TTYDRV_DC_GetTextExtentPoint(DC *dc, LPCWSTR str, INT count,
LPSIZE size) LPSIZE size)
{ {
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev; TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
TRACE("(%p, %s, %d, %p)\n", dc, debugstr_an(str, count), count, size); TRACE("(%p, %s, %d, %p)\n", dc, debugstr_wn(str, count), count, size);
size->cx = count * physDev->cellWidth; size->cx = count * physDev->cellWidth;
size->cy = physDev->cellHeight; size->cy = physDev->cellHeight;

15
graphics/ttydrv/text.c
View File

@ -18,15 +18,16 @@ DEFAULT_DEBUG_CHANNEL(ttydrv)
* TTYDRV_DC_ExtTextOut * TTYDRV_DC_ExtTextOut
*/ */
BOOL TTYDRV_DC_ExtTextOut(DC *dc, INT x, INT y, UINT flags, BOOL TTYDRV_DC_ExtTextOut(DC *dc, INT x, INT y, UINT flags,
const RECT *lpRect, LPCSTR str, UINT count, const RECT *lpRect, LPCWSTR str, UINT count,
const INT *lpDx) const INT *lpDx)
{ {
#ifdef HAVE_LIBCURSES #ifdef HAVE_LIBCURSES
TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev; TTYDRV_PDEVICE *physDev = (TTYDRV_PDEVICE *) dc->physDev;
INT row, col; INT row, col;
LPSTR ascii;
TRACE("(%p, %d, %d, 0x%08x, %p, %s, %d, %p)\n", TRACE("(%p, %d, %d, 0x%08x, %p, %s, %d, %p)\n",
dc, x, y, flags, lpRect, debugstr_a(str), count, lpDx); dc, x, y, flags, lpRect, debugstr_wn(str, count), count, lpDx);
if(!physDev->window) if(!physDev->window)
return FALSE; return FALSE;
@ -42,19 +43,21 @@ BOOL TTYDRV_DC_ExtTextOut(DC *dc, INT x, INT y, UINT flags,
row = (dc->w.DCOrgY + y) / physDev->cellHeight; row = (dc->w.DCOrgY + y) / physDev->cellHeight;
col = (dc->w.DCOrgX + x) / physDev->cellWidth; col = (dc->w.DCOrgX + x) / physDev->cellWidth;
ascii = HeapAlloc( GetProcessHeap(), 0, count+1 );
mvwaddnstr(physDev->window, row, col, str, count); lstrcpynWtoA(ascii, str, count+1);
mvwaddnstr(physDev->window, row, col, ascii, count);
HeapFree( GetProcessHeap(), 0, ascii );
wrefresh(physDev->window); wrefresh(physDev->window);
if(dc->w.textAlign & TA_UPDATECP) { if(dc->w.textAlign & TA_UPDATECP) {
dc->w.CursPosX += count * physDev->cellWidth; dc->w.CursPosX += count * physDev->cellWidth;
dc->w.CursPosY += count * physDev->cellHeight; dc->w.CursPosY += physDev->cellHeight;
} }
return TRUE; return TRUE;
#else /* defined(HAVE_LIBCURSES) */ #else /* defined(HAVE_LIBCURSES) */
FIXME("(%p, %d, %d, 0x%08x, %p, %s, %d, %p): stub\n", FIXME("(%p, %d, %d, 0x%08x, %p, %s, %d, %p): stub\n",
dc, x, y, flags, lpRect, debugstr_a(str), count, lpDx); dc, x, y, flags, lpRect, debugstr_wn(str,count), count, lpDx);
return TRUE; return TRUE;
#endif /* defined(HAVE_LIBCURSES) */ #endif /* defined(HAVE_LIBCURSES) */

10
graphics/win16drv/font.c
View File

@ -19,15 +19,18 @@ DEFAULT_DEBUG_CHANNEL(win16drv)
/*********************************************************************** /***********************************************************************
* WIN16DRV_GetTextExtentPoint * WIN16DRV_GetTextExtentPoint
*/ */
BOOL WIN16DRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count, BOOL WIN16DRV_GetTextExtentPoint( DC *dc, LPCWSTR wstr, INT count,
LPSIZE size ) LPSIZE size )
{ {
WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev; WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
DWORD dwRet; DWORD dwRet;
char *str;
TRACE("%04x %s %d %p\n", TRACE("%04x %s %d %p\n",
dc->hSelf, str, count, size); dc->hSelf, debugstr_wn(wstr, count), count, size);
str = HeapAlloc( GetProcessHeap(), 0, count+1 );
lstrcpynWtoA( str, wstr, count+1 );
dwRet = PRTDRV_ExtTextOut(physDev->segptrPDEVICE, 0, 0, dwRet = PRTDRV_ExtTextOut(physDev->segptrPDEVICE, 0, 0,
NULL, str, NULL, str,
-count, physDev->FontInfo, -count, physDev->FontInfo,
@ -37,6 +40,7 @@ BOOL WIN16DRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count,
size->cy = YDSTOLS(dc,HIWORD(dwRet)); size->cy = YDSTOLS(dc,HIWORD(dwRet));
TRACE("cx=0x%x, cy=0x%x\n", TRACE("cx=0x%x, cy=0x%x\n",
size->cx, size->cy ); size->cx, size->cy );
HeapFree( GetProcessHeap(), 0, str );
return TRUE; return TRUE;
} }
@ -184,7 +188,7 @@ BOOL WIN16DRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
/* EnumDFontCallback is GDI.158 */ /* EnumDFontCallback is GDI.158 */
FARPROC16 pfnCallback = NE_GetEntryPoint( GetModuleHandle16("GDI"), 158 ); FARPROC16 pfnCallback = NE_GetEntryPoint( GetModuleHandle16("GDI"), 158 );
wepfc.proc = proc; wepfc.proc = (int (*)(LPENUMLOGFONT16,LPNEWTEXTMETRIC16,UINT16,LPARAM))proc;
wepfc.lp = lp; wepfc.lp = lp;
wRet = PRTDRV_EnumDFonts(physDev->segptrPDEVICE, plf->lfFaceName[0] ? wRet = PRTDRV_EnumDFonts(physDev->segptrPDEVICE, plf->lfFaceName[0] ?

37
graphics/win16drv/text.c
View File

@ -10,6 +10,7 @@
#include "dc.h" #include "dc.h"
#include "gdi.h" #include "gdi.h"
#include "debugtools.h" #include "debugtools.h"
#include "winbase.h"
DEFAULT_DEBUG_CHANNEL(win16drv) DEFAULT_DEBUG_CHANNEL(win16drv)
@ -17,7 +18,7 @@ DEFAULT_DEBUG_CHANNEL(win16drv)
* WIN16DRV_ExtTextOut * WIN16DRV_ExtTextOut
*/ */
BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags, BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCWSTR wstr, UINT count,
const INT *lpDx ) const INT *lpDx )
{ {
WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev; WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
@ -28,37 +29,34 @@ BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
WORD wOptions = 0; WORD wOptions = 0;
WORD wCount = count; WORD wCount = count;
INT16 width; INT16 width;
char *str;
DWORD dwRet;
if (count == 0) if (count == 0)
return FALSE; return FALSE;
TRACE("%04x %d %d %x %p %*s %p\n", TRACE("%04x %d %d %x %p %s %p\n",
dc->hSelf, x, y, flags, lprect, count > 0 ? count : 8, str, lpDx); dc->hSelf, x, y, flags, lprect, debugstr_wn(wstr, count), lpDx);
str = HeapAlloc( GetProcessHeap(), 0, count+1 );
if (dc != NULL) lstrcpynWtoA( str, wstr, count+1 );
{
DWORD dwRet;
clipRect.left = 0; clipRect.left = 0;
clipRect.top = 0; clipRect.top = 0;
clipRect.right = dc->w.devCaps->horzRes; clipRect.right = dc->w.devCaps->horzRes;
clipRect.bottom = dc->w.devCaps->vertRes; clipRect.bottom = dc->w.devCaps->vertRes;
if (lprect) if (lprect) {
{
opaqueRect.left = lprect->left; opaqueRect.left = lprect->left;
opaqueRect.top = lprect->top; opaqueRect.top = lprect->top;
opaqueRect.right = lprect->right; opaqueRect.right = lprect->right;
opaqueRect.bottom = lprect->bottom; opaqueRect.bottom = lprect->bottom;
lpOpaqueRect = &opaqueRect; lpOpaqueRect = &opaqueRect;
} }
TRACE("textalign = %d\n", dc->w.textAlign); TRACE("textalign = %d\n", dc->w.textAlign);
if (dc->w.textAlign & TA_UPDATECP) if (dc->w.textAlign & TA_UPDATECP) {
{
x = dc->w.CursPosX; x = dc->w.CursPosX;
y = dc->w.CursPosY; y = dc->w.CursPosY;
} }
@ -68,13 +66,13 @@ BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
dwRet = PRTDRV_ExtTextOut(physDev->segptrPDEVICE, 0, 0, dwRet = PRTDRV_ExtTextOut(physDev->segptrPDEVICE, 0, 0,
NULL, str, -count, physDev->FontInfo, NULL, str, -count, physDev->FontInfo,
win16drv_SegPtr_DrawMode, win16drv_SegPtr_TextXForm, win16drv_SegPtr_DrawMode,
win16drv_SegPtr_TextXForm,
NULL, NULL, 0); NULL, NULL, 0);
width = LOWORD(dwRet); width = LOWORD(dwRet);
switch( dc->w.textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER) ) switch( dc->w.textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER) ) {
{
case TA_LEFT: case TA_LEFT:
if (dc->w.textAlign & TA_UPDATECP) if (dc->w.textAlign & TA_UPDATECP)
dc->w.CursPosX = XDPTOLP( dc, x + width ); dc->w.CursPosX = XDPTOLP( dc, x + width );
@ -89,8 +87,7 @@ BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
break; break;
} }
switch( dc->w.textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE) ) switch( dc->w.textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE) ) {
{
case TA_TOP: case TA_TOP:
break; break;
case TA_BOTTOM: case TA_BOTTOM:
@ -104,8 +101,10 @@ BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
dwRet = PRTDRV_ExtTextOut(physDev->segptrPDEVICE, dwRet = PRTDRV_ExtTextOut(physDev->segptrPDEVICE,
x, y, &clipRect, str, wCount, x, y, &clipRect, str, wCount,
physDev->FontInfo, win16drv_SegPtr_DrawMode, physDev->FontInfo, win16drv_SegPtr_DrawMode,
win16drv_SegPtr_TextXForm, NULL, lpOpaqueRect, wOptions); win16drv_SegPtr_TextXForm, NULL, lpOpaqueRect,
} wOptions);
HeapFree( GetProcessHeap(), 0, str );
return bRet; return bRet;
} }

44
graphics/x11drv/text.c
View File

@ -30,7 +30,7 @@ DEFAULT_DEBUG_CHANNEL(text)
*/ */
BOOL BOOL
X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags, X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCWSTR wstr, UINT count,
const INT *lpDx ) const INT *lpDx )
{ {
int i; int i;
@ -41,6 +41,7 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
char dfBreakChar, lfUnderline, lfStrikeOut; char dfBreakChar, lfUnderline, lfStrikeOut;
BOOL rotated = FALSE; BOOL rotated = FALSE;
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev; X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
XChar2b *str2b;
if (!X11DRV_SetupGCForText( dc )) return TRUE; if (!X11DRV_SetupGCForText( dc )) return TRUE;
@ -55,12 +56,12 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
TRACE("hdc=%04x df=%04x %d,%d %s, %d flags=%d lpDx=%p\n", TRACE("hdc=%04x df=%04x %d,%d %s, %d flags=%d lpDx=%p\n",
dc->hSelf, (UINT16)(physDev->font), x, y, dc->hSelf, (UINT16)(physDev->font), x, y,
debugstr_an (str, count), count, flags, lpDx); debugstr_wn (wstr, count), count, flags, lpDx);
/* some strings sent here end in a newline for whatever reason. I have no /* some strings sent here end in a newline for whatever reason. I have no
clue what the right treatment should be in general, but ignoring clue what the right treatment should be in general, but ignoring
terminating newlines seems ok. MW, April 1998. */ terminating newlines seems ok. MW, April 1998. */
if (count > 0 && str[count - 1] == '\n') count--; if (count > 0 && wstr[count - 1] == '\n') count--;
if (lprect != NULL) TRACE("\trect=(%d,%d - %d,%d)\n", if (lprect != NULL) TRACE("\trect=(%d,%d - %d,%d)\n",
lprect->left, lprect->top, lprect->left, lprect->top,
@ -80,7 +81,7 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
SIZE sz; SIZE sz;
if (flags & ETO_CLIPPED) /* Can't clip with no rectangle */ if (flags & ETO_CLIPPED) /* Can't clip with no rectangle */
return FALSE; return FALSE;
if (!X11DRV_GetTextExtentPoint( dc, str, count, &sz )) if (!X11DRV_GetTextExtentPoint( dc, wstr, count, &sz ))
return FALSE; return FALSE;
rect.left = XLPTODP( dc, x ); rect.left = XLPTODP( dc, x );
rect.right = XLPTODP( dc, x+sz.cx ); rect.right = XLPTODP( dc, x+sz.cx );
@ -126,7 +127,7 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
else else
{ {
SIZE sz; SIZE sz;
if (!X11DRV_GetTextExtentPoint( dc, str, count, &sz )) if (!X11DRV_GetTextExtentPoint( dc, wstr, count, &sz ))
return FALSE; return FALSE;
width = XLSTODS(dc, sz.cx); width = XLSTODS(dc, sz.cx);
} }
@ -213,24 +214,29 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
} }
/* Draw the text (count > 0 verified) */ /* Draw the text (count > 0 verified) */
str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) );
for(i = 0; i < count; i++) {
str2b[i].byte1 = wstr[i] >> 8;
str2b[i].byte2 = wstr[i] & 0xff;
}
TSXSetForeground( display, physDev->gc, physDev->textPixel ); TSXSetForeground( display, physDev->gc, physDev->textPixel );
if(!rotated) if(!rotated)
{ {
if (!dc->w.charExtra && !dc->w.breakExtra && !lpDx) if (!dc->w.charExtra && !dc->w.breakExtra && !lpDx)
{ {
TSXDrawString( display, physDev->drawable, physDev->gc, TSXDrawString16( display, physDev->drawable, physDev->gc,
dc->w.DCOrgX + x, dc->w.DCOrgY + y, str, count ); dc->w.DCOrgX + x, dc->w.DCOrgY + y, str2b, count );
} }
else /* Now the fun begins... */ else /* Now the fun begins... */
{ {
XTextItem *items, *pitem; XTextItem16 *items, *pitem;
int delta; int delta;
/* allocate max items */ /* allocate max items */
pitem = items = HEAP_xalloc( GetProcessHeap(), 0, pitem = items = HEAP_xalloc( GetProcessHeap(), 0,
count * sizeof(XTextItem) ); count * sizeof(XTextItem16) );
delta = i = 0; delta = i = 0;
if( lpDx ) /* explicit character widths */ if( lpDx ) /* explicit character widths */
{ {
@ -240,7 +246,7 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
{ {
/* initialize text item with accumulated delta */ /* initialize text item with accumulated delta */
pitem->chars = (char *)str + i; pitem->chars = str2b + i;
pitem->delta = delta; pitem->delta = delta;
pitem->nchars = 0; pitem->nchars = 0;
pitem->font = None; pitem->font = None;
@ -252,7 +258,7 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
do do
{ {
delta += (lpDx[i] * dc->vportExtX + extra) / dc->wndExtX delta += (lpDx[i] * dc->vportExtX + extra) / dc->wndExtX
- TSXTextWidth( font, str + i, 1); - TSXTextWidth16( font, str2b + i, 1);
pitem->nchars++; pitem->nchars++;
} while ((++i < count) && !delta); } while ((++i < count) && !delta);
pitem++; pitem++;
@ -262,7 +268,7 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
{ {
while (i < count) while (i < count)
{ {
pitem->chars = (char *)str + i; pitem->chars = str2b + i;
pitem->delta = delta; pitem->delta = delta;
pitem->nchars = 0; pitem->nchars = 0;
pitem->font = None; pitem->font = None;
@ -271,14 +277,15 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
do do
{ {
delta += dc->w.charExtra; delta += dc->w.charExtra;
if (str[i] == (char)dfBreakChar) delta += dc->w.breakExtra; if (str2b[i].byte2 == (char)dfBreakChar)
delta += dc->w.breakExtra;
pitem->nchars++; pitem->nchars++;
} while ((++i < count) && !delta); } while ((++i < count) && !delta);
pitem++; pitem++;
} }
} }
TSXDrawText( display, physDev->drawable, physDev->gc, TSXDrawText16( display, physDev->drawable, physDev->gc,
dc->w.DCOrgX + x, dc->w.DCOrgY + y, items, pitem - items ); dc->w.DCOrgX + x, dc->w.DCOrgY + y, items, pitem - items );
HeapFree( GetProcessHeap(), 0, items ); HeapFree( GetProcessHeap(), 0, items );
} }
@ -291,15 +298,15 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
for (i=0; i<count; i++) for (i=0; i<count; i++)
{ {
int char_metric_offset = (unsigned char) str[i] int char_metric_offset = str2b[i].byte2 + (str2b[i].byte1 << 8)
- font->min_char_or_byte2; - font->min_char_or_byte2;
int x_i = IROUND((double) (dc->w.DCOrgX + x) + offset * int x_i = IROUND((double) (dc->w.DCOrgX + x) + offset *
pfo->lpX11Trans->a / pfo->lpX11Trans->pixelsize ); pfo->lpX11Trans->a / pfo->lpX11Trans->pixelsize );
int y_i = IROUND((double) (dc->w.DCOrgY + y) - offset * int y_i = IROUND((double) (dc->w.DCOrgY + y) - offset *
pfo->lpX11Trans->b / pfo->lpX11Trans->pixelsize ); pfo->lpX11Trans->b / pfo->lpX11Trans->pixelsize );
TSXDrawString( display, physDev->drawable, physDev->gc, TSXDrawString16( display, physDev->drawable, physDev->gc,
x_i, y_i, &str[i], 1); x_i, y_i, &str2b[i], 1);
if (lpDx) if (lpDx)
offset += XLSTODS(dc, lpDx[i]); offset += XLSTODS(dc, lpDx[i]);
else else
@ -309,11 +316,12 @@ X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
font->min_bounds.attributes) font->min_bounds.attributes)
* pfo->lpX11Trans->pixelsize / 1000.0; * pfo->lpX11Trans->pixelsize / 1000.0;
offset += dc->w.charExtra; offset += dc->w.charExtra;
if (str[i] == (char)dfBreakChar) if (str2b[i].byte2 == (char)dfBreakChar)
offset += dc->w.breakExtra; offset += dc->w.breakExtra;
} }
} }
} }
HeapFree( GetProcessHeap(), 0, str2b );
/* Draw underline and strike-out if needed */ /* Draw underline and strike-out if needed */

17
graphics/x11drv/xfont.c
View File

@ -3038,23 +3038,30 @@ BOOL X11DRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
/*********************************************************************** /***********************************************************************
* X11DRV_GetTextExtentPoint * X11DRV_GetTextExtentPoint
*/ */
BOOL X11DRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count, BOOL X11DRV_GetTextExtentPoint( DC *dc, LPCWSTR str, INT count,
LPSIZE size ) LPSIZE size )
{ {
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev; X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
fontObject* pfo = XFONT_GetFontObject( physDev->font ); fontObject* pfo = XFONT_GetFontObject( physDev->font );
TRACE("%s %d\n", debugstr_wn(str,count), count);
if( pfo ) { if( pfo ) {
if( !pfo->lpX11Trans ) { if( !pfo->lpX11Trans ) {
int dir, ascent, descent; int dir, ascent, descent, i;
XCharStruct info; XCharStruct info;
XChar2b *p = HeapAlloc( GetProcessHeap(), 0,
TSXTextExtents( pfo->fs, str, count, &dir, &ascent, &descent, &info ); count * sizeof(XChar2b) );
for(i = 0; i < count; i++) {
p[i].byte1 = str[i] >> 8;
p[i].byte2 = str[i] & 0xff;
}
TSXTextExtents16( pfo->fs, p, count, &dir, &ascent, &descent, &info );
size->cx = abs((info.width + dc->w.breakRem + count * size->cx = abs((info.width + dc->w.breakRem + count *
dc->w.charExtra) * dc->wndExtX / dc->vportExtX); dc->w.charExtra) * dc->wndExtX / dc->vportExtX);
size->cy = abs((pfo->fs->ascent + pfo->fs->descent) * size->cy = abs((pfo->fs->ascent + pfo->fs->descent) *
dc->wndExtY / dc->vportExtY); dc->wndExtY / dc->vportExtY);
HeapFree( GetProcessHeap(), 0, p );
} else { } else {
INT i; INT i;
float x = 0.0, y = 0.0; float x = 0.0, y = 0.0;
for(i = 0; i < count; i++) { for(i = 0; i < count; i++) {

4
include/gdi.h
View File

@ -198,7 +198,7 @@ typedef struct tagDC_FUNCS
INT (*pExtDeviceMode)(LPSTR,HWND,LPDEVMODEA,LPSTR,LPSTR,LPDEVMODEA, INT (*pExtDeviceMode)(LPSTR,HWND,LPDEVMODEA,LPSTR,LPSTR,LPDEVMODEA,
LPSTR,DWORD); LPSTR,DWORD);
BOOL (*pExtFloodFill)(DC*,INT,INT,COLORREF,UINT); BOOL (*pExtFloodFill)(DC*,INT,INT,COLORREF,UINT);
BOOL (*pExtTextOut)(DC*,INT,INT,UINT,const RECT*,LPCSTR,UINT, BOOL (*pExtTextOut)(DC*,INT,INT,UINT,const RECT*,LPCWSTR,UINT,
const INT*); const INT*);
BOOL (*pFillPath)(DC*); BOOL (*pFillPath)(DC*);
BOOL (*pFillRgn)(DC*,HRGN,HBRUSH); BOOL (*pFillRgn)(DC*,HRGN,HBRUSH);
@ -206,7 +206,7 @@ typedef struct tagDC_FUNCS
BOOL (*pFrameRgn)(DC*,HRGN,HBRUSH,INT,INT); BOOL (*pFrameRgn)(DC*,HRGN,HBRUSH,INT,INT);
BOOL (*pGetCharWidth)(DC*,UINT,UINT,LPINT); BOOL (*pGetCharWidth)(DC*,UINT,UINT,LPINT);
COLORREF (*pGetPixel)(DC*,INT,INT); COLORREF (*pGetPixel)(DC*,INT,INT);
BOOL (*pGetTextExtentPoint)(DC*,LPCSTR,INT,LPSIZE); BOOL (*pGetTextExtentPoint)(DC*,LPCWSTR,INT,LPSIZE);
BOOL (*pGetTextMetrics)(DC*,TEXTMETRICA*); BOOL (*pGetTextMetrics)(DC*,TEXTMETRICA*);
INT (*pIntersectClipRect)(DC*,INT,INT,INT,INT); INT (*pIntersectClipRect)(DC*,INT,INT,INT,INT);
BOOL (*pInvertRgn)(DC*,HRGN); BOOL (*pInvertRgn)(DC*,HRGN);

2
include/metafiledrv.h
View File

@ -54,7 +54,7 @@ extern INT MFDRV_ExcludeClipRect( DC *dc, INT left, INT top, INT right, INT
extern BOOL MFDRV_ExtFloodFill( DC *dc, INT x, INT y, extern BOOL MFDRV_ExtFloodFill( DC *dc, INT x, INT y,
COLORREF color, UINT fillType ); COLORREF color, UINT fillType );
extern BOOL MFDRV_ExtTextOut( DC *dc, INT x, INT y, extern BOOL MFDRV_ExtTextOut( DC *dc, INT x, INT y,
UINT flags, const RECT *lprect, LPCSTR str, UINT flags, const RECT *lprect, LPCWSTR str,
UINT count, const INT *lpDx ); UINT count, const INT *lpDx );
extern BOOL MFDRV_FillPath( DC *dc ); extern BOOL MFDRV_FillPath( DC *dc );
extern BOOL MFDRV_FillRgn( DC *dc, HRGN hrgn, HBRUSH hbrush ); extern BOOL MFDRV_FillRgn( DC *dc, HRGN hrgn, HBRUSH hbrush );

7
include/psdrv.h
View File

@ -264,6 +264,7 @@ extern BOOL PSDRV_CmpColor(PSCOLOR *col1, PSCOLOR *col2);
extern BOOL PSDRV_CopyColor(PSCOLOR *col1, PSCOLOR *col2); extern BOOL PSDRV_CopyColor(PSCOLOR *col1, PSCOLOR *col2);
extern void PSDRV_CreateColor( PSDRV_PDEVICE *physDev, PSCOLOR *pscolor, extern void PSDRV_CreateColor( PSDRV_PDEVICE *physDev, PSCOLOR *pscolor,
COLORREF wincolor ); COLORREF wincolor );
extern char PSDRV_UnicodeToANSI(int u);
extern INT PSDRV_WriteHeader( DC *dc, LPCSTR title ); extern INT PSDRV_WriteHeader( DC *dc, LPCSTR title );
@ -278,7 +279,7 @@ extern BOOL PSDRV_WriteRectangle(DC *dc, INT x, INT y, INT width,
extern BOOL PSDRV_WriteRRectangle(DC *dc, INT x, INT y, INT width, extern BOOL PSDRV_WriteRRectangle(DC *dc, INT x, INT y, INT width,
INT height); INT height);
extern BOOL PSDRV_WriteSetFont(DC *dc, BOOL UseANSI); extern BOOL PSDRV_WriteSetFont(DC *dc, BOOL UseANSI);
extern BOOL PSDRV_WriteShow(DC *dc, char *str, INT count); extern BOOL PSDRV_WriteShow(DC *dc, LPCWSTR str, INT count);
extern BOOL PSDRV_WriteReencodeFont(DC *dc); extern BOOL PSDRV_WriteReencodeFont(DC *dc);
extern BOOL PSDRV_WriteSetPen(DC *dc); extern BOOL PSDRV_WriteSetPen(DC *dc);
extern BOOL PSDRV_WriteArc(DC *dc, INT x, INT y, INT w, INT h, extern BOOL PSDRV_WriteArc(DC *dc, INT x, INT y, INT w, INT h,
@ -328,11 +329,11 @@ extern BOOL PSDRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
extern INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput, extern INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
SEGPTR lpInData, SEGPTR lpOutData ); SEGPTR lpInData, SEGPTR lpOutData );
extern BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags, extern BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCWSTR str, UINT count,
const INT *lpDx ); const INT *lpDx );
extern BOOL PSDRV_GetCharWidth( DC *dc, UINT firstChar, UINT lastChar, extern BOOL PSDRV_GetCharWidth( DC *dc, UINT firstChar, UINT lastChar,
LPINT buffer ); LPINT buffer );
extern BOOL PSDRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count, extern BOOL PSDRV_GetTextExtentPoint( DC *dc, LPCWSTR str, INT count,
LPSIZE size ); LPSIZE size );
extern BOOL PSDRV_GetTextMetrics( DC *dc, TEXTMETRICA *metrics ); extern BOOL PSDRV_GetTextMetrics( DC *dc, TEXTMETRICA *metrics );
extern BOOL PSDRV_LineTo( DC *dc, INT x, INT y ); extern BOOL PSDRV_LineTo( DC *dc, INT x, INT y );

8
include/ts_xlib.h
View File

@ -69,8 +69,8 @@ extern int TSXDrawLines(Display*, Drawable, GC, XPoint*, int, int);
extern int TSXDrawPoint(Display*, Drawable, GC, int, int); extern int TSXDrawPoint(Display*, Drawable, GC, int, int);
extern int TSXDrawRectangle(Display*, Drawable, GC, int, int, unsigned int, unsigned int); extern int TSXDrawRectangle(Display*, Drawable, GC, int, int, unsigned int, unsigned int);
extern int TSXDrawSegments(Display*, Drawable, GC, XSegment*, int); extern int TSXDrawSegments(Display*, Drawable, GC, XSegment*, int);
extern int TSXDrawString(Display*, Drawable, GC, int, int, const char*, int); extern int TSXDrawString16(Display*, Drawable, GC, int, int, const XChar2b*, int);
extern int TSXDrawText(Display*, Drawable, GC, int, int, XTextItem*, int); extern int TSXDrawText16(Display*, Drawable, GC, int, int, XTextItem16*, int);
extern int TSXFillArc(Display*, Drawable, GC, int, int, unsigned int, unsigned int, int, int); extern int TSXFillArc(Display*, Drawable, GC, int, int, unsigned int, unsigned int, int, int);
extern int TSXFillPolygon(Display*, Drawable, GC, XPoint*, int, int, int); extern int TSXFillPolygon(Display*, Drawable, GC, XPoint*, int, int, int);
extern int TSXFillRectangle(Display*, Drawable, GC, int, int, unsigned int, unsigned int); extern int TSXFillRectangle(Display*, Drawable, GC, int, int, unsigned int, unsigned int);
@ -129,8 +129,8 @@ extern int TSXSetWindowColormap(Display*, Window, Colormap);
extern int TSXStoreColor(Display*, Colormap, XColor*); extern int TSXStoreColor(Display*, Colormap, XColor*);
extern int TSXStoreName(Display*, Window, const char*); extern int TSXStoreName(Display*, Window, const char*);
extern int TSXSync(Display*, int); extern int TSXSync(Display*, int);
extern int TSXTextExtents(XFontStruct*, const char*, int, int*, int*, int*, XCharStruct*); extern int TSXTextExtents16(XFontStruct*, const XChar2b*, int, int*, int*, int*, XCharStruct*);
extern int TSXTextWidth(XFontStruct*, const char*, int); extern int TSXTextWidth16(XFontStruct*, const XChar2b*, int);
extern int TSXUngrabKeyboard(Display*, Time); extern int TSXUngrabKeyboard(Display*, Time);
extern int TSXUngrabPointer(Display*, Time); extern int TSXUngrabPointer(Display*, Time);
extern int TSXUngrabServer(Display*); extern int TSXUngrabServer(Display*);

4
include/ttydrv.h
View File

@ -75,11 +75,11 @@ extern BOOL TTYDRV_DC_Chord(struct tagDC *dc, INT left, INT top, INT right, INT
extern BOOL TTYDRV_DC_Ellipse(struct tagDC *dc, INT left, INT top, INT right, INT bottom); extern BOOL TTYDRV_DC_Ellipse(struct tagDC *dc, INT left, INT top, INT right, INT bottom);
extern INT TTYDRV_DC_Escape(struct tagDC *dc, INT nEscape, INT cbInput, SEGPTR lpInData, SEGPTR lpOutData); extern INT TTYDRV_DC_Escape(struct tagDC *dc, INT nEscape, INT cbInput, SEGPTR lpInData, SEGPTR lpOutData);
extern BOOL TTYDRV_DC_ExtFloodFill(struct tagDC *dc, INT x, INT y, COLORREF color, UINT fillType); extern BOOL TTYDRV_DC_ExtFloodFill(struct tagDC *dc, INT x, INT y, COLORREF color, UINT fillType);
extern BOOL TTYDRV_DC_ExtTextOut(struct tagDC *dc, INT x, INT y, UINT flags, const RECT *lpRect, LPCSTR str, UINT count, const INT *lpDx); extern BOOL TTYDRV_DC_ExtTextOut(struct tagDC *dc, INT x, INT y, UINT flags, const RECT *lpRect, LPCWSTR str, UINT count, const INT *lpDx);
extern BOOL TTYDRV_DC_GetCharWidth(struct tagDC *dc, UINT firstChar, UINT lastChar, LPINT buffer); extern BOOL TTYDRV_DC_GetCharWidth(struct tagDC *dc, UINT firstChar, UINT lastChar, LPINT buffer);
extern COLORREF TTYDRV_DC_GetPixel(struct tagDC *dc, INT x, INT y); extern COLORREF TTYDRV_DC_GetPixel(struct tagDC *dc, INT x, INT y);
extern BOOL TTYDRV_DC_GetTextExtentPoint(struct tagDC *dc, LPCSTR str, INT count, LPSIZE size); extern BOOL TTYDRV_DC_GetTextExtentPoint(struct tagDC *dc, LPCWSTR str, INT count, LPSIZE size);
extern BOOL TTYDRV_DC_GetTextMetrics(struct tagDC *dc, TEXTMETRICA *metrics); extern BOOL TTYDRV_DC_GetTextMetrics(struct tagDC *dc, TEXTMETRICA *metrics);
extern BOOL TTYDRV_DC_LineTo(struct tagDC *dc, INT x, INT y); extern BOOL TTYDRV_DC_LineTo(struct tagDC *dc, INT x, INT y);
extern HANDLE TTYDRV_DC_LoadOEMResource(WORD resid, WORD type); extern HANDLE TTYDRV_DC_LoadOEMResource(WORD resid, WORD type);

4
include/win16drv.h
View File

@ -208,12 +208,12 @@ extern BOOL WIN16DRV_Init(void);
extern BOOL WIN16DRV_GetCharWidth( struct tagDC *dc, UINT firstChar, UINT lastChar, extern BOOL WIN16DRV_GetCharWidth( struct tagDC *dc, UINT firstChar, UINT lastChar,
LPINT buffer ); LPINT buffer );
extern BOOL WIN16DRV_GetTextExtentPoint( DC *dc, LPCSTR str, INT count, extern BOOL WIN16DRV_GetTextExtentPoint( DC *dc, LPCWSTR str, INT count,
LPSIZE size ); LPSIZE size );
extern BOOL WIN16DRV_GetTextMetrics( DC *dc, TEXTMETRICA *metrics ); extern BOOL WIN16DRV_GetTextMetrics( DC *dc, TEXTMETRICA *metrics );
extern BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags, extern BOOL WIN16DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCWSTR str, UINT count,
const INT *lpDx ); const INT *lpDx );
extern BOOL WIN16DRV_LineTo( DC *dc, INT x, INT y ); extern BOOL WIN16DRV_LineTo( DC *dc, INT x, INT y );
extern BOOL WIN16DRV_MoveToEx(DC *dc,INT x,INT y,LPPOINT pt); extern BOOL WIN16DRV_MoveToEx(DC *dc,INT x,INT y,LPPOINT pt);

4
include/x11drv.h
View File

@ -93,7 +93,7 @@ extern BOOL X11DRV_EnumDeviceFonts( struct tagDC *dc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC dfeproc, LPARAM lp ); DEVICEFONTENUMPROC dfeproc, LPARAM lp );
extern BOOL X11DRV_GetCharWidth( struct tagDC *dc, UINT firstChar, extern BOOL X11DRV_GetCharWidth( struct tagDC *dc, UINT firstChar,
UINT lastChar, LPINT buffer ); UINT lastChar, LPINT buffer );
extern BOOL X11DRV_GetTextExtentPoint( struct tagDC *dc, LPCSTR str, extern BOOL X11DRV_GetTextExtentPoint( struct tagDC *dc, LPCWSTR str,
INT count, LPSIZE size ); INT count, LPSIZE size );
extern BOOL X11DRV_GetTextMetrics(struct tagDC *dc, TEXTMETRICA *metrics); extern BOOL X11DRV_GetTextMetrics(struct tagDC *dc, TEXTMETRICA *metrics);
extern BOOL X11DRV_PatBlt( struct tagDC *dc, INT left, INT top, extern BOOL X11DRV_PatBlt( struct tagDC *dc, INT left, INT top,
@ -139,7 +139,7 @@ extern BOOL X11DRV_ExtFloodFill( struct tagDC *dc, INT x, INT y,
COLORREF color, UINT fillType ); COLORREF color, UINT fillType );
extern BOOL X11DRV_ExtTextOut( struct tagDC *dc, INT x, INT y, extern BOOL X11DRV_ExtTextOut( struct tagDC *dc, INT x, INT y,
UINT flags, const RECT *lprect, UINT flags, const RECT *lprect,
LPCSTR str, UINT count, const INT *lpDx ); LPCWSTR str, UINT count, const INT *lpDx );
extern BOOL X11DRV_CreateBitmap( HBITMAP hbitmap ); extern BOOL X11DRV_CreateBitmap( HBITMAP hbitmap );
extern BOOL X11DRV_DeleteObject( HGDIOBJ handle ); extern BOOL X11DRV_DeleteObject( HGDIOBJ handle );
extern LONG X11DRV_BitmapBits( HBITMAP hbitmap, void *bits, LONG count, extern LONG X11DRV_BitmapBits( HBITMAP hbitmap, void *bits, LONG count,

107
objects/font.c
View File

@ -852,7 +852,10 @@ BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count,
LPSIZE16 size ) LPSIZE16 size )
{ {
SIZE size32; SIZE size32;
BOOL ret = GetTextExtentPoint32A( hdc, str, count, &size32 ); BOOL ret;
TRACE("%04x, %p (%s), %d, %p\n", hdc, str, debugstr_an(str, count), count,
size);
ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
CONV_SIZE32TO16( &size32, size ); CONV_SIZE32TO16( &size32, size );
return (BOOL16)ret; return (BOOL16)ret;
} }
@ -864,20 +867,19 @@ BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count,
BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count, BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
LPSIZE size ) LPSIZE size )
{ {
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); LPWSTR p;
if (!dc) BOOL ret;
{
if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
return FALSE;
}
if (!dc->funcs->pGetTextExtentPoint || /* str may not be 0 terminated so we can't use HEAP_strdupWtoA.
!dc->funcs->pGetTextExtentPoint( dc, str, count, size )) * We allocate one more than we need so that lstrcpynWtoA can write a
return FALSE; * trailing 0 if it wants.
*/
TRACE("(%08x %s %d %p): returning %d,%d\n", p = HeapAlloc( GetProcessHeap(), 0, (count+1) * sizeof(WCHAR) );
hdc, debugstr_an (str, count), count, size, size->cx, size->cy ); lstrcpynAtoW(p, str, count+1);
return TRUE; ret = GetTextExtentPoint32W( hdc, p, count, size );
HeapFree( GetProcessHeap(), 0, p );
return ret;
} }
@ -896,20 +898,14 @@ BOOL WINAPI GetTextExtentPoint32W(
INT count, /* [in] Number of characters in string */ INT count, /* [in] Number of characters in string */
LPSIZE size) /* [out] Address of structure for string size */ LPSIZE size) /* [out] Address of structure for string size */
{ {
LPSTR p; DC * dc = DC_GetDCPtr( hdc );
BOOL ret; if (!dc || !dc->funcs->pGetTextExtentPoint ||
!dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
return FALSE;
/* str may not be 0 terminated so we can't use HEAP_strdupWtoA. TRACE("(%08x %s %d %p): returning %d,%d\n",
* We allocate one more than we need so that lstrcpynWtoA can write a hdc, debugstr_wn (str, count), count, size, size->cx, size->cy );
* trailing 0 if it wants. return TRUE;
*/
if(!count) count = lstrlenW(str);
p = HeapAlloc( GetProcessHeap(), 0, count+1 );
lstrcpynWtoA(p, str, count+1);
ret = GetTextExtentPoint32A( hdc, p, count, size );
HeapFree( GetProcessHeap(), 0, p );
return ret;
} }
@ -940,17 +936,34 @@ BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count, BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
INT maxExt, LPINT lpnFit, INT maxExt, LPINT lpnFit,
LPINT alpDx, LPSIZE size ) LPINT alpDx, LPSIZE size )
{
LPWSTR p;
BOOL ret;
/* Docs say str should be 0 terminated here, but we'll use count just in case
*/
p = HeapAlloc( GetProcessHeap(), 0, (count+1) * sizeof(WCHAR) );
lstrcpynAtoW(p, str, count+1);
ret = GetTextExtentExPointW( hdc, p, count, maxExt, lpnFit, alpDx, size);
HeapFree( GetProcessHeap(), 0, p );
return ret;
}
/***********************************************************************
* GetTextExtentExPointW (GDI32.229)
*/
BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
INT maxExt, LPINT lpnFit,
LPINT alpDx, LPSIZE size )
{ {
int index, nFit, extent; int index, nFit, extent;
SIZE tSize; SIZE tSize;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); DC * dc = DC_GetDCPtr( hdc );
if (!dc) if (!dc || !dc->funcs->pGetTextExtentPoint) return FALSE;
{
if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
return FALSE;
}
if (!dc->funcs->pGetTextExtentPoint) return FALSE;
size->cx = size->cy = nFit = extent = 0; size->cx = size->cy = nFit = extent = 0;
for(index = 0; index < count; index++) for(index = 0; index < count; index++)
@ -969,35 +982,11 @@ BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
size->cx = extent; size->cx = extent;
*lpnFit = nFit; *lpnFit = nFit;
TRACE("(%08x '%.*s' %d) returning %d %d %d\n", TRACE("(%08x %s %d) returning %d %d %d\n",
hdc,count,str,maxExt,nFit, size->cx,size->cy); hdc,debugstr_wn(str,count),maxExt,nFit, size->cx,size->cy);
return TRUE; return TRUE;
} }
/***********************************************************************
* GetTextExtentExPointW (GDI32.229)
*/
BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
INT maxExt, LPINT lpnFit,
LPINT alpDx, LPSIZE size )
{
LPSTR p;
BOOL ret;
/* Docs say str should be 0 terminated here, but we'll use count just in case
*/
if(!count) count = lstrlenW(str);
p = HeapAlloc( GetProcessHeap(), 0, count+1 );
lstrcpynWtoA(p, str, count+1);
ret = GetTextExtentExPointA( hdc, p, count, maxExt,
lpnFit, alpDx, size);
HeapFree( GetProcessHeap(), 0, p );
return ret;
}
/*********************************************************************** /***********************************************************************
* GetTextMetrics16 (GDI.93) * GetTextMetrics16 (GDI.93)
*/ */

22
objects/text.c
View File

@ -374,29 +374,33 @@ BOOL16 WINAPI ExtTextOut16( HDC16 hdc, INT16 x, INT16 y, UINT16 flags,
/*********************************************************************** /***********************************************************************
* ExtTextOut32A (GDI32.98) * ExtTextOutA (GDI32.98)
*/ */
BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags, BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
const RECT *lprect, LPCSTR str, UINT count, const RECT *lprect, LPCSTR str, UINT count,
const INT *lpDx ) const INT *lpDx )
{ {
DC * dc = DC_GetDCPtr( hdc ); /* str need not be \0 terminated but lstrcpynAtoW adds \0 so we allocate one
return dc && dc->funcs->pExtTextOut && more byte */
dc->funcs->pExtTextOut(dc,x,y,flags,lprect,str,count,lpDx); LPWSTR p = HeapAlloc( GetProcessHeap(), 0, (count+1) * sizeof(WCHAR) );
INT ret;
lstrcpynAtoW( p, str, count+1 );
ret = ExtTextOutW( hdc, x, y, flags, lprect, p, count, lpDx );
HeapFree( GetProcessHeap(), 0, p );
return ret;
} }
/*********************************************************************** /***********************************************************************
* ExtTextOut32W (GDI32.99) * ExtTextOutW (GDI32.99)
*/ */
BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags, BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
const RECT *lprect, LPCWSTR str, UINT count, const RECT *lprect, LPCWSTR str, UINT count,
const INT *lpDx ) const INT *lpDx )
{ {
LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str ); DC * dc = DC_GetDCPtr( hdc );
INT ret = ExtTextOutA( hdc, x, y, flags, lprect, p, count, lpDx ); return dc && dc->funcs->pExtTextOut &&
HeapFree( GetProcessHeap(), 0, p ); dc->funcs->pExtTextOut(dc,x,y,flags,lprect,str,count,lpDx);
return ret;
} }

8
tsx11/X11_calls
View File

@ -46,8 +46,8 @@ XDrawLines
XDrawPoint XDrawPoint
XDrawRectangle XDrawRectangle
XDrawSegments XDrawSegments
XDrawString XDrawString16
XDrawText XDrawText16
XEmptyRegion XEmptyRegion
XEqualRegion XEqualRegion
XFillArc XFillArc
@ -157,8 +157,8 @@ XSubImage
XSubtractRegion XSubtractRegion
XSync XSync
XSynchronize XSynchronize
XTextExtents XTextExtents16
XTextWidth XTextWidth16
XUngrabKeyboard XUngrabKeyboard
XUngrabPointer XUngrabPointer
XUngrabServer XUngrabServer

32
tsx11/ts_xlib.c
View File

@ -598,25 +598,25 @@ int TSXDrawSegments(Display* a0, Drawable a1, GC a2, XSegment* a3, int a4)
return r; return r;
} }
int TSXDrawString(Display* a0, Drawable a1, GC a2, int a3, int a4, const char* a5, int a6) int TSXDrawString16(Display* a0, Drawable a1, GC a2, int a3, int a4, const XChar2b* a5, int a6)
{ {
int r; int r;
TRACE("Call XDrawString\n"); TRACE("Call XDrawString16\n");
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );
r = XDrawString(a0, a1, a2, a3, a4, a5, a6); r = XDrawString16(a0, a1, a2, a3, a4, a5, a6);
LeaveCriticalSection( &X11DRV_CritSection ); LeaveCriticalSection( &X11DRV_CritSection );
TRACE("Ret XDrawString\n"); TRACE("Ret XDrawString16\n");
return r; return r;
} }
int TSXDrawText(Display* a0, Drawable a1, GC a2, int a3, int a4, XTextItem* a5, int a6) int TSXDrawText16(Display* a0, Drawable a1, GC a2, int a3, int a4, XTextItem16* a5, int a6)
{ {
int r; int r;
TRACE("Call XDrawText\n"); TRACE("Call XDrawText16\n");
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );
r = XDrawText(a0, a1, a2, a3, a4, a5, a6); r = XDrawText16(a0, a1, a2, a3, a4, a5, a6);
LeaveCriticalSection( &X11DRV_CritSection ); LeaveCriticalSection( &X11DRV_CritSection );
TRACE("Ret XDrawText\n"); TRACE("Ret XDrawText16\n");
return r; return r;
} }
@ -1258,25 +1258,25 @@ int TSXSync(Display* a0, int a1)
return r; return r;
} }
int TSXTextExtents(XFontStruct* a0, const char* a1, int a2, int* a3, int* a4, int* a5, XCharStruct* a6) int TSXTextExtents16(XFontStruct* a0, const XChar2b* a1, int a2, int* a3, int* a4, int* a5, XCharStruct* a6)
{ {
int r; int r;
TRACE("Call XTextExtents\n"); TRACE("Call XTextExtents16\n");
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );
r = XTextExtents(a0, a1, a2, a3, a4, a5, a6); r = XTextExtents16(a0, a1, a2, a3, a4, a5, a6);
LeaveCriticalSection( &X11DRV_CritSection ); LeaveCriticalSection( &X11DRV_CritSection );
TRACE("Ret XTextExtents\n"); TRACE("Ret XTextExtents16\n");
return r; return r;
} }
int TSXTextWidth(XFontStruct* a0, const char* a1, int a2) int TSXTextWidth16(XFontStruct* a0, const XChar2b* a1, int a2)
{ {
int r; int r;
TRACE("Call XTextWidth\n"); TRACE("Call XTextWidth16\n");
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );
r = XTextWidth(a0, a1, a2); r = XTextWidth16(a0, a1, a2);
LeaveCriticalSection( &X11DRV_CritSection ); LeaveCriticalSection( &X11DRV_CritSection );
TRACE("Ret XTextWidth\n"); TRACE("Ret XTextWidth16\n");
return r; return r;
} }