font.c File Reference

#include <user32.h>

Include dependency graph for font.c:

Go to the source code of this file.

Macros
#define	MAX_BUFFER   1024
#define	PREFIX   38
#define	ALPHA_PREFIX   30 /* Win16: Alphabet prefix */
#define	KANA_PREFIX   31 /* Win16: Katakana prefix */

Functions
DWORD WINAPI	GdiGetCodePage (HDC hdc)
INT WINAPI	DrawTextExWorker (HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
LONG	TEXT_TabbedTextOut (HDC hdc, INT x, INT y, LPCWSTR lpstr, INT count, INT cTabStops, const INT *lpTabPos, INT nTabOrg, BOOL fDisplayText)
LONG WINAPI	TabbedTextOutA (HDC hDC, int X, int Y, LPCSTR lpString, int nCount, int nTabPositions, CONST INT *lpnTabStopPositions, int nTabOrigin)
LONG WINAPI	TabbedTextOutW (HDC hDC, int X, int Y, LPCWSTR lpString, int nCount, int nTabPositions, CONST INT *lpnTabStopPositions, int nTabOrigin)
DWORD WINAPI	GetTabbedTextExtentA (HDC hDC, LPCSTR lpString, int nCount, int nTabPositions, CONST INT *lpnTabStopPositions)
DWORD WINAPI	GetTabbedTextExtentW (HDC hDC, LPCWSTR lpString, int nCount, int nTabPositions, CONST INT *lpnTabStopPositions)
INT WINAPI	DrawTextExW (HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
INT WINAPI	DrawTextExA (HDC hdc, LPSTR str, INT count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
INT WINAPI	DrawTextW (HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
INT WINAPI	DrawTextA (HDC hdc, LPCSTR str, INT count, LPRECT rect, UINT flags)
INT WINAPI	UserLpkPSMTextOut (HDC hdc, int x, int y, LPCWSTR lpString, int cString, DWORD dwFlags)

Macro Definition Documentation

ALPHA_PREFIX

#define ALPHA_PREFIX   30 /* Win16: Alphabet prefix */

Definition at line 410 of file font.c.

KANA_PREFIX

#define KANA_PREFIX   31 /* Win16: Katakana prefix */

Definition at line 411 of file font.c.

MAX_BUFFER

#define MAX_BUFFER   1024

Definition at line 253 of file font.c.

PREFIX

#define PREFIX   38

Definition at line 409 of file font.c.

Function Documentation

DrawTextA()

INT WINAPI DrawTextA	(	HDC	hdc,
		LPCSTR	str,
		INT	count,
		LPRECT	rect,
		UINT	flags
	)

Definition at line 373 of file font.c.

{
    DRAWTEXTPARAMS dtp;
 
    memset (&dtp, 0, sizeof(dtp));
    dtp.cbSize = sizeof(dtp);
    if (flags & DT_TABSTOP)
    {
        dtp.iTabLength = (flags >> 8) & 0xff;
        flags &= 0xffff00ff;
    }
    return DrawTextExA( hdc, (LPSTR)str, count, rect, flags, &dtp );
}

Referenced by create_bitmap(), DECLARE_INTERFACE_(), DoEntry(), menu_ownerdraw_wnd_proc(), PAINTING_DrawStateJam(), test_bcm_get_ideal_size(), and test_DrawTextCalcRect().

DrawTextExA()

INT WINAPI DrawTextExA	(	HDC	hdc,
		LPSTR	str,
		INT	count,
		LPRECT	rect,
		UINT	flags,
		LPDRAWTEXTPARAMS	dtp
	)

Definition at line 276 of file font.c.

{
   WCHAR *wstr;
   WCHAR *p;
   INT ret = 0;
   int i;
   DWORD wcount;
   DWORD wmax;
   DWORD amax;
   UINT cp;
 
   if (!count) return 0;
   if (!str && count > 0) return 0;
   if( !str || ((count == -1) && !(count = strlen(str))))
   {
        int lh;
        TEXTMETRICA tm;
 
        if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS))
            return 0;
 
        GetTextMetricsA(hdc, &tm);
        if (flags & DT_EXTERNALLEADING)
            lh = tm.tmHeight + tm.tmExternalLeading;
        else
            lh = tm.tmHeight;
 
        if( flags & DT_CALCRECT)
        {
            rect->right = rect->left;
            if( flags & DT_SINGLELINE)
                rect->bottom = rect->top + lh;
            else
                rect->bottom = rect->top;
        }
        return lh;
   }
   cp = GdiGetCodePage( hdc );
   wcount = MultiByteToWideChar( cp, 0, str, count, NULL, 0 );
   wmax = wcount;
   amax = count;
   if (flags & DT_MODIFYSTRING)
   {
        wmax += 4;
        amax += 4;
   }
   wstr = HeapAlloc(GetProcessHeap(), 0, wmax * sizeof(WCHAR));
   if (wstr)
   {
       MultiByteToWideChar( cp, 0, str, count, wstr, wcount );
       if (flags & DT_MODIFYSTRING)
           for (i=4, p=wstr+wcount; i--; p++) *p=0xFFFE;
           /* Initialise the extra characters so that we can see which ones
            * change.  U+FFFE is guaranteed to be not a unicode character and
            * so will not be generated by DrawTextEx itself.
            */
       ret = DrawTextExW( hdc, wstr, wcount, rect, flags, dtp );
       if (flags & DT_MODIFYSTRING)
       {
            /* Unfortunately the returned string may contain multiple \0s
             * and so we need to measure it ourselves.
             */
            for (i=4, p=wstr+wcount; i-- && *p != 0xFFFE; p++) wcount++;
            WideCharToMultiByte( cp, 0, wstr, wcount, str, amax, NULL, NULL );
       }
       HeapFree(GetProcessHeap(), 0, wstr);
   }
   return ret;
}

Referenced by DrawTextA().

DrawTextExW()

INT WINAPI DrawTextExW	(	HDC	hdc,
		LPWSTR	str,
		INT	i_count,
		LPRECT	rect,
		UINT	flags,
		LPDRAWTEXTPARAMS	dtp
	)

Definition at line 259 of file font.c.

{
   return DrawTextExWorker( hdc, str, i_count, rect, flags, dtp );
}

Referenced by DrawTextExA(), and DrawTextW().

DrawTextExWorker()

INT WINAPI DrawTextExWorker	(	HDC	hdc,
		LPWSTR	str,
		INT	i_count,
		LPRECT	rect,
		UINT	flags,
		LPDRAWTEXTPARAMS	dtp
	)

Definition at line 1075 of file text.c.

{
    SIZE size;
    const WCHAR *strPtr;
    WCHAR *retstr, *p_retstr;
    size_t size_retstr;
    WCHAR line[MAX_BUFFER];
    int len, lh, count=i_count;
    TEXTMETRICW tm;
    int lmargin = 0, rmargin = 0;
    int x = rect->left, y = rect->top;
    int width = rect->right - rect->left;
    int max_width = 0;
    int last_line;
    int tabwidth /* to keep gcc happy */ = 0;
    int prefix_offset;
    ellipsis_data ellip;
    BOOL invert_y=FALSE;
 
    HRGN    hrgn = 0;
 
#ifdef _WIN32K_
    TRACE("%S, %d, %08x\n", str, count, flags);
#else
    TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str, count), count,
        wine_dbgstr_rect(rect), flags);
#endif
    if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
          dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin);
 
    if (!str) return 0;
 
    strPtr = str;
 
    if (flags & DT_SINGLELINE)
        flags &= ~DT_WORDBREAK;
