lpk.c File Reference

#include "ros_lpk.h"

Include dependency graph for lpk.c:

Go to the source code of this file.

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

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (bidi)
static int	PSM_FindLastPrefix (LPCWSTR str, int count)
static void	PSM_PrepareToDraw (LPCWSTR str, INT count, LPWSTR new_str, LPINT new_count)
static void	LPK_DrawUnderscore (HDC hdc, int x, int y, LPCWSTR str, int count, int offset)
static BOOL	GetProcessImageVersionInfo (_Out_ PVOID *pFileInfo, _Out_ LPDWORD pdwLen)
static void	LPK_ApplyMirroring (void)
BOOL WINAPI	LpkDllInitialize (_In_ HANDLE hDll, _In_ ULONG dwReason, _In_opt_ PVOID pReserved)
BOOL WINAPI	LpkExtTextOut (HDC hdc, int x, int y, UINT fuOptions, const RECT *lprc, LPCWSTR lpString, UINT uCount, const INT *lpDx, INT unknown)
DWORD WINAPI	LpkGetCharacterPlacement (HDC hdc, LPCWSTR lpString, INT uCount, INT nMaxExtent, LPGCP_RESULTSW lpResults, DWORD dwFlags, DWORD dwUnused)
INT WINAPI	LpkPSMTextOut (HDC hdc, int x, int y, LPCWSTR lpString, int cString, DWORD dwFlags)
BOOL WINAPI	LpkGetTextExtentExPoint (HDC hdc, LPCWSTR lpString, INT cString, INT nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize, DWORD dwUnused, int unknown)

Variables
LPK_LPEDITCONTROL_LIST	LpkEditControl

Macro Definition Documentation

ALPHA_PREFIX

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

Definition at line 19 of file lpk.c.

KANA_PREFIX

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

Definition at line 20 of file lpk.c.

PREFIX

#define PREFIX   38

Definition at line 18 of file lpk.c.

Function Documentation

GetProcessImageVersionInfo()

static BOOL GetProcessImageVersionInfo ( _Out_ PVOID *  pFileInfo, _Out_ LPDWORD  pdwLen  )

static

Definition at line 115 of file lpk.c.

{
    HRSRC hResource;
    DWORD dwResourceSize;
    HGLOBAL hResourceData;
    PVOID pvResourceData;
 
    *pFileInfo = NULL;
    *pdwLen = 0;
 
    /* Try to get the VersionInfo resource */
    hResource = FindResourceW(NULL, MAKEINTRESOURCEW(VS_VERSION_INFO), RT_VERSION);
    if (hResource == NULL)
        return FALSE;
 
    /* Get resource size and do basic size check */
    dwResourceSize = SizeofResource(NULL, hResource);
    if (dwResourceSize < sizeof(VS_FIXEDFILEINFO))
        return FALSE;
 
    /* Load the resource */
    hResourceData = LoadResource(NULL, hResource);
    if (hResourceData == NULL)
        return FALSE;
 
    /* Lock the resource */
    pvResourceData = LockResource(hResourceData);
    if (pvResourceData == NULL)
        return FALSE;
 
    *pFileInfo = pvResourceData;
    *pdwLen = dwResourceSize;
    return TRUE;
}

Referenced by LPK_ApplyMirroring().

LPK_ApplyMirroring()

static void LPK_ApplyMirroring ( void  )

static

Definition at line 161 of file lpk.c.

