system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-07 09:08:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

user32: Use wide character string literals.

Browse source 
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Alexandre Julliard 2020-09-21 16:31:11 +02:00
parent 9cc9236556
commit 5ad25c293b
30 changed files with 198 additions and 405 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
dlls/user32/button.c
View file

@ -121,10 +121,9 @@ static const pfPaint btnPaintFunc[MAX_BTN_TYPE] =
/*********************************************************************
* button class descriptor
*/
static const WCHAR buttonW[] = {'B','u','t','t','o','n',0};
const struct builtin_class_descr BUTTON_builtin_class =
{
buttonW, /* name */
L"Button", /* name */
CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC, /* style */
WINPROC_BUTTON, /* proc */
NB_EXTRA_BYTES, /* extra */

55
dlls/user32/class.c
View file

@ -123,28 +123,28 @@ ATOM get_int_atom_value( LPCWSTR name )
*/
static BOOL is_comctl32_class( const WCHAR *name )
{
static const WCHAR classesW[][20] =
static const WCHAR *classesW[] =
{
{'C','o','m','b','o','B','o','x','E','x','3','2',0},
{'m','s','c','t','l','s','_','h','o','t','k','e','y','3','2',0},
{'m','s','c','t','l','s','_','p','r','o','g','r','e','s','s','3','2',0},
{'m','s','c','t','l','s','_','s','t','a','t','u','s','b','a','r','3','2',0},
{'m','s','c','t','l','s','_','t','r','a','c','k','b','a','r','3','2',0},
{'m','s','c','t','l','s','_','u','p','d','o','w','n','3','2',0},
{'N','a','t','i','v','e','F','o','n','t','C','t','l',0},
{'R','e','B','a','r','W','i','n','d','o','w','3','2',0},
{'S','y','s','A','n','i','m','a','t','e','3','2',0},
{'S','y','s','D','a','t','e','T','i','m','e','P','i','c','k','3','2',0},
{'S','y','s','H','e','a','d','e','r','3','2',0},
{'S','y','s','I','P','A','d','d','r','e','s','s','3','2',0},
{'S','y','s','L','i','n','k',0},
{'S','y','s','L','i','s','t','V','i','e','w','3','2',0},
{'S','y','s','M','o','n','t','h','C','a','l','3','2',0},
{'S','y','s','P','a','g','e','r',0},
{'S','y','s','T','a','b','C','o','n','t','r','o','l','3','2',0},
{'S','y','s','T','r','e','e','V','i','e','w','3','2',0},
{'T','o','o','l','b','a','r','W','i','n','d','o','w','3','2',0},
{'t','o','o','l','t','i','p','s','_','c','l','a','s','s','3','2',0},
L"ComboBoxEx32",
L"msctls_hotkey32",
L"msctls_progress32",
L"msctls_statusbar32",
L"msctls_trackbar32",
L"msctls_updown32",
L"NativeFontCtl",
L"ReBarWindow32",
L"SysAnimate32",
L"SysDateTimePick32",
L"SysHeader32",
L"SysIPAddress32",
L"SysLink",
L"SysListView32",
L"SysMonthCal32",
L"SysPager",
L"SysTabControl32",
L"SysTreeView32",
L"ToolbarWindow32",
L"tooltips_class32",
};
int min = 0, max = ARRAY_SIZE( classesW ) - 1;
@ -161,11 +161,11 @@ static BOOL is_comctl32_class( const WCHAR *name )
static BOOL is_builtin_class( const WCHAR *name )
{
static const WCHAR classesW[][20] =
static const WCHAR *classesW[] =
{
{'I','M','E',0},
{'M','D','I','C','l','i','e','n','t',0},
{'S','c','r','o','l','l','b','a','r',0},
L"IME",
L"MDIClient",
L"Scrollbar",
};
int min = 0, max = ARRAY_SIZE( classesW ) - 1;
@ -408,7 +408,6 @@ const WCHAR *CLASS_GetVersionedName( const WCHAR *name, UINT *basename_offset, W
*/
static CLASS *CLASS_FindClass( LPCWSTR name, HINSTANCE hinstance )
{
static const WCHAR comctl32W[] = {'c','o','m','c','t','l','3','2','.','d','l','l',0};
struct list *ptr;
ATOM atom = get_int_atom_value( name );
@ -443,8 +442,8 @@ static CLASS *CLASS_FindClass( LPCWSTR name, HINSTANCE hinstance )
if (atom) break;
if (!is_comctl32_class( name )) break;
if (GetModuleHandleW( comctl32W )) break;
if (!LoadLibraryW( comctl32W )) break;
if (GetModuleHandleW( L"comctl32.dll" )) break;
if (!LoadLibraryW( L"comctl32.dll" )) break;
TRACE( "%s retrying after loading comctl32\n", debugstr_w(name) );
}

25
dlls/user32/combo.c
View file

@ -80,10 +80,9 @@ static void CBResetPos(HEADCOMBO *combo, BOOL redraw);
/*********************************************************************
* combo class descriptor
*/
static const WCHAR comboboxW[] = {'C','o','m','b','o','B','o','x',0};
const struct builtin_class_descr COMBO_builtin_class =
{
comboboxW, /* name */
L"ComboBox", /* name */
CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, /* style */
WINPROC_COMBO, /* proc */
sizeof(HEADCOMBO *), /* extra */
@ -412,9 +411,6 @@ static void CBGetDroppedControlRect( LPHEADCOMBO lphc, LPRECT lpRect)
static LRESULT COMBO_Create( HWND hwnd, LPHEADCOMBO lphc, HWND hwndParent, LONG style,
BOOL unicode )
{
static const WCHAR clbName[] = {'C','o','m','b','o','L','B','o','x',0};
static const WCHAR editName[] = {'E','d','i','t',0};
if( !CB_GETTYPE(lphc) ) lphc->dwStyle |= CBS_SIMPLE;
if( CB_GETTYPE(lphc) != CBS_DROPDOWNLIST ) lphc->wState |= CBF_EDIT;
@ -495,7 +491,7 @@ static LRESULT COMBO_Create( HWND hwnd, LPHEADCOMBO lphc, HWND hwndParent, LONG
}
if (unicode)
lphc->hWndLBox = CreateWindowExW(lbeExStyle, clbName, NULL, lbeStyle,
lphc->hWndLBox = CreateWindowExW(lbeExStyle, L"ComboLBox", NULL, lbeStyle,
lphc->droppedRect.left,
lphc->droppedRect.top,
lphc->droppedRect.right - lphc->droppedRect.left,
@ -530,7 +526,7 @@ static LRESULT COMBO_Create( HWND hwnd, LPHEADCOMBO lphc, HWND hwndParent, LONG
if (!IsWindowEnabled(hwnd)) lbeStyle |= WS_DISABLED;
if (unicode)
lphc->hWndEdit = CreateWindowExW(0, editName, NULL, lbeStyle,
lphc->hWndEdit = CreateWindowExW(0, L"Edit", NULL, lbeStyle,
lphc->textRect.left, lphc->textRect.top,
lphc->textRect.right - lphc->textRect.left,
lphc->textRect.bottom - lphc->textRect.top,
@ -678,8 +674,7 @@ static void CBPaintText(
if( lphc->wState & CBF_EDIT )
{
static const WCHAR empty_stringW[] = { 0 };
if( CB_HASSTRINGS(lphc) ) SetWindowTextW( lphc->hWndEdit, pText ? pText : empty_stringW );
if( CB_HASSTRINGS(lphc) ) SetWindowTextW( lphc->hWndEdit, pText ? pText : L"" );
if( lphc->wState & CBF_FOCUSED )
SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, MAXLONG);
}
@ -735,8 +730,6 @@ static void CBPaintText(
}
else
{
static const WCHAR empty_stringW[] = { 0 };
if ( (lphc->wState & CBF_FOCUSED) &&
!(lphc->wState & CBF_DROPPED) ) {
@ -751,7 +744,7 @@ static void CBPaintText(
rectEdit.top + 1,
ETO_OPAQUE | ETO_CLIPPED,
&rectEdit,
pText ? pText : empty_stringW , size, NULL );
pText ? pText : L"" , size, NULL );
if(lphc->wState & CBF_FOCUSED && !(lphc->wState & CBF_DROPPED))
DrawFocusRect( hdc, &rectEdit );
@ -890,7 +883,6 @@ static void CBUpdateEdit( LPHEADCOMBO lphc , INT index )
{
INT length;
LPWSTR pText = NULL;
static const WCHAR empty_stringW[] = { 0 };
TRACE("\t %i\n", index );
@ -909,7 +901,7 @@ static void CBUpdateEdit( LPHEADCOMBO lphc , INT index )
if( CB_HASSTRINGS(lphc) )
{
lphc->wState |= (CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, pText ? (LPARAM)pText : (LPARAM)empty_stringW);
SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, pText ? (LPARAM)pText : (LPARAM)L"");
lphc->wState &= ~(CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
}
@ -2012,10 +2004,7 @@ LRESULT ComboWndProc_common( HWND hwnd, UINT message, WPARAM wParam, LPARAM lPar
case CB_RESETCONTENT:
SendMessageW(lphc->hWndLBox, LB_RESETCONTENT, 0, 0);
if( (lphc->wState & CBF_EDIT) && CB_HASSTRINGS(lphc) )
{
static const WCHAR empty_stringW[] = { 0 };
SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)empty_stringW);
}
SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)L"");
else
InvalidateRect(lphc->self, NULL, TRUE);
return TRUE;

2
dlls/user32/dde_client.c
View file

@ -40,7 +40,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
static LRESULT CALLBACK WDML_ClientProc(HWND, UINT, WPARAM, LPARAM); /* only for one client, not conv list */
const char WDML_szClientConvClassA[] = "WineDdeClientA";
const WCHAR WDML_szClientConvClassW[] = {'W','i','n','e','D','d','e','C','l','i','e','n','t','W',0};
const WCHAR WDML_szClientConvClassW[] = L"WineDdeClientW";
/******************************************************************************
* DdeConnectList [USER32.@] Establishes conversation with DDE servers

5
dlls/user32/dde_misc.c
View file

@ -44,7 +44,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
static WDML_INSTANCE* WDML_InstanceList = NULL;
static LONG WDML_MaxInstanceID = 0; /* OK for present, have to worry about wrap-around later */
const WCHAR WDML_szEventClass[] = {'W','i','n','e','D','d','e','E','v','e','n','t','C','l','a','s','s',0};
const WCHAR WDML_szEventClass[] = L"WineDdeEventClass";
/* protection for instance list */
static CRITICAL_SECTION WDML_CritSect;
@ -1646,7 +1646,6 @@ HGLOBAL WDML_DataHandle2Global(HDDEDATA hDdeData, BOOL fResponse, BOOL fRelease,
*/
WDML_SERVER* WDML_AddServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
{
static const WCHAR fmtW[] = {'%','s','(','0','x','%','*','x',')',0};
WDML_SERVER* pServer;
WCHAR buf1[256];
WCHAR buf2[256];
@ -1658,7 +1657,7 @@ WDML_SERVER* WDML_AddServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTop
WDML_IncHSZ(pInstance, hszService);
DdeQueryStringW(pInstance->instanceID, hszService, buf1, 256, CP_WINUNICODE);
swprintf(buf2, 256, fmtW, buf1, 2*sizeof(ULONG_PTR), GetCurrentProcessId());
swprintf(buf2, 256, L"%s(0x%*x)", buf1, 2*sizeof(ULONG_PTR), GetCurrentProcessId());
pServer->hszServiceSpec = DdeCreateStringHandleW(pInstance->instanceID, buf2, CP_WINUNICODE);
pServer->atomService = WDML_MakeAtomFromHsz(pServer->hszService);

10
dlls/user32/dde_server.c
View file

@ -39,9 +39,8 @@
WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
static const WCHAR szServerNameClass[] = {'W','i','n','e','D','d','e','S','e','r','v','e','r','N','a','m','e',0};
const char WDML_szServerConvClassA[] = "WineDdeServerConvA";
const WCHAR WDML_szServerConvClassW[] = {'W','i','n','e','D','d','e','S','e','r','v','e','r','C','o','n','v','W',0};
const WCHAR WDML_szServerConvClassW[] = L"WineDdeServerConvW";
static LRESULT CALLBACK WDML_ServerNameProc(HWND, UINT, WPARAM, LPARAM);
static LRESULT CALLBACK WDML_ServerConvProc(HWND, UINT, WPARAM, LPARAM);
@ -230,15 +229,12 @@ HDDEDATA WINAPI DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
wndclass.hCursor = 0;
wndclass.hbrBackground = 0;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = szServerNameClass;
wndclass.lpszClassName = L"WineDdeServerName";
wndclass.hIconSm = 0;
RegisterClassExW(&wndclass);
hwndServer = CreateWindowW(szServerNameClass, NULL,
WS_POPUP, 0, 0, 0, 0,
0, 0, 0, 0);
hwndServer = CreateWindowW(L"WineDdeServerName", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
SetWindowLongPtrW(hwndServer, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
SetWindowLongPtrW(hwndServer, GWL_WDML_SERVER, (ULONG_PTR)pServer);
TRACE("Created nameServer=%p for instance=%08x\n", hwndServer, idInst);

3
dlls/user32/defwnd.c
View file

@ -123,7 +123,6 @@ static LRESULT DEFWND_SetTextA( HWND hwnd, LPCSTR text )
*/
static LRESULT DEFWND_SetTextW( HWND hwnd, LPCWSTR text )
{
static const WCHAR empty_string[] = {0};
WND *wndPtr;
int count;
@ -132,7 +131,7 @@ static LRESULT DEFWND_SetTextW( HWND hwnd, LPCWSTR text )
if (text && IS_INTRESOURCE(text))
return 0;
if (!text) text = empty_string;
if (!text) text = L"";
count = lstrlenW(text) + 1;
if (!(wndPtr = WIN_GetPtr( hwnd ))) return 0;

12
dlls/user32/desktop.c
View file

@ -92,13 +92,6 @@ static void init_wallpaper( const WCHAR *wallpaper )
*/
LRESULT WINAPI DesktopWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
static const WCHAR display_device_guid_propW[] = {
'_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
'd','e','v','i','c','e','_','g','u','i','d',0 };
static const WCHAR guid_formatW[] = {
'%','0','8','x','-','%','0','4','x','-','%','0','4','x','-','%','0','2','x','%','0','2','x','-',
'%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',0};
switch (message)
{
case WM_NCCREATE:
@ -113,11 +106,12 @@ LRESULT WINAPI DesktopWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lP
if (GetAncestor( hwnd, GA_PARENT )) return FALSE; /* refuse to create non-desktop window */
swprintf( buffer, ARRAY_SIZE(buffer), guid_formatW, guid->Data1, guid->Data2, guid->Data3,
swprintf( buffer, ARRAY_SIZE(buffer), L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
guid->Data1, guid->Data2, guid->Data3,
guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
atom = GlobalAddAtomW( buffer );
SetPropW( hwnd, display_device_guid_propW, ULongToHandle( atom ) );
SetPropW( hwnd, L"__wine_display_device_guid", ULongToHandle( atom ) );
}
return TRUE;
}

18
dlls/user32/dialog.c
View file

@ -139,14 +139,14 @@ static const WORD *DIALOG_GetControl32( const WORD *p, DLG_CONTROL_INFO *info,
if (GET_WORD(p) == 0xffff)
{
static const WCHAR class_names[6][10] =
static const WCHAR *class_names[6] =
{
{ 'B','u','t','t','o','n', }, /* 0x80 */
{ 'E','d','i','t', }, /* 0x81 */
{ 'S','t','a','t','i','c', }, /* 0x82 */
{ 'L','i','s','t','B','o','x', }, /* 0x83 */
{ 'S','c','r','o','l','l','B','a','r', }, /* 0x84 */
{ 'C','o','m','b','o','B','o','x', } /* 0x85 */
L"Button", /* 0x80 */
L"Edit", /* 0x81 */
L"Static", /* 0x82 */
L"ListBox", /* 0x83 */
L"ScrollBar", /* 0x84 */
L"ComboBox" /* 0x85 */
};
WORD id = GET_WORD(p+1);
/* Windows treats dialog control class ids 0-5 same way as 0x80-0x85 */
@ -1816,8 +1816,8 @@ static INT DIALOG_DlgDirListW( HWND hDlg, LPWSTR spec, INT idLBox,
{
HWND hwnd;
LPWSTR orig_spec = spec;
WCHAR any[] = {'*','.','*',0};
WCHAR star[] = {'*',0};
WCHAR any[] = L"*.*";
WCHAR star[] = L"*";
#define SENDMSG(msg,wparam,lparam) \
((attrib & DDL_POSTMSGS) ? PostMessageW( hwnd, msg, wparam, lparam ) \

26
dlls/user32/driver.c
View file

@ -45,22 +45,11 @@ static BOOL CDECL nodrv_CreateWindow( HWND hwnd );
static BOOL load_desktop_driver( HWND hwnd, HMODULE *module )
{
static const WCHAR display_device_guid_propW[] = {
'_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
'd','e','v','i','c','e','_','g','u','i','d',0 };
static const WCHAR key_pathW[] = {
'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'V','i','d','e','o','\\','{',0};
static const WCHAR displayW[] = {'}','\\','0','0','0','0',0};
static const WCHAR driverW[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0};
static const WCHAR nullW[] = {'n','u','l','l',0};
BOOL ret = FALSE;
HKEY hkey;
DWORD size;
WCHAR path[MAX_PATH];
WCHAR key[ARRAY_SIZE(key_pathW) + ARRAY_SIZE(displayW) + 40];
WCHAR key[ARRAY_SIZE(L"System\\CurrentControlSet\\Control\\Video\\{}\\0000") + 40];
UINT guid_atom;
USER_CheckNotLock();
@ -68,15 +57,15 @@ static BOOL load_desktop_driver( HWND hwnd, HMODULE *module )
strcpy( driver_load_error, "The explorer process failed to start." ); /* default error */
SendMessageW( hwnd, WM_NULL, 0, 0 ); /* wait for the desktop process to be ready */
guid_atom = HandleToULong( GetPropW( hwnd, display_device_guid_propW ));
memcpy( key, key_pathW, sizeof(key_pathW) );
guid_atom = HandleToULong( GetPropW( hwnd, L"__wine_display_device_guid" ));
lstrcpyW( key, L"System\\CurrentControlSet\\Control\\Video\\{" );
if (!GlobalGetAtomNameW( guid_atom, key + lstrlenW(key), 40 )) return 0;
lstrcatW( key, displayW );
lstrcatW( key, L"}\\0000" );
if (RegOpenKeyW( HKEY_LOCAL_MACHINE, key, &hkey )) return 0;
size = sizeof(path);
if (!RegQueryValueExW( hkey, driverW, NULL, NULL, (BYTE *)path, &size ))
if (!RegQueryValueExW( hkey, L"GraphicsDriver", NULL, NULL, (BYTE *)path, &size ))
{
if ((ret = !wcscmp( path, nullW ))) *module = NULL;
if ((ret = !wcscmp( path, L"null" ))) *module = NULL;
else ret = (*module = LoadLibraryW( path )) != NULL;
if (!ret) ERR( "failed to load %s\n", debugstr_w(path) );
TRACE( "%s %p\n", debugstr_w(path), *module );
@ -214,7 +203,6 @@ static UINT CDECL nulldrv_GetKeyboardLayoutList( INT size, HKL *layouts )
INT count = 0;
ULONG_PTR baselayout;
LANGID langid;
static const WCHAR szKeyboardReg[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s',0};
baselayout = GetUserDefaultLCID();
langid = PRIMARYLANGID(LANGIDFROMLCID(baselayout));
@ -224,7 +212,7 @@ static UINT CDECL nulldrv_GetKeyboardLayoutList( INT size, HKL *layouts )
baselayout |= baselayout << 16;
/* Enumerate the Registry */
rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,szKeyboardReg,&hKeyKeyboard);
rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,L"System\\CurrentControlSet\\Control\\Keyboard Layouts",&hKeyKeyboard);
if (rc == ERROR_SUCCESS)
{
do {

9
dlls/user32/edit.c
View file

@ -3193,18 +3193,16 @@ static LRESULT EDIT_WM_Char(EDITSTATE *es, WCHAR c)
EDIT_MoveHome(es, FALSE, FALSE);
EDIT_MoveDown_ML(es, FALSE);
} else {
static const WCHAR cr_lfW[] = {'\r','\n'};
EDIT_EM_ReplaceSel(es, TRUE, cr_lfW, 2, TRUE, TRUE);
EDIT_EM_ReplaceSel(es, TRUE, L"\r\n", 2, TRUE, TRUE);
}
}
break;
case '\t':
if ((es->style & ES_MULTILINE) && !(es->style & ES_READONLY))
{
static const WCHAR tabW[] = {'\t'};
if (EDIT_IsInsideDialog(es))
break;
EDIT_EM_ReplaceSel(es, TRUE, tabW, 1, TRUE, TRUE);
EDIT_EM_ReplaceSel(es, TRUE, L"\t", 1, TRUE, TRUE);
}
break;
case VK_BACK:
@ -5250,10 +5248,9 @@ LRESULT EditWndProc_common( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, B
/*********************************************************************
* edit class descriptor
*/
static const WCHAR editW[] = {'E','d','i','t',0};
const struct builtin_class_descr EDIT_builtin_class =
{
editW, /* name */
L"Edit", /* name */
CS_DBLCLKS | CS_PARENTDC, /* style */
WINPROC_EDIT, /* proc */
#ifdef __i386__

3
dlls/user32/icontitle.c
View file

@ -50,7 +50,6 @@ const struct builtin_class_descr ICONTITLE_builtin_class =
*/
static BOOL ICONTITLE_SetTitlePos( HWND hwnd, HWND owner )
{
static const WCHAR emptyTitleText[] = {'<','.','.','.','>',0};
WCHAR str[80];
HDC hDC;
HFONT hPrevFont;
@ -65,7 +64,7 @@ static BOOL ICONTITLE_SetTitlePos( HWND hwnd, HWND owner )
if( !length )
{
lstrcpyW( str, emptyTitleText );
lstrcpyW( str, L"<...>" );
length = lstrlenW( str );
}

19
dlls/user32/listbox.c
View file

@ -244,10 +244,9 @@ static void remove_item_data(LB_DESCR *descr, UINT index)
/*********************************************************************
* listbox class descriptor
*/
static const WCHAR listboxW[] = {'L','i','s','t','B','o','x',0};
const struct builtin_class_descr LISTBOX_builtin_class =
{
listboxW, /* name */
L"ListBox", /* name */
CS_DBLCLKS /*| CS_PARENTDC*/, /* style */
WINPROC_LISTBOX, /* proc */
sizeof(LB_DESCR *), /* extra */
@ -259,10 +258,9 @@ const struct builtin_class_descr LISTBOX_builtin_class =
/*********************************************************************
* combolbox class descriptor
*/
static const WCHAR combolboxW[] = {'C','o','m','b','o','L','B','o','x',0};
const struct builtin_class_descr COMBOLBOX_builtin_class =
{
combolboxW, /* name */
L"ComboLBox", /* name */
CS_DBLCLKS | CS_SAVEBITS, /* style */
WINPROC_LISTBOX, /* proc */
sizeof(LB_DESCR *), /* extra */
@ -1701,8 +1699,7 @@ static LRESULT LISTBOX_InsertString( LB_DESCR *descr, INT index, LPCWSTR str )
if (HAS_STRINGS(descr))
{
static const WCHAR empty_stringW[] = { 0 };
if (!str) str = empty_stringW;
if (!str) str = L"";
if (!(new_str = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(str) + 1) * sizeof(WCHAR) )))
{
SEND_NOTIFICATION( descr, LBN_ERRSPACE );
@ -1896,16 +1893,14 @@ static LRESULT LISTBOX_Directory( LB_DESCR *descr, UINT attrib,
WCHAR buffer[270];
if (entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
static const WCHAR bracketW[] = { ']',0 };
static const WCHAR dotW[] = { '.',0 };
if (!(attrib & DDL_DIRECTORY) ||
!wcscmp( entry.cFileName, dotW )) continue;
!wcscmp( entry.cFileName, L"." )) continue;
buffer[0] = '[';
if (!long_names && entry.cAlternateFileName[0])
lstrcpyW( buffer + 1, entry.cAlternateFileName );
else
lstrcpyW( buffer + 1, entry.cFileName );
lstrcatW(buffer, bracketW);
lstrcatW(buffer, L"]");
}
else /* not a directory */
{
@ -1937,8 +1932,8 @@ static LRESULT LISTBOX_Directory( LB_DESCR *descr, UINT attrib,
/* scan drives */
if (attrib & DDL_DRIVES)
{
WCHAR buffer[] = {'[','-','a','-',']',0};
WCHAR root[] = {'A',':','\\',0};
WCHAR buffer[] = L"[-a-]";
WCHAR root[] = L"A:\\";
int drive;
for (drive = 0; drive < 26; drive++, buffer[2]++, root[0]++)
{

10
dlls/user32/mdi.c
View file

@ -182,10 +182,9 @@ static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO* ci, WORD recalc)
/*********************************************************************
* MDIClient class descriptor
*/
static const WCHAR mdiclientW[] = {'M','D','I','C','l','i','e','n','t',0};
const struct builtin_class_descr MDICLIENT_builtin_class =
{
mdiclientW, /* name */
L"MDIClient", /* name */
0, /* style */
WINPROC_MDICLIENT, /* proc */
sizeof(MDICLIENTINFO), /* extra */
@ -993,19 +992,16 @@ static void MDI_UpdateFrameText( HWND frame, HWND hClient, BOOL repaint, LPCWSTR
if (ci->hwndChildMaximized)
{
/* combine frame title and child title if possible */
static const WCHAR lpBracket[] = {' ','-',' ','[',0};
static const WCHAR lpBracket2[] = {']',0};
int i_frame_text_length = lstrlenW(ci->frameTitle);
lstrcpynW( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
{
lstrcatW( lpBuffer, lpBracket );
lstrcatW( lpBuffer, L" - [" );
if (GetWindowTextW( ci->hwndActiveChild, lpBuffer + i_frame_text_length + 4,
MDI_MAXTITLELENGTH - i_frame_text_length - 5 ))
lstrcatW( lpBuffer, lpBracket2 );
lstrcatW( lpBuffer, L"]" );
else
lpBuffer[i_frame_text_length] = 0; /* remove bracket */
}

8
dlls/user32/menu.c
View file

@ -400,9 +400,7 @@ static inline UINT get_scroll_arrow_height(const POPUPMENU *menu)
*/
static HMENU MENU_CopySysPopup(BOOL mdi)
{
static const WCHAR sysmenuW[] = {'S','Y','S','M','E','N','U',0};
static const WCHAR sysmenumdiW[] = {'S','Y','S','M','E','N','U','M','D','I',0};
HMENU hMenu = LoadMenuW(user32_module, (mdi ? sysmenumdiW : sysmenuW));
HMENU hMenu = LoadMenuW(user32_module, mdi ? L"SYSMENUMDI" : L"SYSMENU");
if( hMenu ) {
MENUINFO minfo;
@ -979,9 +977,7 @@ static void MENU_DrawBitmapItem( HDC hdc, MENUITEM *lpitem, const RECT *rect,
/* draw the magic bitmaps using marlett font characters */
/* FIXME: fontsize and the position (x,y) could probably be better */
HFONT hfont, hfontsav;
LOGFONTW logfont = { 0, 0, 0, 0, FW_NORMAL,
0, 0, 0, SYMBOL_CHARSET, 0, 0, 0, 0,
{ 'M','a','r','l','e','t','t',0 } };
LOGFONTW logfont = { 0, 0, 0, 0, FW_NORMAL, 0, 0, 0, SYMBOL_CHARSET, 0, 0, 0, 0, L"Marlett" };
logfont.lfHeight = min( h, w) - 5 ;
TRACE(" height %d rect %s\n", logfont.lfHeight, wine_dbgstr_rect( rect));
hfont = CreateFontIndirectW( &logfont);

4
dlls/user32/message.c
View file

@ -280,11 +280,9 @@ static const INPUT_MESSAGE_SOURCE msg_source_unavailable = { IMDT_UNAVAILABLE, I
/* Message class descriptor */
static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
const struct builtin_class_descr MESSAGE_builtin_class =
{
messageW, /* name */
L"Message", /* name */
0, /* style */
WINPROC_MESSAGE, /* proc */
0, /* extra */

6
dlls/user32/misc.c
View file

@ -322,8 +322,7 @@ VOID WINAPI LoadLocalFonts(VOID)
*/
BOOL WINAPI User32InitializeImmEntryTable(DWORD magic)
{
static const WCHAR imm32_dllW[] = {'i','m','m','3','2','.','d','l','l',0};
HMODULE imm32 = GetModuleHandleW(imm32_dllW);
HMODULE imm32 = GetModuleHandleW(L"imm32.dll");
TRACE("(%x)\n", magic);
@ -531,10 +530,9 @@ BOOL WINAPI GetPointerType(UINT32 id, POINTER_INPUT_TYPE *type)
return TRUE;
}
static const WCHAR imeW[] = {'I','M','E',0};
const struct builtin_class_descr IME_builtin_class =
{
imeW, /* name */
L"IME", /* name */
0, /* style */
WINPROC_IME, /* proc */
2*sizeof(LONG_PTR), /* extra */

6
dlls/user32/msgbox.c
View file

@ -518,13 +518,11 @@ INT WINAPI MessageBoxIndirectW( LPMSGBOXPARAMSW msgbox )
int ret;
UINT i;
struct ThreadWindows threadWindows;
static const WCHAR msg_box_res_nameW[] = { 'M','S','G','B','O','X',0 };
if (!(hRes = FindResourceExW(user32_module, (LPWSTR)RT_DIALOG,
msg_box_res_nameW, msgbox->dwLanguageId)))
if (!(hRes = FindResourceExW(user32_module, (LPWSTR)RT_DIALOG, L"MSGBOX", msgbox->dwLanguageId)))
{
if (!msgbox->dwLanguageId ||
!(hRes = FindResourceExW(user32_module, (LPWSTR)RT_DIALOG, msg_box_res_nameW, LANG_NEUTRAL)))
!(hRes = FindResourceExW(user32_module, (LPWSTR)RT_DIALOG, L"MSGBOX", LANG_NEUTRAL)))
return 0;
}
if (!(tmplate = LoadResource(user32_module, hRes)))

4
dlls/user32/painting.c
View file

@ -57,8 +57,6 @@ static struct list dce_list = LIST_INIT(dce_list);
static BOOL CALLBACK dc_hook( HDC hDC, WORD code, DWORD_PTR data, LPARAM lParam );
static const WCHAR displayW[] = { 'D','I','S','P','L','A','Y',0 };
/***********************************************************************
* dump_rdw_flags
@ -225,7 +223,7 @@ static struct dce *alloc_dce(void)
struct dce *dce;
if (!(dce = HeapAlloc( GetProcessHeap(), 0, sizeof(*dce) ))) return NULL;
if (!(dce->hdc = CreateDCW( displayW, NULL, NULL, NULL )))
if (!(dce->hdc = CreateDCW( L"DISPLAY", NULL, NULL, NULL )))
{
HeapFree( GetProcessHeap(), 0, dce );
return 0;

10
dlls/user32/rawinput.c
View file

@ -645,8 +645,6 @@ UINT WINAPI GetRawInputDeviceInfoA(HANDLE device, UINT command, void *data, UINT
UINT WINAPI GetRawInputDeviceInfoW(HANDLE handle, UINT command, void *data, UINT *data_size)
{
/* FIXME: Most of this is made up. */
static const WCHAR keyboard_name[] = {'\\','\\','?','\\','W','I','N','E','_','K','E','Y','B','O','A','R','D',0};
static const WCHAR mouse_name[] = {'\\','\\','?','\\','W','I','N','E','_','M','O','U','S','E',0};
static const RID_DEVICE_INFO_KEYBOARD keyboard_info = {0, 0, 1, 12, 3, 101};
static const RID_DEVICE_INFO_MOUSE mouse_info = {1, 5, 0, FALSE};
@ -673,13 +671,13 @@ UINT WINAPI GetRawInputDeviceInfoW(HANDLE handle, UINT command, void *data, UINT
avail_bytes = *data_size * sizeof(WCHAR);
if (handle == WINE_MOUSE_HANDLE)
{
*data_size = ARRAY_SIZE(mouse_name);
to_copy = mouse_name;
*data_size = ARRAY_SIZE(L"\\\\?\\WINE_MOUSE");
to_copy = L"\\\\?\\WINE_MOUSE";
}
else if (handle == WINE_KEYBOARD_HANDLE)
{
*data_size = ARRAY_SIZE(keyboard_name);
to_copy = keyboard_name;
*data_size = ARRAY_SIZE(L"\\\\?\\WINE_KEYBOARD");
to_copy = L"\\\\?\\WINE_KEYBOARD";
}
else
{

3
dlls/user32/scroll.c
View file

@ -118,10 +118,9 @@ static void SCROLL_DrawInterior_9x( HWND hwnd, HDC hdc, INT nBar,
/*********************************************************************
* scrollbar class descriptor
*/
static const WCHAR scrollbarW[] = {'S','c','r','o','l','l','B','a','r',0};
const struct builtin_class_descr SCROLL_builtin_class =
{
scrollbarW, /* name */
L"ScrollBar", /* name */
CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC, /* style */
WINPROC_SCROLLBAR, /* proc */
sizeof(SCROLLBAR_WNDDATA), /* extra */

5
dlls/user32/spy.c
View file

@ -1671,9 +1671,6 @@ static const USER_MSG propsht_array[] = {
USM(PSM_SETTITLEW ,0),
USM(PSM_SETFINISHTEXTW ,0),
};
static const WCHAR PropSheetInfoStr[] =
{'P','r','o','p','e','r','t','y','S','h','e','e','t','I','n','f','o',0 };
static const USER_MSG updown_array[] = {
USM(UDM_SETRANGE ,0),
USM(UDM_GETRANGE ,0),
@ -2145,7 +2142,7 @@ static void SPY_GetClassName( SPY_INSTANCE *sp_e )
{
/* special code to detect a property sheet dialog */
if ((GetClassLongW(sp_e->msg_hwnd, GCW_ATOM) == WC_DIALOG) &&
(GetPropW(sp_e->msg_hwnd, PropSheetInfoStr))) {
(GetPropW(sp_e->msg_hwnd, L"PropertySheetInfo"))) {
lstrcpyW(sp_e->wnd_class, WC_PROPSHEETW);
}
else {

3
dlls/user32/static.c
View file

@ -83,10 +83,9 @@ static const pfPaint staticPaintFunc[SS_TYPEMASK+1] =
/*********************************************************************
* static class descriptor
*/
static const WCHAR staticW[] = {'S','t','a','t','i','c',0};
const struct builtin_class_descr STATIC_builtin_class =
{
staticW, /* name */
L"Static", /* name */
CS_DBLCLKS | CS_PARENTDC, /* style */
WINPROC_STATIC, /* proc */
STATIC_EXTRA_BYTES, /* extra */

221
dlls/user32/sysparams.c
View file

@ -80,44 +80,19 @@ enum parameter_key
NB_PARAM_KEYS
};
static const WCHAR COLORS_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','C','o','l','o','r','s',0};
static const WCHAR DESKTOP_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
static const WCHAR KEYBOARD_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','K','e','y','b','o','a','r','d',0};
static const WCHAR MOUSE_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
static const WCHAR METRICS_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
static const WCHAR SOUND_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','S','o','u','n','d',0};
static const WCHAR VERSION_REGKEY[] = {'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'W','i','n','d','o','w','s',0};
static const WCHAR SHOWSOUNDS_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
'S','h','o','w','S','o','u','n','d','s',0};
static const WCHAR KEYBOARDPREF_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
'K','e','y','b','o','a','r','d',' ','P','r','e','f','e','r','e','n','c','e',0};
static const WCHAR SCREENREADER_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
'B','l','i','n','d',' ','A','c','c','e','s','s',0};
static const WCHAR AUDIODESC_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
'A','u','d','i','o','D','e','s','c','r','i','p','t','i','o','n',0};
static const WCHAR *parameter_key_names[NB_PARAM_KEYS] =
{
COLORS_REGKEY,
DESKTOP_REGKEY,
KEYBOARD_REGKEY,
MOUSE_REGKEY,
METRICS_REGKEY,
SOUND_REGKEY,
VERSION_REGKEY,
SHOWSOUNDS_REGKEY,
KEYBOARDPREF_REGKEY,
SCREENREADER_REGKEY,
AUDIODESC_REGKEY,
L"Control Panel\\Colors",
L"Control Panel\\Desktop",
L"Control Panel\\Keyboard",
L"Control Panel\\Mouse",
L"Control Panel\\Desktop\\WindowMetrics",
L"Control Panel\\Sound",
L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows",
L"Control Panel\\Accessibility\\ShowSounds",
L"Control Panel\\Accessibility\\Keyboard Preference",
L"Control Panel\\Accessibility\\Blind Access",
L"Control Panel\\Accessibility\\AudioDescription",
};
/* parameter key values; the first char is actually an enum parameter_key to specify the key */
@ -234,20 +209,6 @@ static const WCHAR AUDIODESC_ON_VALNAME[] = {AUDIODESC_KEY,'O','n',0}
/* FIXME - real value */
static const WCHAR SCREENSAVERRUNNING_VALNAME[]= {DESKTOP_KEY,'W','I','N','E','_','S','c','r','e','e','n','S','a','v','e','r','R','u','n','n','i','n','g',0};
static const WCHAR WINE_CURRENT_USER_REGKEY[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','e',0};
/* volatile registry branch under WINE_CURRENT_USER_REGKEY for temporary values storage */
static const WCHAR WINE_CURRENT_USER_REGKEY_TEMP_PARAMS[] = {'T','e','m','p','o','r','a','r','y',' ',
'S','y','s','t','e','m',' ',
'P','a','r','a','m','e','t','e','r','s',0};
static const WCHAR Yes[] = {'Y','e','s',0};
static const WCHAR No[] = {'N','o',0};
static const WCHAR CSu[] = {'%','u',0};
static const WCHAR CSd[] = {'%','d',0};
static const WCHAR CSrgb[] = {'%','u',' ','%','u',' ','%','u',0};
DEFINE_DEVPROPKEY(DEVPROPKEY_GPU_LUID, 0x60b193cb, 0x5276, 0x4d0f, 0x96, 0xfc, 0xf1, 0x73, 0xab, 0xad, 0x3e, 0xc6, 2);
DEFINE_DEVPROPKEY(DEVPROPKEY_MONITOR_GPU_LUID, 0xca085853, 0x16ce, 0x48aa, 0xb1, 0x14, 0xde, 0x9c, 0x72, 0x33, 0x42, 0x23, 1);
DEFINE_DEVPROPKEY(DEVPROPKEY_MONITOR_OUTPUT_ID, 0xca085853, 0x16ce, 0x48aa, 0xb1, 0x14, 0xde, 0x9c, 0x72, 0x33, 0x42, 0x23, 2);
@ -260,54 +221,6 @@ DEFINE_DEVPROPKEY(WINE_DEVPROPKEY_MONITOR_ADAPTERNAME, 0x233a9ef3, 0xafc4, 0x4ab
#define NULLDRV_DEFAULT_HMONITOR ((HMONITOR)(UINT_PTR)(0x10000 + 1))
/* Strings for monitor functions */
static const WCHAR DEFAULT_ADAPTER_NAME[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0};
static const WCHAR DEFAULT_MONITOR_NAME[] = {'\\','\\','.','\\',
'D','I','S','P','L','A','Y','1','\\',
'M','o','n','i','t','o','r','0',0};
static const WCHAR DEFAULT_ADAPTER_STRING[] = {'W','i','n','e',' ','A','d','a','p','t','e','r',0};
static const WCHAR DEFAULT_MONITOR_STRING[] = {'G','e','n','e','r','i','c',' ','N','o','n','-','P','n','P',' ','M','o','n','i','t','o','r',0};
static const WCHAR DEFAULT_ADAPTER_ID[] = {'P','C','I','\\',
'V','E','N','_','0','0','0','0','&',
'D','E','V','_','0','0','0','0','&',
'S','U','B','S','Y','S','_','0','0','0','0','0','0','0','0','&',
'R','E','V','_','0','0',0};
static const WCHAR DEFAULT_MONITOR_ID[] = {'M','O','N','I','T','O','R','\\',
'D','e','f','a','u','l','t','_','M','o','n','i','t','o','r','\\',
'{','4','d','3','6','e','9','6','e','-','e','3','2','5','-','1','1','c','e','-',
'b','f','c','1','-','0','8','0','0','2','b','e','1','0','3','1','8','}',
'\\','0','0','0','0',0};
static const WCHAR DEFAULT_MONITOR_INTERFACE_ID[] = {'\\','\\','\?','\\',
'D','I','S','P','L','A','Y','#','D','e','f','a','u','l','t','_','M','o','n','i','t','o','r','#',
'4','&','1','7','f','0','f','f','5','4','&','0','&','U','I','D','0','#',
'{','e','6','f','0','7','b','5','f','-','e','e','9','7','-','4','a','9','0','-',
'b','0','7','6','-','3','3','f','5','7','b','f','4','e','a','a','7','}',0};
static const WCHAR BACKSLASH[] = {'\\',0};
static const WCHAR DRIVER_DESC[] = {'D','r','i','v','e','r','D','e','s','c',0};
static const WCHAR STATE_FLAGS[] = {'S','t','a','t','e','F','l','a','g','s',0};
static const WCHAR GPU_ID[] = {'G','P','U','I','D',0};
static const WCHAR DISPLAY[] = {'D','I','S','P','L','A','Y',0};
static const WCHAR ADAPTER_PREFIX[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y'};
static const WCHAR MONITOR_ID_VALUE_FMT[] = {'M','o','n','i','t','o','r','I','D','%','d',0};
static const WCHAR VIDEO_KEY[] = {'H','A','R','D','W','A','R','E','\\',
'D','E','V','I','C','E','M','A','P','\\',
'V','I','D','E','O','\\',0};
static const WCHAR NT_CLASS[] = {'\\','R','e','g','i','s','t','r','y','\\',
'M','a','c','h','i','n','e','\\',
'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'C','l','a','s','s','\\',0};
static const WCHAR ADAPTER_FMT[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','%','d',0};
static const WCHAR MONITOR_FMT[] = {'\\','\\','.','\\',
'D','I','S','P','L','A','Y','%','d','\\',
'M','o','n','i','t','o','r','%','d',0};
static const WCHAR VIDEO_VALUE_FMT[] = {'\\','D','e','v','i','c','e','\\',
'V','i','d','e','o','%','d',0};
static const WCHAR MONITOR_INTERFACE_PREFIX[] = {'\\','\\','\?','\\',0};
static const WCHAR GUID_DEVINTERFACE_MONITOR[] = {'#','{','e','6','f','0','7','b','5','f','-','e','e','9','7','-',
'4','a','9','0','-','b','0','7','6','-','3','3','f','5','7','b','f','4','e','a','a','7','}',0};
/* Cached monitor information */
static MONITORINFOEXW *monitors;
static UINT monitor_count;
@ -593,10 +506,10 @@ static BOOL is_valid_adapter_name(const WCHAR *name)
long int adapter_idx;
WCHAR *end;
if (wcsnicmp(name, ADAPTER_PREFIX, ARRAY_SIZE(ADAPTER_PREFIX)))
if (wcsnicmp(name, L"\\\\.\\DISPLAY", lstrlenW(L"\\\\.\\DISPLAY")))
return FALSE;
adapter_idx = wcstol(name + ARRAY_SIZE(ADAPTER_PREFIX), &end, 10);
adapter_idx = wcstol(name + lstrlenW(L"\\\\.\\DISPLAY"), &end, 10);
if (*end || adapter_idx < 1)
return FALSE;
@ -746,9 +659,8 @@ static BOOL init_entry_string( struct sysparam_entry *entry, const WCHAR *str )
HDC get_display_dc(void)
{
static const WCHAR DISPLAY[] = {'D','I','S','P','L','A','Y',0};
EnterCriticalSection( &display_dc_section );
if (!display_dc) display_dc = CreateDCW( DISPLAY, NULL, NULL, NULL );
if (!display_dc) display_dc = CreateDCW( L"DISPLAY", NULL, NULL, NULL );
return display_dc;
}
@ -759,8 +671,7 @@ void release_display_dc( HDC hdc )
static HANDLE get_display_device_init_mutex( void )
{
static const WCHAR init_mutexW[] = {'d','i','s','p','l','a','y','_','d','e','v','i','c','e','_','i','n','i','t',0};
HANDLE mutex = CreateMutexW( NULL, FALSE, init_mutexW );
HANDLE mutex = CreateMutexW( NULL, FALSE, L"display_device_init" );
WaitForSingleObject( mutex, INFINITE );
return mutex;
@ -869,7 +780,7 @@ static BOOL set_uint_entry( union sysparam_all_entry *entry, UINT int_param, voi
{
WCHAR buf[32];
wsprintfW( buf, CSu, int_param );
wsprintfW( buf, L"%u", int_param );
if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
entry->uint.val = int_param;
entry->hdr.loaded = TRUE;
@ -881,7 +792,7 @@ static BOOL init_uint_entry( union sysparam_all_entry *entry )
{
WCHAR buf[32];
wsprintfW( buf, CSu, entry->uint.val );
wsprintfW( buf, L"%u", entry->uint.val );
return init_entry_string( &entry->hdr, buf );
}
@ -890,7 +801,7 @@ static BOOL set_int_entry( union sysparam_all_entry *entry, UINT int_param, void
{
WCHAR buf[32];
wsprintfW( buf, CSd, int_param );
wsprintfW( buf, L"%d", int_param );
if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
entry->uint.val = int_param;
entry->hdr.loaded = TRUE;
@ -902,7 +813,7 @@ static BOOL init_int_entry( union sysparam_all_entry *entry )
{
WCHAR buf[32];
wsprintfW( buf, CSd, entry->uint.val );
wsprintfW( buf, L"%d", entry->uint.val );
return init_entry_string( &entry->hdr, buf );
}
@ -964,7 +875,7 @@ static BOOL set_bool_entry( union sysparam_all_entry *entry, UINT int_param, voi
{
WCHAR buf[32];
wsprintfW( buf, CSu, int_param != 0 );
wsprintfW( buf, L"%u", int_param != 0 );
if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
entry->bool.val = int_param != 0;
entry->hdr.loaded = TRUE;
@ -976,7 +887,7 @@ static BOOL init_bool_entry( union sysparam_all_entry *entry )
{
WCHAR buf[32];
wsprintfW( buf, CSu, entry->bool.val != 0 );
wsprintfW( buf, L"%u", entry->bool.val != 0 );
return init_entry_string( &entry->hdr, buf );
}
@ -989,7 +900,7 @@ static BOOL get_yesno_entry( union sysparam_all_entry *entry, UINT int_param, vo
{
WCHAR buf[32];
if (load_entry( &entry->hdr, buf, sizeof(buf) )) entry->bool.val = !lstrcmpiW( Yes, buf );
if (load_entry( &entry->hdr, buf, sizeof(buf) )) entry->bool.val = !lstrcmpiW( L"Yes", buf );
}
*(UINT *)ptr_param = entry->bool.val;
return TRUE;
@ -998,7 +909,7 @@ static BOOL get_yesno_entry( union sysparam_all_entry *entry, UINT int_param, vo
/* set a bool parameter using Yes/No strings from the registry */
static BOOL set_yesno_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
{
const WCHAR *str = int_param ? Yes : No;
const WCHAR *str = int_param ? L"Yes" : L"No";
if (!save_entry_string( &entry->hdr, str, flags )) return FALSE;
entry->bool.val = int_param != 0;
@ -1009,7 +920,7 @@ static BOOL set_yesno_entry( union sysparam_all_entry *entry, UINT int_param, vo
/* initialize a bool parameter using Yes/No strings */
static BOOL init_yesno_entry( union sysparam_all_entry *entry )
{
return init_entry_string( &entry->hdr, entry->bool.val ? Yes : No );
return init_entry_string( &entry->hdr, entry->bool.val ? L"Yes" : L"No" );
}
/* load a dword (binary) parameter from the registry */
@ -1081,7 +992,7 @@ static BOOL set_rgb_entry( union sysparam_all_entry *entry, UINT int_param, void
HBRUSH brush;
HPEN pen;
wsprintfW( buf, CSrgb, GetRValue(int_param), GetGValue(int_param), GetBValue(int_param) );
wsprintfW( buf, L"%u %u %u", GetRValue(int_param), GetGValue(int_param), GetBValue(int_param) );
if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
entry->rgb.val = int_param;
entry->hdr.loaded = TRUE;
@ -1103,7 +1014,7 @@ static BOOL init_rgb_entry( union sysparam_all_entry *entry )
{
WCHAR buf[32];
wsprintfW( buf, CSrgb, GetRValue(entry->rgb.val), GetGValue(entry->rgb.val), GetBValue(entry->rgb.val) );
wsprintfW( buf, L"%u %u %u", GetRValue(entry->rgb.val), GetGValue(entry->rgb.val), GetBValue(entry->rgb.val) );
return init_entry_string( &entry->hdr, buf );
}
@ -1565,20 +1476,18 @@ static union sysparam_all_entry * const default_entries[] =
*/
void SYSPARAMS_Init(void)
{
static const WCHAR def_key_name[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s',0};
static const WCHAR def_value_name[] = {'L','o','g','P','i','x','e','l','s',0};
HKEY key;
DWORD i, dispos, dpi_scaling;
/* this one must be non-volatile */
if (RegCreateKeyW( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY, &key ))
if (RegCreateKeyW( HKEY_CURRENT_USER, L"Software\\Wine", &key ))
{
ERR("Can't create wine registry branch\n");
return;
}
/* @@ Wine registry key: HKCU\Software\Wine\Temporary System Parameters */
if (RegCreateKeyExW( key, WINE_CURRENT_USER_REGKEY_TEMP_PARAMS, 0, 0,
if (RegCreateKeyExW( key, L"Temporary System Parameters", 0, 0,
REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0, &volatile_base_key, &dispos ))
ERR("Can't create non-permanent wine registry branch\n");
@ -1587,10 +1496,10 @@ void SYSPARAMS_Init(void)
get_dword_entry( (union sysparam_all_entry *)&entry_LOGPIXELS, 0, &system_dpi, 0 );
if (!system_dpi) /* check fallback key */
{
if (!RegOpenKeyW( HKEY_CURRENT_CONFIG, def_key_name, &key ))
if (!RegOpenKeyW( HKEY_CURRENT_CONFIG, L"Software\\Fonts", &key ))
{
DWORD type, size = sizeof(system_dpi);
if (RegQueryValueExW( key, def_value_name, NULL, &type, (void *)&system_dpi, &size ) ||
if (RegQueryValueExW( key, L"LogPixels", NULL, &type, (void *)&system_dpi, &size ) ||
type != REG_DWORD)
system_dpi = 0;
RegCloseKey( key );
@ -3967,7 +3876,7 @@ static BOOL update_monitor_cache(void)
DWORD type;
/* Update monitor cache from SetupAPI if it's outdated */
if (!video_key && RegOpenKeyW( HKEY_LOCAL_MACHINE, VIDEO_KEY, &video_key ))
if (!video_key && RegOpenKeyW( HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\VIDEO", &video_key ))
return FALSE;
if (RegQueryInfoKeyW( video_key, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, &filetime ))
return FALSE;
@ -3976,7 +3885,7 @@ static BOOL update_monitor_cache(void)
mutex = get_display_device_init_mutex();
EnterCriticalSection( &monitors_section );
devinfo = SetupDiGetClassDevsW( &GUID_DEVCLASS_MONITOR, DISPLAY, NULL, DIGCF_PRESENT );
devinfo = SetupDiGetClassDevsW( &GUID_DEVCLASS_MONITOR, L"DISPLAY", NULL, DIGCF_PRESENT );
while (SetupDiEnumDeviceInfo( devinfo, i++, &device_data ))
{
@ -4028,7 +3937,7 @@ static BOOL update_monitor_cache(void)
(BYTE *)monitors[monitor_count].szDevice, CCHDEVICENAME * sizeof(WCHAR), NULL, 0))
goto fail;
monitors[monitor_count].dwFlags =
!wcscmp( DEFAULT_ADAPTER_NAME, monitors[monitor_count].szDevice ) ? MONITORINFOF_PRIMARY : 0;
!wcscmp( L"\\\\.\\DISPLAY1", monitors[monitor_count].szDevice ) ? MONITORINFOF_PRIMARY : 0;
monitor_count++;
}
@ -4056,7 +3965,7 @@ BOOL CDECL nulldrv_GetMonitorInfo( HMONITOR handle, MONITORINFO *info )
info->rcWork = default_rect;
info->dwFlags = MONITORINFOF_PRIMARY;
if (info->cbSize >= sizeof(MONITORINFOEXW))
lstrcpyW( ((MONITORINFOEXW *)info)->szDevice, DEFAULT_ADAPTER_NAME );
lstrcpyW( ((MONITORINFOEXW *)info)->szDevice, L"\\\\.\\DISPLAY1" );
return TRUE;
}
@ -4299,9 +4208,9 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
/* Find adapter */
if (!device)
{
swprintf( key_nameW, ARRAY_SIZE(key_nameW), VIDEO_VALUE_FMT, index );
swprintf( key_nameW, ARRAY_SIZE(key_nameW), L"\\Device\\Video%d", index );
size = sizeof(bufferW);
if (RegGetValueW( HKEY_LOCAL_MACHINE, VIDEO_KEY, key_nameW, RRF_RT_REG_SZ, NULL, bufferW, &size ))
if (RegGetValueW( HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\VIDEO", key_nameW, RRF_RT_REG_SZ, NULL, bufferW, &size ))
goto done;
/* DeviceKey */
@ -4309,20 +4218,20 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
lstrcpyW( info->DeviceKey, bufferW );
/* DeviceName */
swprintf( info->DeviceName, ARRAY_SIZE(info->DeviceName), ADAPTER_FMT, index + 1 );
swprintf( info->DeviceName, ARRAY_SIZE(info->DeviceName), L"\\\\.\\DISPLAY%d", index + 1 );
/* Strip \Registry\Machine\ */
lstrcpyW( key_nameW, bufferW + 18 );
/* DeviceString */
size = sizeof(info->DeviceString);
if (RegGetValueW( HKEY_LOCAL_MACHINE, key_nameW, DRIVER_DESC, RRF_RT_REG_SZ, NULL,
if (RegGetValueW( HKEY_LOCAL_MACHINE, key_nameW, L"DriverDesc", RRF_RT_REG_SZ, NULL,
info->DeviceString, &size ))
goto done;
/* StateFlags */
size = sizeof(info->StateFlags);
if (RegGetValueW( HKEY_CURRENT_CONFIG, key_nameW, STATE_FLAGS, RRF_RT_REG_DWORD, NULL,
if (RegGetValueW( HKEY_CURRENT_CONFIG, key_nameW, L"StateFlags", RRF_RT_REG_DWORD, NULL,
&info->StateFlags, &size ))
goto done;
@ -4334,7 +4243,7 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
else
{
size = sizeof(bufferW);
if (RegGetValueW( HKEY_CURRENT_CONFIG, key_nameW, GPU_ID, RRF_RT_REG_SZ | RRF_ZEROONFAILURE, NULL,
if (RegGetValueW( HKEY_CURRENT_CONFIG, key_nameW, L"GPUID", RRF_RT_REG_SZ | RRF_ZEROONFAILURE, NULL,
bufferW, &size ))
goto done;
set = SetupDiCreateDeviceInfoList( &GUID_DEVCLASS_DISPLAY, NULL );
@ -4350,23 +4259,23 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
else
{
/* Check adapter name */
if (wcsnicmp( device, ADAPTER_PREFIX, ARRAY_SIZE(ADAPTER_PREFIX) ))
if (wcsnicmp( device, L"\\\\.\\DISPLAY", lstrlenW(L"\\\\.\\DISPLAY") ))
goto done;
adapter_index = wcstol( device + ARRAY_SIZE(ADAPTER_PREFIX), NULL, 10 );
swprintf( key_nameW, ARRAY_SIZE(key_nameW), VIDEO_VALUE_FMT, adapter_index - 1 );
adapter_index = wcstol( device + lstrlenW(L"\\\\.\\DISPLAY"), NULL, 10 );
swprintf( key_nameW, ARRAY_SIZE(key_nameW), L"\\Device\\Video%d", adapter_index - 1 );
size = sizeof(bufferW);
if (RegGetValueW( HKEY_LOCAL_MACHINE, VIDEO_KEY, key_nameW, RRF_RT_REG_SZ, NULL, bufferW, &size ))
if (RegGetValueW( HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\VIDEO", key_nameW, RRF_RT_REG_SZ, NULL, bufferW, &size ))
goto done;
/* DeviceName */
swprintf( info->DeviceName, ARRAY_SIZE(info->DeviceName), MONITOR_FMT, adapter_index, index );
swprintf( info->DeviceName, ARRAY_SIZE(info->DeviceName), L"\\\\.\\DISPLAY%d\\Monitor%d", adapter_index, index );
/* Get monitor instance */
/* Strip \Registry\Machine\ first */
lstrcpyW( key_nameW, bufferW + 18 );
swprintf( bufferW, ARRAY_SIZE(bufferW), MONITOR_ID_VALUE_FMT, index );
swprintf( bufferW, ARRAY_SIZE(bufferW), L"MonitorID%d", index );
size = sizeof(instanceW);
if (RegGetValueW( HKEY_CURRENT_CONFIG, key_nameW, bufferW, RRF_RT_REG_SZ, NULL, instanceW, &size ))
@ -4394,7 +4303,7 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
sizeof(bufferW), NULL ))
goto done;
lstrcpyW( info->DeviceKey, NT_CLASS );
lstrcpyW( info->DeviceKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class\\" );
lstrcatW( info->DeviceKey, bufferW );
}
@ -4403,11 +4312,11 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
{
if (flags & EDD_GET_DEVICE_INTERFACE_NAME)
{
lstrcpyW( info->DeviceID, MONITOR_INTERFACE_PREFIX );
lstrcpyW( info->DeviceID, L"\\\\\?\\" );
lstrcatW( info->DeviceID, instanceW );
lstrcatW( info->DeviceID, GUID_DEVINTERFACE_MONITOR );
lstrcatW( info->DeviceID, L"#{e6f07b5f-ee97-4a90-b076-33f57bf4eaa7}" );
/* Replace '\\' with '#' after prefix */
for (next_charW = info->DeviceID + lstrlenW( MONITOR_INTERFACE_PREFIX ); *next_charW;
for (next_charW = info->DeviceID + lstrlenW( L"\\\\\?\\" ); *next_charW;
next_charW++)
{
if (*next_charW == '\\')
@ -4421,7 +4330,7 @@ BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *i
goto done;
lstrcpyW( info->DeviceID, bufferW );
lstrcatW( info->DeviceID, BACKSLASH );
lstrcatW( info->DeviceID, L"\\" );
if (!SetupDiGetDeviceRegistryPropertyW( set, &device_data, SPDRP_DRIVER, NULL, (BYTE *)bufferW,
sizeof(bufferW), NULL ))
@ -4444,7 +4353,7 @@ done:
return FALSE;
/* If user driver did initialize the registry, then exit */
if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, VIDEO_KEY, &hkey ))
if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\VIDEO", &hkey ))
{
RegCloseKey( hkey );
return FALSE;
@ -4454,8 +4363,8 @@ done:
/* Adapter */
if (!device)
{
memcpy( info->DeviceName, DEFAULT_ADAPTER_NAME, sizeof(DEFAULT_ADAPTER_NAME) );
memcpy( info->DeviceString, DEFAULT_ADAPTER_STRING, sizeof(DEFAULT_ADAPTER_STRING) );
lstrcpyW( info->DeviceName, L"\\\\.\\DISPLAY1" );
lstrcpyW( info->DeviceString, L"Wine Adapter" );
info->StateFlags =
DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE | DISPLAY_DEVICE_VGA_COMPATIBLE;
if (info->cb >= offsetof(DISPLAY_DEVICEW, DeviceID) + sizeof(info->DeviceID))
@ -4463,24 +4372,24 @@ done:
if (flags & EDD_GET_DEVICE_INTERFACE_NAME)
info->DeviceID[0] = 0;
else
memcpy( info->DeviceID, DEFAULT_ADAPTER_ID, sizeof(DEFAULT_ADAPTER_ID) );
lstrcpyW( info->DeviceID, L"PCI\\VEN_0000&DEV_0000&SUBSYS_00000000&REV_00" );
}
}
/* Monitor */
else
{
if (lstrcmpiW( DEFAULT_ADAPTER_NAME, device ))
if (lstrcmpiW( L"\\\\.\\DISPLAY1", device ))
return FALSE;
memcpy( info->DeviceName, DEFAULT_MONITOR_NAME, sizeof(DEFAULT_MONITOR_NAME) );
memcpy( info->DeviceString, DEFAULT_MONITOR_STRING, sizeof(DEFAULT_MONITOR_STRING) );
lstrcpyW( info->DeviceName, L"\\\\.\\DISPLAY1\\Monitor0" );
lstrcpyW( info->DeviceString, L"Generic Non-PnP Monitor" );
info->StateFlags = DISPLAY_DEVICE_ACTIVE | DISPLAY_DEVICE_ATTACHED;
if (info->cb >= offsetof(DISPLAY_DEVICEW, DeviceID) + sizeof(info->DeviceID))
{
if (flags & EDD_GET_DEVICE_INTERFACE_NAME)
memcpy( info->DeviceID, DEFAULT_MONITOR_INTERFACE_ID, sizeof(DEFAULT_MONITOR_INTERFACE_ID) );
lstrcpyW( info->DeviceID, L"\\\\\?\\DISPLAY#Default_Monitor#4&17f0ff54&0&UID0#{e6f07b5f-ee97-4a90-b076-33f57bf4eaa7}" );
else
memcpy( info->DeviceID, DEFAULT_MONITOR_ID, sizeof(DEFAULT_MONITOR_ID) );
lstrcpyW( info->DeviceID, L"MONITOR\\Default_Monitor\\{4d36e96e-e325-11ce-bfc1-08002be10318}\\0000" );
}
}
@ -4583,7 +4492,7 @@ LONG WINAPI GetDisplayConfigBufferSizes(UINT32 flags, UINT32 *num_path_info, UIN
/* Iterate through "targets"/monitors.
* Each target corresponds to a path, and each path references a source and a target mode.
*/
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, DISPLAY, NULL, DIGCF_PRESENT);
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, L"DISPLAY", NULL, DIGCF_PRESENT);
if (devinfo == INVALID_HANDLE_VALUE)
goto done;
@ -4780,7 +4689,7 @@ LONG WINAPI QueryDisplayConfig(UINT32 flags, UINT32 *numpathelements, DISPLAYCON
/* Iterate through "targets"/monitors.
* Each target corresponds to a path, and each path corresponds to one or two unique modes.
*/
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, DISPLAY, NULL, DIGCF_PRESENT);
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, L"DISPLAY", NULL, DIGCF_PRESENT);
if (devinfo == INVALID_HANDLE_VALUE)
{
ret = ERROR_GEN_FAILURE;
@ -4815,7 +4724,7 @@ LONG WINAPI QueryDisplayConfig(UINT32 flags, UINT32 *numpathelements, DISPLAYCON
goto done;
/* Extract the adapter index from device_name to use as the source ID */
adapter_index = wcstol(device_name + ARRAY_SIZE(ADAPTER_PREFIX), NULL, 10);
adapter_index = wcstol(device_name + lstrlenW(L"\\\\.\\DISPLAY"), NULL, 10);
adapter_index--;
if (path_index == *numpathelements || mode_index == *numinfoelements)
@ -4890,7 +4799,7 @@ LONG WINAPI DisplayConfigGetDeviceInfo(DISPLAYCONFIG_DEVICE_INFO_HEADER *packet)
return ERROR_INVALID_PARAMETER;
mutex = get_display_device_init_mutex();
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, DISPLAY, NULL, DIGCF_PRESENT);
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, L"DISPLAY", NULL, DIGCF_PRESENT);
if (devinfo == INVALID_HANDLE_VALUE)
{
release_display_device_init_mutex(mutex);
@ -4912,7 +4821,7 @@ LONG WINAPI DisplayConfigGetDeviceInfo(DISPLAYCONFIG_DEVICE_INFO_HEADER *packet)
&type, (BYTE *)device_name, sizeof(device_name), NULL, 0))
continue;
source_id = wcstol(device_name + ARRAY_SIZE(ADAPTER_PREFIX), NULL, 10);
source_id = wcstol(device_name + lstrlenW(L"\\\\.\\DISPLAY"), NULL, 10);
source_id--;
if (source_name->header.id != source_id)
continue;

2
dlls/user32/text.c
View file

@ -91,7 +91,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(text);
#define FORWARD_SLASH '/'
#define BACK_SLASH '\\'
static const WCHAR ELLIPSISW[] = {'.','.','.', 0};
static const WCHAR ELLIPSISW[] = L"...";
typedef struct tag_ellipsis_data
{

3
dlls/user32/uitools.c
View file

@ -918,7 +918,6 @@ static BOOL UITOOLS95_DrawFrameCaption(HDC dc, LPRECT r, UINT uFlags)
int xc = (myr.left+myr.right)/2;
int yc = (myr.top+myr.bottom)/2;
WCHAR str[] = {0, 0};
static const WCHAR glyphFontName[] = { 'M','a','r','l','e','t','t',0 };
UINT alignsave;
int bksave;
COLORREF clrsave;
@ -940,7 +939,7 @@ static BOOL UITOOLS95_DrawFrameCaption(HDC dc, LPRECT r, UINT uFlags)
hf = CreateFontW(-SmallDiam, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
SYMBOL_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY, FIXED_PITCH|FF_DONTCARE, glyphFontName);
DEFAULT_QUALITY, FIXED_PITCH|FF_DONTCARE, L"Marlett");
alignsave = SetTextAlign(dc, TA_TOP|TA_LEFT);
bksave = SetBkMode(dc, TRANSPARENT);
clrsave = GetTextColor(dc);

83
dlls/user32/user_main.c
View file

@ -166,52 +166,43 @@ static void palette_init(void)
*/
static const WCHAR *get_default_desktop(void)
{
static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0};
static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
static const WCHAR explorerW[] = {'\\','E','x','p','l','o','r','e','r',0};
static const WCHAR app_defaultsW[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','e','\\',
'A','p','p','D','e','f','a','u','l','t','s',0};
static WCHAR buffer[MAX_PATH + ARRAY_SIZE(explorerW)];
static WCHAR buffer[MAX_PATH + ARRAY_SIZE(L"\\Explorer")];
WCHAR *p, *appname = buffer;
const WCHAR *ret = NULL;
DWORD len;
HKEY tmpkey, appkey;
len = (GetModuleFileNameW( 0, buffer, MAX_PATH ));
if (!len || len >= MAX_PATH) return defaultW;
if (!len || len >= MAX_PATH) return L"Default";
if ((p = wcsrchr( appname, '/' ))) appname = p + 1;
if ((p = wcsrchr( appname, '\\' ))) appname = p + 1;
p = appname + lstrlenW(appname);
lstrcpyW( p, explorerW );
lstrcpyW( p, L"\\Explorer" );
/* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\Explorer */
if (!RegOpenKeyW( HKEY_CURRENT_USER, app_defaultsW, &tmpkey ))
if (!RegOpenKeyW( HKEY_CURRENT_USER, L"Software\\Wine\\AppDefaults", &tmpkey ))
{
if (RegOpenKeyW( tmpkey, appname, &appkey )) appkey = 0;
RegCloseKey( tmpkey );
if (appkey)
{
len = sizeof(buffer);
if (!RegQueryValueExW( appkey, desktopW, 0, NULL, (LPBYTE)buffer, &len )) ret = buffer;
if (!RegQueryValueExW( appkey, L"Desktop", 0, NULL, (LPBYTE)buffer, &len )) ret = buffer;
RegCloseKey( appkey );
if (ret && *ret) return ret;
ret = NULL;
}
}
memcpy( buffer, app_defaultsW, 13 * sizeof(WCHAR) ); /* copy only software\\wine */
lstrcpyW( buffer + 13, explorerW );
/* @@ Wine registry key: HKCU\Software\Wine\Explorer */
if (!RegOpenKeyW( HKEY_CURRENT_USER, buffer, &appkey ))
if (!RegOpenKeyW( HKEY_CURRENT_USER, L"Software\\Wine\\Explorer", &appkey ))
{
len = sizeof(buffer);
if (!RegQueryValueExW( appkey, desktopW, 0, NULL, (LPBYTE)buffer, &len )) ret = buffer;
if (!RegQueryValueExW( appkey, L"Desktop", 0, NULL, (LPBYTE)buffer, &len )) ret = buffer;
RegCloseKey( appkey );
if (ret && *ret) return ret;
}
return defaultW;
return L"Default";
}
@ -224,13 +215,9 @@ static void dpiaware_init(void)
{
WCHAR buffer[256];
DWORD option;
static const WCHAR dpiAwareW[] = {'d','p','i','A','w','a','r','e',0};
static const WCHAR dpiAwarenessW[] = {'d','p','i','A','w','a','r','e','n','e','s','s',0};
static const WCHAR namespace2005W[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','S','M','I','/','2','0','0','5','/','W','i','n','d','o','w','s','S','e','t','t','i','n','g','s',0};
static const WCHAR namespace2016W[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','S','M','I','/','2','0','1','6','/','W','i','n','d','o','w','s','S','e','t','t','i','n','g','s',0};
if (!LdrQueryImageFileExecutionOptions( &NtCurrentTeb()->Peb->ProcessParameters->ImagePathName,
dpiAwarenessW, REG_DWORD, &option, sizeof(option), NULL ))
L"dpiAwareness", REG_DWORD, &option, sizeof(option), NULL ))
{
TRACE( "got option %x\n", option );
if (option <= 2)
@ -240,24 +227,20 @@ static void dpiaware_init(void)
}
}
if (QueryActCtxSettingsW( 0, NULL, namespace2016W, dpiAwarenessW, buffer, ARRAY_SIZE(buffer), NULL ))
if (QueryActCtxSettingsW( 0, NULL, L"http://schemas.microsoft.com/SMI/2016/WindowsSettings",
L"dpiAwareness", buffer, ARRAY_SIZE(buffer), NULL ))
{
static const WCHAR unawareW[] = {'u','n','a','w','a','r','e',0};
static const WCHAR systemW[] = {'s','y','s','t','e','m',0};
static const WCHAR permonW[] = {'p','e','r','m','o','n','i','t','o','r',0};
static const WCHAR permonv2W[] = {'p','e','r','m','o','n','i','t','o','r','v','2',0};
static const WCHAR spacesW[] = {' ','\t','\r','\n',0};
static const WCHAR * const types[] = { unawareW, systemW, permonW, permonv2W };
static const WCHAR * const types[] = { L"unaware", L"system", L"permonitor", L"permonitorv2" };
WCHAR *p, *start, *end;
ULONG_PTR i;
TRACE( "got dpiAwareness=%s\n", debugstr_w(buffer) );
for (start = buffer; *start; start = end)
{
start += wcsspn( start, spacesW );
start += wcsspn( start, L" \t\r\n" );
if (!(end = wcschr( start, ',' ))) end = start + lstrlenW(start);
else *end++ = 0;
if ((p = wcspbrk( start, spacesW ))) *p = 0;
if ((p = wcspbrk( start, L" \t\r\n" ))) *p = 0;
for (i = 0; i < ARRAY_SIZE(types); i++)
{
if (wcsicmp( start, types[i] )) continue;
@ -266,16 +249,13 @@ static void dpiaware_init(void)
}
}
}
else if (QueryActCtxSettingsW( 0, NULL, namespace2005W, dpiAwareW, buffer, ARRAY_SIZE(buffer), NULL ))
else if (QueryActCtxSettingsW( 0, NULL, L"http://schemas.microsoft.com/SMI/2005/WindowsSettings",
L"dpiAware", buffer, ARRAY_SIZE(buffer), NULL ))
{
static const WCHAR trueW[] = {'t','r','u','e',0};
static const WCHAR truepmW[] = {'t','r','u','e','/','p','m',0};
static const WCHAR permonW[] = {'p','e','r',' ','m','o','n','i','t','o','r',0};
TRACE( "got dpiAware=%s\n", debugstr_w(buffer) );
if (!wcsicmp( buffer, trueW ))
if (!wcsicmp( buffer, L"true" ))
SetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
else if (!wcsicmp( buffer, truepmW ) || !wcsicmp( buffer, permonW ))
else if (!wcsicmp( buffer, L"true/pm" ) || !wcsicmp( buffer, L"per monitor" ))
SetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE );
else
SetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT_UNAWARE );
@ -290,8 +270,6 @@ static void dpiaware_init(void)
*/
static void winstation_init(void)
{
static const WCHAR WinSta0[] = {'W','i','n','S','t','a','0',0};
STARTUPINFOW info;
WCHAR *winstation = NULL, *desktop = NULL, *buffer = NULL;
HANDLE handle;
@ -312,12 +290,12 @@ static void winstation_init(void)
/* set winstation if explicitly specified, or if we don't have one yet */
if (buffer || !GetProcessWindowStation())
{
handle = CreateWindowStationW( winstation ? winstation : WinSta0, 0, WINSTA_ALL_ACCESS, NULL );
handle = CreateWindowStationW( winstation ? winstation : L"WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
if (handle)
{
SetProcessWindowStation( handle );
/* only WinSta0 is visible */
if (!winstation || !wcsicmp( winstation, WinSta0 ))
if (!winstation || !wcsicmp( winstation, L"WinSta0" ))
{
USEROBJECTFLAGS flags;
flags.fInherit = FALSE;
@ -395,7 +373,6 @@ static void thread_detach(void)
*/
BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
{
static const WCHAR imm32_dllW[] = {'i','m','m','3','2','.','d','l','l',0};
static HMODULE imm32_module;
BOOL ret = TRUE;
@ -405,7 +382,7 @@ BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
user32_module = inst;
ret = process_attach();
if(ret)
imm32_module = LoadLibraryW(imm32_dllW);
imm32_module = LoadLibraryW(L"imm32.dll");
break;
case DLL_THREAD_DETACH:
thread_detach();
@ -425,29 +402,23 @@ BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
*/
BOOL WINAPI ExitWindowsEx( UINT flags, DWORD reason )
{
static const WCHAR winebootW[] = { '\\','w','i','n','e','b','o','o','t','.','e','x','e',0 };
static const WCHAR killW[] = { ' ','-','-','k','i','l','l',0 };
static const WCHAR end_sessionW[] = { ' ','-','-','e','n','d','-','s','e','s','s','i','o','n',0 };
static const WCHAR forceW[] = { ' ','-','-','f','o','r','c','e',0 };
static const WCHAR shutdownW[] = { ' ','-','-','s','h','u','t','d','o','w','n',0 };
WCHAR app[MAX_PATH];
WCHAR cmdline[MAX_PATH + 64];
PROCESS_INFORMATION pi;
STARTUPINFOW si;
void *redir;
GetSystemDirectoryW( app, MAX_PATH - ARRAY_SIZE( winebootW ));
lstrcatW( app, winebootW );
GetSystemDirectoryW( app, MAX_PATH - ARRAY_SIZE( L"\\wineboot.exe" ));
lstrcatW( app, L"\\wineboot.exe" );
lstrcpyW( cmdline, app );
if (flags & EWX_FORCE) lstrcatW( cmdline, killW );
if (flags & EWX_FORCE) lstrcatW( cmdline, L" --kill" );
else
{
lstrcatW( cmdline, end_sessionW );
if (flags & EWX_FORCEIFHUNG) lstrcatW( cmdline, forceW );
lstrcatW( cmdline, L" --end-session" );
if (flags & EWX_FORCEIFHUNG) lstrcatW( cmdline, L" --force" );
}
if (!(flags & EWX_REBOOT)) lstrcatW( cmdline, shutdownW );
if (!(flags & EWX_REBOOT)) lstrcatW( cmdline, L" --shutdown" );
memset( &si, 0, sizeof si );
si.cb = sizeof si;

24
dlls/user32/win.c
View file

@ -1447,8 +1447,6 @@ HWND WIN_CreateWindowEx( CREATESTRUCTW *cs, LPCWSTR className, HINSTANCE module,
}
else
{
static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
{
WARN("No parent for child window\n" );
@ -1458,7 +1456,7 @@ HWND WIN_CreateWindowEx( CREATESTRUCTW *cs, LPCWSTR className, HINSTANCE module,
/* are we creating the desktop or HWND_MESSAGE parent itself? */
if (className != (LPCWSTR)DESKTOP_CLASS_ATOM &&
(IS_INTRESOURCE(className) || wcsicmp( className, messageW )))
(IS_INTRESOURCE(className) || wcsicmp( className, L"Message" )))
{
DWORD layout;
GetProcessDefaultLayout( &layout );
@ -2084,13 +2082,11 @@ HWND WINAPI GetDesktopWindow(void)
if (!thread_info->top_window)
{
static const WCHAR explorer[] = {'\\','e','x','p','l','o','r','e','r','.','e','x','e',0};
static const WCHAR args[] = {' ','/','d','e','s','k','t','o','p',0};
STARTUPINFOW si;
PROCESS_INFORMATION pi;
WCHAR windir[MAX_PATH];
WCHAR app[MAX_PATH + ARRAY_SIZE( explorer )];
WCHAR cmdline[MAX_PATH + ARRAY_SIZE( explorer ) + ARRAY_SIZE( args )];
WCHAR app[MAX_PATH + ARRAY_SIZE( L"\\explorer.exe" )];
WCHAR cmdline[MAX_PATH + ARRAY_SIZE( L"\\explorer.exe /desktop" )];
WCHAR desktop[MAX_PATH];
void *redir;
@ -2120,9 +2116,9 @@ HWND WINAPI GetDesktopWindow(void)
GetSystemDirectoryW( windir, MAX_PATH );
lstrcpyW( app, windir );
lstrcatW( app, explorer );
lstrcatW( app, L"\\explorer.exe" );
lstrcpyW( cmdline, app );
lstrcatW( cmdline, args );
lstrcatW( cmdline, L" /desktop" );
Wow64DisableWow64FsRedirection( &redir );
if (CreateProcessW( app, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS,
@ -4054,11 +4050,6 @@ BOOL WINAPI GetProcessDefaultLayout( DWORD *layout )
}
if (process_layout == ~0u)
{
static const WCHAR translationW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o',
'\\','T','r','a','n','s','l','a','t','i','o','n', 0 };
static const WCHAR filedescW[] = { '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o',
'\\','%','0','4','x','%','0','4','x',
'\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n',0 };
WCHAR *str, buffer[MAX_PATH];
DWORD i, len, version_layout = 0;
DWORD user_lang = GetUserDefaultLangID();
@ -4069,7 +4060,7 @@ BOOL WINAPI GetProcessDefaultLayout( DWORD *layout )
if (!(len = GetFileVersionInfoSizeW( buffer, NULL ))) goto done;
if (!(data = HeapAlloc( GetProcessHeap(), 0, len ))) goto done;
if (!GetFileVersionInfoW( buffer, 0, len, data )) goto done;
if (!VerQueryValueW( data, translationW, (void **)&languages, &len ) || !len) goto done;
if (!VerQueryValueW( data, L"\\VarFileInfo\\Translation", (void **)&languages, &len ) || !len) goto done;
len /= sizeof(DWORD);
for (i = 0; i < len; i++) if (LOWORD(languages[i]) == user_lang) break;
@ -4078,7 +4069,8 @@ BOOL WINAPI GetProcessDefaultLayout( DWORD *layout )
if (LOWORD(languages[i]) == MAKELANGID( PRIMARYLANGID(user_lang), SUBLANG_NEUTRAL )) break;
if (i == len) i = 0; /* default to the first one */
swprintf( buffer, ARRAY_SIZE(buffer), filedescW, LOWORD(languages[i]), HIWORD(languages[i]) );
swprintf( buffer, ARRAY_SIZE(buffer), L"\\StringFileInfo\\%04x%04x\\FileDescription",
LOWORD(languages[i]), HIWORD(languages[i]) );
if (!VerQueryValueW( data, buffer, (void **)&str, &len )) goto done;
TRACE( "found description %s\n", debugstr_w( str ));
if (str[0] == 0x200e && str[1] == 0x200e) version_layout = LAYOUT_RTL;

14
dlls/user32/winstation.c
View file

@ -58,9 +58,6 @@ static BOOL CALLBACK enum_names_WtoA( LPWSTR name, LPARAM lparam )
static HANDLE get_winstations_dir_handle(void)
{
static HANDLE handle = NULL;
static const WCHAR basenameW[] = {'\\','S','e','s','s','i','o','n','s','\\','%','u',
'\\','W','i','n','d','o','w','s','\\',
'W','i','n','d','o','w','S','t','a','t','i','o','n','s',0};
WCHAR buffer[64];
UNICODE_STRING str;
OBJECT_ATTRIBUTES attr;
@ -69,7 +66,7 @@ static HANDLE get_winstations_dir_handle(void)
{
HANDLE dir;
swprintf( buffer, ARRAY_SIZE(buffer), basenameW, NtCurrentTeb()->Peb->SessionId );
swprintf( buffer, ARRAY_SIZE(buffer), L"\\Sessions\\%u\\Windows\\WindowStations", NtCurrentTeb()->Peb->SessionId );
RtlInitUnicodeString( &str, buffer );
InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
NtOpenDirectoryObject( &dir, DIRECTORY_CREATE_OBJECT | DIRECTORY_TRAVERSE, &attr );
@ -83,13 +80,12 @@ static WCHAR default_name[29];
static BOOL WINAPI winstation_default_name_once( INIT_ONCE *once, void *param, void **context )
{
static const WCHAR fmt[] = {'S','e','r','v','i','c','e','-','0','x','%','x','-','%','x','$',0};
TOKEN_STATISTICS stats;
BOOL ret;
ret = GetTokenInformation( GetCurrentProcessToken(), TokenStatistics, &stats, sizeof(stats), NULL );
if (ret)
swprintf( default_name, ARRAY_SIZE(default_name), fmt,
swprintf( default_name, ARRAY_SIZE(default_name), L"Service-0x%x-%x$",
stats.AuthenticationId.HighPart, stats.AuthenticationId.LowPart );
return ret;
@ -579,8 +575,6 @@ BOOL WINAPI GetUserObjectInformationA( HANDLE handle, INT index, LPVOID info, DW
*/
BOOL WINAPI GetUserObjectInformationW( HANDLE handle, INT index, LPVOID info, DWORD len, LPDWORD needed )
{
static const WCHAR desktopW[] = { 'D','e','s','k','t','o','p',0 };
static const WCHAR winstationW[] = { 'W','i','n','d','o','w','S','t','a','t','i','o','n',0 };
BOOL ret;
switch(index)
@ -617,14 +611,14 @@ BOOL WINAPI GetUserObjectInformationW( HANDLE handle, INT index, LPVOID info, DW
ret = !wine_server_call_err( req );
if (ret)
{
size_t size = reply->is_desktop ? sizeof(desktopW) : sizeof(winstationW);
size_t size = reply->is_desktop ? sizeof(L"Desktop") : sizeof(L"WindowStation");
if (needed) *needed = size;
if (len < size)
{
SetLastError( ERROR_INSUFFICIENT_BUFFER );
ret = FALSE;
}
else memcpy( info, reply->is_desktop ? desktopW : winstationW, size );
else memcpy( info, reply->is_desktop ? L"Desktop" : L"WindowStation", size );
}
}
SERVER_END_REQ;

7
dlls/user32/wsprintf.c
View file

@ -75,9 +75,6 @@ typedef union {
LONGLONG int_view;
} WPRINTF_DATA;
static const CHAR null_stringA[] = "(null)";
static const WCHAR null_stringW[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
/***********************************************************************
* WPRINTF_ParseFormatA
*
@ -261,7 +258,7 @@ static UINT WPRINTF_GetLen( WPRINTF_FORMAT *format, WPRINTF_DATA *arg,
else len = WideCharToMultiByte( CP_ACP, 0, &arg->wchar_view, 1, NULL, 0, NULL, NULL );
return (format->precision = len);
case WPR_STRING:
if (!arg->lpcstr_view) arg->lpcstr_view = null_stringA;
if (!arg->lpcstr_view) arg->lpcstr_view = "(null)";
if (dst_is_wide)
{
LPCSTR p = arg->lpcstr_view;
@ -281,7 +278,7 @@ static UINT WPRINTF_GetLen( WPRINTF_FORMAT *format, WPRINTF_DATA *arg,
if (len > maxlen) len = maxlen;
return (format->precision = len);
case WPR_WSTRING:
if (!arg->lpcwstr_view) arg->lpcwstr_view = null_stringW;
if (!arg->lpcwstr_view) arg->lpcwstr_view = L"(null)";
if (dst_is_wide)
{
for (len = 0; !format->precision || (len < format->precision); len++)