#ifdef _WIN32K_
    GreGetTextMetricsW(hdc, &tm);
#else
    GetTextMetricsW(hdc, &tm);
#endif
    if (flags & DT_EXTERNALLEADING)
    lh = tm.tmHeight + tm.tmExternalLeading;
    else
    lh = tm.tmHeight;
 
    if (str[0] && count == 0)
        return lh;
 
    if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS))
        return 0;
#ifdef _WIN32K_
    if (GreGetGraphicsMode(hdc) == GM_COMPATIBLE)
    {
        SIZE window_ext, viewport_ext;
        GreGetWindowExtEx(hdc, &window_ext);
        GreGetViewportExtEx(hdc, &viewport_ext);
        if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
            invert_y = TRUE;
    }
#else
    if (GetGraphicsMode(hdc) == GM_COMPATIBLE)
    {
        SIZE window_ext, viewport_ext;
        GetWindowExtEx(hdc, &window_ext);
        GetViewportExtEx(hdc, &viewport_ext);
        if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
            invert_y = TRUE;
    }
#endif
    if (count == -1)
    {
#ifdef _WIN32K_
        count = wcslen(str);
#else
        count = strlenW(str);
#endif
        if (count == 0)
        {
            if( flags & DT_CALCRECT)
            {
                rect->right = rect->left;
                if( flags & DT_SINGLELINE)
                    rect->bottom = rect->top + (invert_y ? -lh : lh);
                else
                    rect->bottom = rect->top;
            }
            return lh;
        }
    }
 
    if (dtp)
    {
        lmargin = dtp->iLeftMargin;
        rmargin = dtp->iRightMargin;
        if (!(flags & (DT_CENTER | DT_RIGHT)))
            x += lmargin;
        dtp->uiLengthDrawn = 0;     /* This param RECEIVES number of chars processed */
    }
 
    if (flags & DT_EXPANDTABS)
    {
        int tabstop = ((flags & DT_TABSTOP) && dtp && dtp->iTabLength) ? dtp->iTabLength : 8;
    tabwidth = tm.tmAveCharWidth * tabstop;
    }
 
    if (flags & DT_CALCRECT) flags |= DT_NOCLIP;