{
    PWSTR pwstrFileDescription = NULL;
    PVOID pvFileInfo;
    DWORD cbFileInfoSize;
 
    /* Get the VersionInfo resource of the main executable */
    if (!GetProcessImageVersionInfo(&pvFileInfo, &cbFileInfoSize))
    {
        return;
    }
 
    /* The length (in WCHARs) of the key name, including the null-terminator */
    const DWORD cchKeyLength = sizeof(L"FileDescription") / sizeof(WCHAR);
 
    /* Calculate the required length (in WCHARs) for a FileDescription entry:
       The key (incl. null) + alignment byte + 2 LTR markers (note: the key
       is always unaligned by 2 bytes) */
    const DWORD cchRequired = cchKeyLength + 1 + 2;
 
    /* Scan the VersionInfo resource for the "FileDescription" key */
    PWSTR pwchCurrent = (PWSTR)pvFileInfo;
    DWORD cchRemining = cbFileInfoSize / sizeof(WCHAR);
    while (cchRemining >= cchRequired)
    {
        /* Compare current position with the "FileDescription" key */
        if (lstrcmpW(pwchCurrent, L"FileDescription") == 0)
        {
            /* The value starts after the key, the null-terminator and 1 WCHAR alignment */
            pwstrFileDescription = pwchCurrent + cchKeyLength + 1;
            break;
        }
 
        /* Move to next position */
        pwchCurrent++;
        cchRemining--;
    }
 
    /* Check if the description starts with 2 LTR markers (u200E).
       Yes, this is how MS marks the layout as RTL (see article linked above). */
    if ((pwstrFileDescription != NULL) &&
        (pwstrFileDescription[0] == 0x200E) &&
        (pwstrFileDescription[1] == 0x200E))
    {
        SetProcessDefaultLayout(LAYOUT_RTL);
    }
}

Referenced by LpkDllInitialize().

LPK_DrawUnderscore()

static void LPK_DrawUnderscore ( HDC  hdc, int  x, int  y, LPCWSTR  str, int  count, int  offset  )

static

Definition at line 66 of file lpk.c.

{
    SCRIPT_STRING_ANALYSIS ssa;
    DWORD dwSSAFlags = SSA_GLYPHS;
    int prefix_x;
    int prefix_end;
    int pos;
    SIZE size;
    HPEN hpen;
    HPEN oldPen;
    HRESULT hr = S_FALSE;
 
    if (offset == -1)
        return;
 
    if (ScriptIsComplex(str, count, SIC_COMPLEX) == S_OK)
    {
        if (GetLayout(hdc) & LAYOUT_RTL || GetTextAlign(hdc) & TA_RTLREADING)
            dwSSAFlags |= SSA_RTL;
 
        hr = ScriptStringAnalyse(hdc, str, count, (3 * count / 2 + 16),
                                 -1, dwSSAFlags, -1, NULL, NULL, NULL, NULL, NULL, &ssa);
    }
 
    if (hr == S_OK)
    {
        ScriptStringCPtoX(ssa, offset, FALSE, &pos);
        prefix_x = x + pos;
        ScriptStringCPtoX(ssa, offset, TRUE, &pos);
        prefix_end = x + pos;
        ScriptStringFree(&ssa);
    }
    else
    {
        GetTextExtentPointW(hdc, str, offset, &size);
        prefix_x = x + size.cx;
        GetTextExtentPointW(hdc, str, 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, NULL);
    LineTo(hdc, prefix_end, y);
    SelectObject(hdc, oldPen);
    DeleteObject(hpen);
}

Referenced by LpkPSMTextOut().

LpkDllInitialize()

BOOL WINAPI LpkDllInitialize	(	_In_ HANDLE	hDll,
		_In_ ULONG	dwReason,
		_In_opt_ PVOID	pReserved
	)

Definition at line 211 of file lpk.c.

{
    UNREFERENCED_PARAMETER(pReserved);
 
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hDll);
            /* Tell usp10 it is activated usp10 */
            //LpkPresent();
            LPK_ApplyMirroring();
            break;
 
        default:
            break;
    }
 
    return TRUE;
}

LpkExtTextOut()

BOOL WINAPI LpkExtTextOut	(	HDC	hdc,
		int	x,
		int	y,
		UINT	fuOptions,
		const RECT *	lprc,
		LPCWSTR	lpString,
		UINT	uCount,
		const INT *	lpDx,
		INT	unknown
	)

Definition at line 240 of file lpk.c.

{
    LPWORD glyphs = NULL;
    LPWSTR reordered_str = NULL;
    INT cGlyphs;
    DWORD dwSICFlags = SIC_COMPLEX;
    BOOL bResult, bReorder;
 
    UNREFERENCED_PARAMETER(unknown);
 
    fuOptions |= ETO_IGNORELANGUAGE;
 
    /* Check text direction */
    if ((GetLayout(hdc) & LAYOUT_RTL) || (GetTextAlign(hdc) & TA_RTLREADING))
        fuOptions |= ETO_RTLREADING;
 
    /* If text direction is RTL change flag to account neutral characters */
    if (fuOptions & ETO_RTLREADING)
        dwSICFlags |= SIC_NEUTRAL;
 
    /* Check if the string requires complex script processing and not a "glyph indices" array */
    if (ScriptIsComplex(lpString, uCount, dwSICFlags) == S_OK && !(fuOptions & ETO_GLYPH_INDEX))
    {
        /* reordered_str is used as fallback in case the glyphs array fails to generate,
           BIDI_Reorder() doesn't attempt to write into reordered_str if memory allocation fails */
        reordered_str = HeapAlloc(GetProcessHeap(), 0, uCount * sizeof(WCHAR));
 
        bReorder = BIDI_Reorder(hdc, lpString, uCount, GCP_REORDER,
                                (fuOptions & ETO_RTLREADING) ? WINE_GCPW_FORCE_RTL : WINE_GCPW_FORCE_LTR,
                                reordered_str, uCount, NULL, &glyphs, &cGlyphs);
 
        /* Now display the reordered text if any of the arrays is valid and if BIDI_Reorder() succeeded */
        if ((glyphs || reordered_str) && bReorder)
        {
            if (glyphs)
            {
                fuOptions |= ETO_GLYPH_INDEX;
                uCount = cGlyphs;
            }
 
            bResult = ExtTextOutW(hdc, x, y, fuOptions, lprc,
                                  glyphs ? (LPWSTR)glyphs : reordered_str, uCount, lpDx);
        }
        else
        {
            WARN("BIDI_Reorder failed, falling back to original string.\n");
            bResult = ExtTextOutW(hdc, x, y, fuOptions, lprc, lpString, uCount, lpDx);
        }
 
        HeapFree(GetProcessHeap(), 0, glyphs);
        HeapFree(GetProcessHeap(), 0, reordered_str);
 
        return bResult;
    }
 
    return ExtTextOutW(hdc, x, y, fuOptions, lprc, lpString, uCount, lpDx);
}

LpkGetCharacterPlacement()

DWORD WINAPI LpkGetCharacterPlacement	(	HDC	hdc,
		LPCWSTR	lpString,
		INT	uCount,
		INT	nMaxExtent,
		LPGCP_RESULTSW	lpResults,
		DWORD	dwFlags,
		DWORD	dwUnused
	)

Definition at line 312 of file lpk.c.