#ifndef _WIN32K_ 
    if (!(flags & DT_NOCLIP) )
    {
       int hasClip;
       hrgn = CreateRectRgn(0,0,0,0);
       if (hrgn)
       {
          hasClip = GetClipRgn(hdc, hrgn);
          // If the region to be retrieved is NULL, the return value is 0.
          if (hasClip != 1)
          {
             DeleteObject(hrgn);
             hrgn = NULL;
          }
          IntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
       }
    }
#else
    if (!(flags & DT_NOCLIP) )
    {
       int hasClip;
       hrgn = NtGdiCreateRectRgn(0,0,0,0);
       if (hrgn)
       {
          hasClip = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN);
          if (hasClip != 1)
          {
             GreDeleteObject(hrgn);
             hrgn = NULL;
          }
          NtGdiIntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
       }
    }
#endif 
    if (flags & DT_MODIFYSTRING)
    {
        size_retstr = (count + 4) * sizeof (WCHAR);
#ifdef _WIN32K_
        retstr = ExAllocatePoolWithTag(PagedPool, size_retstr, USERTAG_RTL);
#else
        retstr = HeapAlloc(GetProcessHeap(), 0, size_retstr);
#endif
        if (!retstr) return 0;
        memcpy (retstr, str, size_retstr);
    }
    else
    {
        size_retstr = 0;
        retstr = NULL;
    }
    p_retstr = retstr;
 
    do
    {
    len = sizeof(line)/sizeof(line[0]);
    if (invert_y)
            last_line = !(flags & DT_NOCLIP) && y - ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) < rect->bottom;
    else
            last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom;
    strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags, &size, last_line, &p_retstr, tabwidth, &prefix_offset, &ellip);
 
#ifdef __REACTOS__
    if (flags & DT_CENTER)
    {
        if (((rect->right - rect->left) < size.cx) && (flags & DT_CALCRECT))
        {
            x = rect->left + size.cx;
        }
        else
        {
            x = (rect->left + rect->right - size.cx) / 2;
        }
    }
#else
    if (flags & DT_CENTER) x = (rect->left + rect->right -
                    size.cx) / 2;