{
    DWORD ret = 0;
    HRESULT hr;
    SCRIPT_STRING_ANALYSIS ssa;
    LPWORD lpGlyphs = NULL;
    SIZE size;
    UINT nSet, i;
    INT cGlyphs;
 
    UNREFERENCED_PARAMETER(dwUnused);
 
    /* Sanity check (most likely a direct call) */
    if (!(dwFlags & GCP_REORDER))
       return GetCharacterPlacementW(hdc, lpString, uCount, nMaxExtent, lpResults, dwFlags);
 
    nSet = (UINT)uCount;
    if (nSet > lpResults->nGlyphs)
        nSet = lpResults->nGlyphs;
 
    BIDI_Reorder(hdc, lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
                 nSet, lpResults->lpOrder, &lpGlyphs, &cGlyphs);
 
    lpResults->nGlyphs = (UINT)cGlyphs;
 
    if (lpResults->lpGlyphs)
    {
        if (lpGlyphs)
            StringCchCopyW(lpResults->lpGlyphs, cGlyphs, lpGlyphs);
        else if (lpResults->lpOutString)
            GetGlyphIndicesW(hdc, lpResults->lpOutString, nSet, lpResults->lpGlyphs, 0);
    }
 
    if (lpResults->lpDx)
    {
        int c;
 
        /* If glyph shaping was requested */
        if (dwFlags & GCP_GLYPHSHAPE)
        {
            if (lpResults->lpGlyphs)
            {
                for (i = 0; i < lpResults->nGlyphs; i++)
                {
                    if (GetCharWidthI(hdc, 0, 1, (WORD *)&lpResults->lpGlyphs[i], &c))
                        lpResults->lpDx[i] = c;
                }
            }
        }
 
        else
        {
            for (i = 0; i < nSet; i++)
            {
                if (GetCharWidth32W(hdc, lpResults->lpOutString[i], lpResults->lpOutString[i], &c))
                    lpResults->lpDx[i] = c;
            }
        }
    }
 
    if (lpResults->lpCaretPos)
    {
        int pos = 0;
 
        hr = ScriptStringAnalyse(hdc, lpString, nSet, (3 * nSet / 2 + 16), -1, SSA_GLYPHS, -1,
                                 NULL, NULL, NULL, NULL, NULL, &ssa);
        if (hr == S_OK)
        {
            for (i = 0; i < nSet; i++)
            {
                if (ScriptStringCPtoX(ssa, i, FALSE, &pos) == S_OK)
                    lpResults->lpCaretPos[i] = pos;
            }
            ScriptStringFree(&ssa);
        }
        else
        {
            lpResults->lpCaretPos[0] = 0;
            for (i = 1; i < nSet; i++)
            {
                if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
                    lpResults->lpCaretPos[i] = (pos += size.cx);
            }
        }
    }
 
    if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
        ret = MAKELONG(size.cx, size.cy);
 
    HeapFree(GetProcessHeap(), 0, lpGlyphs);
 
    return ret;
}

LpkGetTextExtentExPoint()

BOOL WINAPI LpkGetTextExtentExPoint	(	HDC	hdc,
		LPCWSTR	lpString,
		INT	cString,
		INT	nMaxExtent,
		LPINT	lpnFit,
		LPINT	lpnDx,
		LPSIZE	lpSize,
		DWORD	dwUnused,
		int	unknown
	)

Definition at line 472 of file lpk.c.

{
    SCRIPT_STRING_ANALYSIS ssa;
    HRESULT hr;
    INT i, extent, *Dx;
    TEXTMETRICW tm;
 
    UNREFERENCED_PARAMETER(dwUnused);
    UNREFERENCED_PARAMETER(unknown);
 
    if (cString < 0 || !lpSize)
        return FALSE;
 
    if (cString == 0 || !lpString)
    {
        lpSize->cx = 0;
        lpSize->cy = 0;
        return TRUE;
    }
 
    /* Check if any processing is required */
    if (ScriptIsComplex(lpString, cString, SIC_COMPLEX) != S_OK)
        goto fallback;
 
    hr = ScriptStringAnalyse(hdc, lpString, cString, 3 * cString / 2 + 16, -1,
                             SSA_GLYPHS, 0, NULL, NULL, NULL, NULL, NULL, &ssa);
    if (hr != S_OK)
        goto fallback;
 
    /* Use logic from TextIntGetTextExtentPoint() */
    Dx = HeapAlloc(GetProcessHeap(), 0, cString * sizeof(INT));
    if (!Dx)
    {
        ScriptStringFree(&ssa);
        goto fallback;
    }
 
    if (lpnFit)
        *lpnFit = 0;
 
    ScriptStringGetLogicalWidths(ssa, Dx);
 
    for (i = 0, extent = 0; i < cString; i++)
    {
        extent += Dx[i];
 
        if (extent <= nMaxExtent && lpnFit)
            *lpnFit = i + 1;
 
        if (lpnDx)
            lpnDx[i] = extent;
    }
 
    HeapFree(GetProcessHeap(), 0, Dx);
    ScriptStringFree(&ssa);
 
    if (!GetTextMetricsW(hdc, &tm))
        return GetTextExtentExPointWPri(hdc, lpString, cString, 0, NULL, NULL, lpSize);
 
    lpSize->cx = extent;
    lpSize->cy = tm.tmHeight;
 
    return TRUE;
 
fallback:
    return GetTextExtentExPointWPri(hdc, lpString, cString, nMaxExtent, lpnFit, lpnDx, lpSize);
}