#endif
    else if (flags & DT_RIGHT) x = rect->right - size.cx;
 
    if (flags & DT_SINGLELINE)
    {
#ifdef __REACTOS__
        if (flags & DT_VCENTER) y = rect->top +
            (rect->bottom - rect->top + (invert_y ? size.cy : -size.cy)) / 2;
        else if (flags & DT_BOTTOM)
            y = rect->bottom + (invert_y ? size.cy : -size.cy);
#else
        if (flags & DT_VCENTER) y = rect->top +
            (rect->bottom - rect->top) / 2 - size.cy / 2;
        else if (flags & DT_BOTTOM) y = rect->bottom - size.cy;
#endif
    }
 
    if (!(flags & DT_CALCRECT))
    {
            const WCHAR *str = line;
            int xseg = x;
            while (len)
            {
                int len_seg;
                SIZE size;
                if ((flags & DT_EXPANDTABS))
                {
                    const WCHAR *p;
                    p = str; while (p < str+len && *p != TAB) p++;
                    len_seg = p - str;
                    if (len_seg != len &&
#ifdef _WIN32K_
                        !GreGetTextExtentW(hdc, str, len_seg, &size, 0))
#else
                        !GetTextExtentPointW(hdc, str, len_seg, &size))
#endif
                    {
#ifdef _WIN32K_
                        ExFreePoolWithTag(retstr, USERTAG_RTL);
#else
                        HeapFree (GetProcessHeap(), 0, retstr);
#endif
                        return 0;
                    }
                }
                else
                    len_seg = len;
#ifdef _WIN32K_
                if (!UserExtTextOutW( hdc, xseg, y,
                                     ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
                                     ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
                                     rect, str, len_seg))
#else
                if (!ExtTextOutW( hdc, xseg, y,
                                 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
                                 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
                                 rect, str, len_seg, NULL ))
#endif
                {
#ifdef _WIN32K_
                    ExFreePoolWithTag(retstr, USERTAG_RTL);
#else
                    HeapFree (GetProcessHeap(), 0, retstr);
#endif
                    return 0;
                }
                if (prefix_offset != -1 && prefix_offset < len_seg)
                {
                    TEXT_DrawUnderscore (hdc, xseg, y + tm.tmAscent + 1, str, prefix_offset, (flags & DT_NOCLIP) ? NULL : rect);
                }
                len -= len_seg;
                str += len_seg;
                if (len)
                {
                    assert ((flags & DT_EXPANDTABS) && *str == TAB);
                    len--; str++;
                    xseg += ((size.cx/tabwidth)+1)*tabwidth;
                    if (prefix_offset != -1)
                    {
                        if (prefix_offset < len_seg)
                        {
                            /* We have just drawn an underscore; we ought to
                             * figure out where the next one is.  I am going
                             * to leave it for now until I have a better model
                             * for the line, which will make reprefixing easier.
                             * This is where ellip would be used.
                             */
                            prefix_offset = -1;
                        }
                        else
                            prefix_offset -= len_seg;
                    }
                }
            }
    }
    else if (size.cx > max_width)
        max_width = size.cx;
 
        y += invert_y ? -lh : lh;
        if (dtp)
            dtp->uiLengthDrawn += len;
    }
    while (strPtr && !last_line);
 
#ifndef _WIN32K_
    if (!(flags & DT_NOCLIP) )
    {
       SelectClipRgn(hdc, hrgn); // This should be NtGdiExtSelectClipRgn, but due to ReactOS build rules this option is next:
       GdiFlush();               // Flush the batch and level up! See CORE-16498.
       if (hrgn)
       {
          DeleteObject(hrgn);
       }
    }
#else
    if (!(flags & DT_NOCLIP) )
    {
       NtGdiExtSelectClipRgn(hdc, hrgn, RGN_COPY);
       if (hrgn)
       {
          GreDeleteObject(hrgn);
       }
    }
#endif
 
    if (flags & DT_CALCRECT)
    {
    rect->right = rect->left + max_width;
    rect->bottom = y;
        if (dtp)
            rect->right += lmargin + rmargin;
    }
    if (retstr)
    {
        memcpy (str, retstr, size_retstr);
#ifdef _WIN32K_
        ExFreePoolWithTag(retstr, USERTAG_RTL);
#else
        HeapFree (GetProcessHeap(), 0, retstr);
#endif
    }
    return y - rect->top;
}

Referenced by DrawTextExW().

DrawTextW()

INT WINAPI DrawTextW	(	HDC	hdc,
		LPCWSTR	str,
		INT	count,
		LPRECT	rect,
		UINT	flags
	)

Definition at line 353 of file font.c.

{
    DRAWTEXTPARAMS dtp;
 
    memset (&dtp, 0, sizeof(dtp));
    dtp.cbSize = sizeof(dtp);
    if (flags & DT_TABSTOP)
    {
        dtp.iTabLength = (flags >> 8) & 0xff;
        flags &= 0xffff00ff;
    }
    return DrawTextExW(hdc, (LPWSTR)str, count, rect, flags, &dtp);
}

GdiGetCodePage()

DWORD WINAPI GdiGetCodePage

(

HDC

hdc

)

GetTabbedTextExtentA()

DWORD WINAPI GetTabbedTextExtentA	(	HDC	hDC,
		LPCSTR	lpString,
		int	nCount,
		int	nTabPositions,
		CONST INT *	lpnTabStopPositions
	)

Definition at line 205 of file font.c.

{
    LONG ret;
    UINT cp = GdiGetCodePage( hDC ); // CP_ACP
    DWORD len;
    LPWSTR strW;
 
    len = MultiByteToWideChar(cp, 0, lpString, nCount, NULL, 0);
    if (!len) return 0;
    strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!strW) return 0;
    MultiByteToWideChar(cp, 0, lpString, nCount, strW, len);
    ret = GetTabbedTextExtentW(hDC, strW, len, nTabPositions, lpnTabStopPositions);
    HeapFree(GetProcessHeap(), 0, strW);
    return ret;
}

GetTabbedTextExtentW()

DWORD WINAPI GetTabbedTextExtentW	(	HDC	hDC,
		LPCWSTR	lpString,
		int	nCount,
		int	nTabPositions,
		CONST INT *	lpnTabStopPositions
	)

Definition at line 232 of file font.c.

{
   return TEXT_TabbedTextOut(hDC, 0, 0, lpString, nCount, nTabPositions, lpnTabStopPositions, 0, FALSE);
}

Referenced by GetTabbedTextExtentA().

TabbedTextOutA()

LONG WINAPI TabbedTextOutA	(	HDC	hDC,
		int	X,
		int	Y,
		LPCSTR	lpString,
		int	nCount,
		int	nTabPositions,
		CONST INT *	lpnTabStopPositions,
		int	nTabOrigin
	)

Definition at line 156 of file font.c.

{
  LONG ret;
  DWORD len;
  LPWSTR strW;
  UINT cp = GdiGetCodePage( hDC ); // CP_ACP
 
  len = MultiByteToWideChar(cp, 0, lpString, nCount, NULL, 0);
  if (!len) return 0;
  strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  if (!strW) return 0;
  MultiByteToWideChar(cp, 0, lpString, nCount, strW, len);
  ret = TabbedTextOutW(hDC, X, Y, strW, len, nTabPositions, lpnTabStopPositions, nTabOrigin);
  HeapFree(GetProcessHeap(), 0, strW);
  return ret;
}

TabbedTextOutW()

LONG WINAPI TabbedTextOutW	(	HDC	hDC,
		int	X,
		int	Y,
		LPCWSTR	lpString,
		int	nCount,
		int	nTabPositions,
		CONST INT *	lpnTabStopPositions,
		int	nTabOrigin
	)

Definition at line 186 of file font.c.

{
  return TEXT_TabbedTextOut(hDC, X, Y, lpString, nCount, nTabPositions, lpnTabStopPositions, nTabOrigin, TRUE);
}

Referenced by TabbedTextOutA().

TEXT_TabbedTextOut()

LONG TEXT_TabbedTextOut	(	HDC	hdc,
		INT	x,
		INT	y,
		LPCWSTR	lpstr,
		INT	count,
		INT	cTabStops,
		const INT *	lpTabPos,
		INT	nTabOrg,
		BOOL	fDisplayText
	)

Definition at line 49 of file font.c.

{
    INT defWidth;
    SIZE extent;
    int i, j;
    int start = x;
    TEXTMETRICW tm;
 
    if (!lpTabPos)
        cTabStops=0;
 
    GetTextMetricsW( hdc, &tm );
 
    if (cTabStops == 1)
    {
        defWidth = *lpTabPos;
        cTabStops = 0;
    }
    else
    {
        defWidth = 8 * tm.tmAveCharWidth;
    }
 
    while (count > 0)
    {
        RECT r;
        INT x0;
        x0 = x;
        r.left = x0;
        /* chop the string into substrings of 0 or more <tabs>
         * possibly followed by 1 or more normal characters */
        for (i = 0; i < count; i++)
            if (lpstr[i] != '\t') break;
        for (j = i; j < count; j++)
            if (lpstr[j] == '\t') break;
        /* get the extent of the normal character part */
        GetTextExtentPointW( hdc, lpstr + i, j - i , &extent );
        /* and if there is a <tab>, calculate its position */
        if( i) {
            /* get x coordinate for the drawing of this string */
            for (; cTabStops > i; lpTabPos++, cTabStops--)
            {
                if( nTabOrg + abs( *lpTabPos) > x) {
                    if( lpTabPos[ i - 1] >= 0) {
                        /* a left aligned tab */
                        x = nTabOrg + lpTabPos[ i-1] + extent.cx;
                        break;
                    }
                    else
                    {
                        /* if tab pos is negative then text is right-aligned
                         * to tab stop meaning that the string extends to the
                         * left, so we must subtract the width of the string */
                        if (nTabOrg - lpTabPos[ i - 1] - extent.cx > x)
                        {
                            x = nTabOrg - lpTabPos[ i - 1];
                            x0 = x - extent.cx;
                            break;
                        }
                    }
                }
            }
            /* if we have run out of tab stops and we have a valid default tab
             * stop width then round x up to that width */
            if ((cTabStops <= i) && (defWidth > 0)) {
                x0 = nTabOrg + ((x - nTabOrg) / defWidth + i) * defWidth;
                x = x0 + extent.cx;
            } else if ((cTabStops <= i) && (defWidth < 0)) {
                x = nTabOrg + ((x - nTabOrg + extent.cx) / -defWidth + i)
                    * -defWidth;
                x0 = x - extent.cx;
            }
        } else
            x += extent.cx;
 
        if (fDisplayText)
        {
            r.top    = y;
            r.right  = x;
            r.bottom = y + extent.cy;
 
            ExtTextOutW( hdc, x0, y, GetBkMode(hdc) == OPAQUE ? ETO_OPAQUE : 0,
                         &r, lpstr + i, j - i, NULL );
        }
        count -= j;
        lpstr += j;
    }
 
    if(!extent.cy)
        extent.cy = tm.tmHeight;
 
    return MAKELONG(x - start, extent.cy);
}