LpkPSMTextOut()

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

Definition at line 427 of file lpk.c.

{
    SIZE size;
    TEXTMETRICW tm;
    int prefix_offset, len;
    LPWSTR display_str = NULL;
 
    if (!lpString || cString <= 0)
        return 0;
 
    if (dwFlags & DT_NOPREFIX)
    {
        LpkExtTextOut(hdc, x, y, 0, NULL, lpString, cString, NULL, 0);
        GetTextExtentPointW(hdc, lpString, cString, &size);
        return size.cx;
    }
 
    display_str = HeapAlloc(GetProcessHeap(), 0, (cString + 1) * sizeof(WCHAR));
 
    if (!display_str)
        return 0;
 
    PSM_PrepareToDraw(lpString, cString, display_str, &len);
 
    if (!(dwFlags & DT_PREFIXONLY))
        LpkExtTextOut(hdc, x, y, 0, NULL, display_str, len, NULL, 0);
 
    if (!(dwFlags & DT_HIDEPREFIX))
    {
        prefix_offset = PSM_FindLastPrefix(lpString, cString);
        GetTextMetricsW(hdc, &tm);
        LPK_DrawUnderscore(hdc, x, y + tm.tmAscent + 1, display_str, len, prefix_offset);
    }
 
    GetTextExtentPointW(hdc, display_str, len + 1, &size);
    HeapFree(GetProcessHeap(), 0, display_str);
 
    return size.cx;
}

Referenced by DrawTest().

PSM_FindLastPrefix()

static int PSM_FindLastPrefix ( LPCWSTR  str, int  count  )

static

Definition at line 22 of file lpk.c.

{
    int i, prefix_count = 0, index = -1;
 
    for (i = 0; i < count - 1; i++)
    {
        if (str[i] == PREFIX && str[i + 1] != PREFIX)
        {
            index = i - prefix_count;
            prefix_count++;
        }
        else if (str[i] == PREFIX && str[i + 1] == PREFIX)
        {
            i++;
        }
    }
    return index;
}

Referenced by LpkPSMTextOut().

PSM_PrepareToDraw()

static void PSM_PrepareToDraw ( LPCWSTR  str, INT  count, LPWSTR  new_str, LPINT  new_count  )

static

Definition at line 41 of file lpk.c.

{
    int len, i = 0, j = 0;
 
    while (i < count)
    {
        if (str[i] == PREFIX || (iswspace(str[i]) && str[i] != L' '))
        {
            if (i < count - 1 && str[i + 1] == PREFIX)
                new_str[j++] = str[i++];
            else
                i++;
        }
        else
        {
            new_str[j++] = str[i++];
        }
    }
 
    new_str[j] = L'\0';
    len = wcslen(new_str);
    *new_count = len;
}

Referenced by LpkPSMTextOut().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

bidi

)

Variable Documentation

LpkEditControl

LPK_LPEDITCONTROL_LIST LpkEditControl

Initial value:

= {EditCreate,       EditIchToXY,  EditMouseToIch, EditCchInWidth,
                                         EditGetLineWidth, EditDrawText, EditHScroll,    EditMoveSelection,
                                         EditVerifyText,   EditNextWord, EditSetMenu,    EditProcessMenu,
                                         EditCreateCaret, EditAdjustCaret}

Definition at line 13 of file lpk.c.