Referenced by GetTabbedTextExtentW(), and TabbedTextOutW().

UserLpkPSMTextOut()

INT WINAPI UserLpkPSMTextOut	(	HDC	hdc,
		int	x,
		int	y,
		LPCWSTR	lpString,
		int	cString,
		DWORD	dwFlags
	)

Definition at line 413 of file font.c.

{
    SIZE size;
    TEXTMETRICW tm;
    int len, i = 0, j = 0;
    int prefix_count = 0, prefix_offset = -1;
    LPWSTR display_str = NULL;
    int prefix_x, prefix_end;
    HPEN hpen;
    HPEN oldPen;
 
    if (!lpString || cString <= 0)
        return 0;
 
    if (dwFlags & DT_NOPREFIX) /* Windows ignores this */
    {
        TextOutW(hdc, x, y, lpString, cString);
        GetTextExtentPointW(hdc, lpString, cString, &size);
        return size.cx;
    }
 
    display_str = HeapAlloc(GetProcessHeap(), 0, (cString + 1) * sizeof(WCHAR));
 
    if (!display_str)
        return 0;
 
    while (i < cString)
    {
        if (lpString[i] == PREFIX || (iswspace(lpString[i]) && lpString[i] != L' '))
        {
            if (i < cString - 1 && lpString[i + 1] == PREFIX)
                display_str[j++] = lpString[i++];
            else
                i++;
        }
        else
        {
            display_str[j++] = lpString[i++];
        }
    }
 
    display_str[j] = L'\0';   
    len = wcslen(display_str);
 
    if (!(dwFlags & DT_PREFIXONLY))
        TextOutW(hdc, x, y, display_str, len);
 
    if (!(dwFlags & DT_HIDEPREFIX))
    {
        
        for (i = 0; i < cString - 1; i++)
        {
            if (lpString[i] == PREFIX && lpString[i + 1] != PREFIX)
            {
                prefix_offset = i - prefix_count;
                prefix_count++;
            }
            else if (lpString[i] == PREFIX && lpString[i + 1] == PREFIX)
            {
                i++;
            }
        }
 
        GetTextMetricsW(hdc, &tm);
        
        if (prefix_offset != -1)
        {
            GetTextExtentPointW(hdc, display_str, prefix_offset, &size);
            prefix_x = x + size.cx;
            GetTextExtentPointW(hdc, display_str, prefix_offset + 1, &size);
            prefix_end = x + size.cx - 1;
            hpen = CreatePen(PS_SOLID, 1, GetTextColor(hdc));
            oldPen = SelectObject(hdc, hpen);
            MoveToEx(hdc, prefix_x, y + tm.tmAscent + 1, NULL);
            LineTo(hdc, prefix_end, y + tm.tmAscent + 1);
            SelectObject(hdc, oldPen);
            DeleteObject(hpen);
        }
    }
 
    GetTextExtentPointW(hdc, display_str, len + 1, &size);
    HeapFree(GetProcessHeap(), 0, display_str);
 
    return size.cx;
}

Referenced by DrawTest().