2 * WineCfg configuration management
4 * Copyright 2002 Jaco Greeff
5 * Copyright 2003 Dimitrie O. Paun
6 * Copyright 2003-2004 Mike Hearn
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 * - Icons in listviews/icons
25 * - Better add app dialog, scan c: for EXE files and add to list in background
26 * - Use [GNOME] HIG style groupboxes rather than win32 style (looks nicer, imho)
30 #define WIN32_LEAN_AND_MEAN
37 #include <wine/unicode.h>
38 #include <wine/debug.h>
39 #include <wine/list.h>
41 WINE_DEFAULT_DEBUG_CHANNEL(winecfg
);
46 static const int is_win64
= (sizeof(void *) > sizeof(int));
48 HKEY config_key
= NULL
;
49 HMENU hPopupMenus
= 0;
52 /* this is called from the WM_SHOWWINDOW handlers of each tab page.
54 * it's a nasty hack, necessary because the property sheet insists on resetting the window title
55 * to the title of the tab, which is utterly useless. dropping the property sheet is on the todo list.
57 void set_window_title(HWND dialog
)
61 /* update the window title */
65 LoadStringW (GetModuleHandleW(NULL
), IDS_WINECFG_TITLE_APP
, apptitle
,
66 sizeof(apptitle
)/sizeof(apptitle
[0]));
67 wsprintfW (newtitle
, apptitle
, current_app
);
71 LoadStringW (GetModuleHandleW(NULL
), IDS_WINECFG_TITLE
, newtitle
,
72 sizeof(newtitle
)/sizeof(newtitle
[0]));
75 WINE_TRACE("setting title to %s\n", wine_dbgstr_w (newtitle
));
76 SendMessageW (GetParent(dialog
), PSM_SETTITLEW
, 0, (LPARAM
) newtitle
);
80 WCHAR
* load_string (UINT id
)
86 LoadStringW (GetModuleHandleW(NULL
), id
, buf
, sizeof(buf
)/sizeof(buf
[0]));
89 newStr
= HeapAlloc (GetProcessHeap(), 0, (len
+ 1) * sizeof (WCHAR
));
90 memcpy (newStr
, buf
, len
* sizeof (WCHAR
));
96 * get_config_key: Retrieves a configuration value from the registry
98 * char *subkey : the name of the config section
99 * char *name : the name of the config value
100 * char *default : if the key isn't found, return this value instead
102 * Returns a buffer holding the value if successful, NULL if
103 * not. Caller is responsible for releasing the result.
106 static WCHAR
*get_config_key (HKEY root
, const WCHAR
*subkey
, const WCHAR
*name
, const WCHAR
*def
)
108 LPWSTR buffer
= NULL
;
113 WINE_TRACE("subkey=%s, name=%s, def=%s\n", wine_dbgstr_w(subkey
),
114 wine_dbgstr_w(name
), wine_dbgstr_w(def
));
116 res
= RegOpenKeyExW(root
, subkey
, 0, MAXIMUM_ALLOWED
, &hSubKey
);
117 if (res
!= ERROR_SUCCESS
)
119 if (res
== ERROR_FILE_NOT_FOUND
)
121 WINE_TRACE("Section key not present - using default\n");
122 return def
? strdupW(def
) : NULL
;
126 WINE_ERR("RegOpenKey failed on wine config key (res=%d)\n", res
);
131 res
= RegQueryValueExW(hSubKey
, name
, NULL
, NULL
, NULL
, &len
);
132 if (res
== ERROR_FILE_NOT_FOUND
)
134 WINE_TRACE("Value not present - using default\n");
135 buffer
= def
? strdupW(def
) : NULL
;
137 } else if (res
!= ERROR_SUCCESS
)
139 WINE_ERR("Couldn't query value's length (res=%d)\n", res
);
143 buffer
= HeapAlloc(GetProcessHeap(), 0, len
+ sizeof(WCHAR
));
145 RegQueryValueExW(hSubKey
, name
, NULL
, NULL
, (LPBYTE
) buffer
, &len
);
147 WINE_TRACE("buffer=%s\n", wine_dbgstr_w(buffer
));
149 RegCloseKey(hSubKey
);
155 * set_config_key: convenience wrapper to set a key/value pair
157 * const char *subKey : the name of the config section
158 * const char *valueName : the name of the config value
159 * const char *value : the value to set the configuration key to
161 * Returns 0 on success, non-zero otherwise
163 * If valueName or value is NULL, an empty section will be created
165 static int set_config_key(HKEY root
, const WCHAR
*subkey
, REGSAM access
, const WCHAR
*name
, const void *value
, DWORD type
)
170 WINE_TRACE("subkey=%s: name=%s, value=%p, type=%d\n", wine_dbgstr_w(subkey
),
171 wine_dbgstr_w(name
), value
, type
);
173 assert( subkey
!= NULL
);
177 res
= RegCreateKeyExW( root
, subkey
, 0, NULL
, REG_OPTION_NON_VOLATILE
,
178 access
, NULL
, &key
, NULL
);
179 if (res
!= ERROR_SUCCESS
) goto end
;
182 if (name
== NULL
|| value
== NULL
) goto end
;
186 case REG_SZ
: res
= RegSetValueExW(key
, name
, 0, REG_SZ
, value
, (lstrlenW(value
)+1)*sizeof(WCHAR
)); break;
187 case REG_DWORD
: res
= RegSetValueExW(key
, name
, 0, REG_DWORD
, value
, sizeof(DWORD
)); break;
189 if (res
!= ERROR_SUCCESS
) goto end
;
193 if (key
&& key
!= root
) RegCloseKey(key
);
195 WINE_ERR("Unable to set configuration key %s in section %s, res=%d\n",
196 wine_dbgstr_w(name
), wine_dbgstr_w(subkey
), res
);
200 /* ========================================================================= */
202 /* This code exists for the following reasons:
204 * - It makes working with the registry easier
205 * - By storing a mini cache of the registry, we can more easily implement
206 * cancel/revert and apply. The 'settings list' is an overlay on top of
207 * the actual registry data that we can write out at will.
209 * Rather than model a tree in memory, we simply store each absolute (rooted
210 * at the config key) path.
217 HKEY root
; /* the key on which path is rooted */
218 WCHAR
*path
; /* path in the registry rooted at root */
219 WCHAR
*name
; /* name of the registry value. if null, this means delete the key */
220 WCHAR
*value
; /* contents of the registry value. if null, this means delete the value */
221 DWORD type
; /* type of registry value. REG_SZ or REG_DWORD for now */
224 struct list
*settings
;
226 static void free_setting(struct setting
*setting
)
228 assert( setting
!= NULL
);
229 assert( setting
->path
);
231 WINE_TRACE("destroying %p: %s\n", setting
,
232 wine_dbgstr_w(setting
->path
));
234 HeapFree(GetProcessHeap(), 0, setting
->path
);
235 HeapFree(GetProcessHeap(), 0, setting
->name
);
236 HeapFree(GetProcessHeap(), 0, setting
->value
);
238 list_remove(&setting
->entry
);
240 HeapFree(GetProcessHeap(), 0, setting
);
244 * Returns the contents of the value at path. If not in the settings
245 * list, it will be fetched from the registry - failing that, the
246 * default will be used.
248 * If already in the list, the contents as given there will be
249 * returned. You are expected to HeapFree the result.
251 WCHAR
*get_reg_keyW(HKEY root
, const WCHAR
*path
, const WCHAR
*name
, const WCHAR
*def
)
257 WINE_TRACE("path=%s, name=%s, def=%s\n", wine_dbgstr_w(path
),
258 wine_dbgstr_w(name
), wine_dbgstr_w(def
));
260 /* check if it's in the list */
261 LIST_FOR_EACH( cursor
, settings
)
263 s
= LIST_ENTRY(cursor
, struct setting
, entry
);
265 if (root
!= s
->root
) continue;
266 if (lstrcmpiW(path
, s
->path
) != 0) continue;
267 if (!s
->name
) continue;
268 if (lstrcmpiW(name
, s
->name
) != 0) continue;
270 WINE_TRACE("found %s:%s in settings list, returning %s\n",
271 wine_dbgstr_w(path
), wine_dbgstr_w(name
),
272 wine_dbgstr_w(s
->value
));
273 return s
->value
? strdupW(s
->value
) : NULL
;
276 /* no, so get from the registry */
277 val
= get_config_key(root
, path
, name
, def
);
279 WINE_TRACE("returning %s\n", wine_dbgstr_w(val
));
284 char *get_reg_key(HKEY root
, const char *path
, const char *name
, const char *def
)
286 WCHAR
*wpath
, *wname
, *wdef
= NULL
, *wRet
= NULL
;
290 WINE_TRACE("path=%s, name=%s, def=%s\n", path
, name
, def
);
292 wpath
= HeapAlloc(GetProcessHeap(), 0, (strlen(path
)+1)*sizeof(WCHAR
));
293 wname
= HeapAlloc(GetProcessHeap(), 0, (strlen(name
)+1)*sizeof(WCHAR
));
295 MultiByteToWideChar(CP_ACP
, 0, path
, -1, wpath
, strlen(path
)+1);
296 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wname
, strlen(name
)+1);
300 wdef
= HeapAlloc(GetProcessHeap(), 0, (strlen(def
)+1)*sizeof(WCHAR
));
301 MultiByteToWideChar(CP_ACP
, 0, def
, -1, wdef
, strlen(def
)+1);
304 wRet
= get_reg_keyW(root
, wpath
, wname
, wdef
);
306 len
= WideCharToMultiByte(CP_ACP
, 0, wRet
, -1, NULL
, 0, NULL
, NULL
);
309 szRet
= HeapAlloc(GetProcessHeap(), 0, len
);
310 WideCharToMultiByte(CP_ACP
, 0, wRet
, -1, szRet
, len
, NULL
, NULL
);
313 HeapFree(GetProcessHeap(), 0, wpath
);
314 HeapFree(GetProcessHeap(), 0, wname
);
315 HeapFree(GetProcessHeap(), 0, wdef
);
316 HeapFree(GetProcessHeap(), 0, wRet
);
322 * Used to set a registry key.
324 * path is rooted at the config key, ie use "Version" or
325 * "AppDefaults\\fooapp.exe\\Version". You can use keypath()
326 * to get such a string.
328 * name is the value name, or NULL to delete the path.
330 * value is what to set the value to, or NULL to delete it.
332 * type is REG_SZ or REG_DWORD.
334 * These values will be copied when necessary.
336 static void set_reg_key_ex(HKEY root
, const WCHAR
*path
, const WCHAR
*name
, const void *value
, DWORD type
)
341 assert( path
!= NULL
);
343 WINE_TRACE("path=%s, name=%s, value=%s\n", wine_dbgstr_w(path
),
344 wine_dbgstr_w(name
), wine_dbgstr_w(value
));
346 /* firstly, see if we already set this setting */
347 LIST_FOR_EACH( cursor
, settings
)
349 struct setting
*s
= LIST_ENTRY(cursor
, struct setting
, entry
);
351 if (root
!= s
->root
) continue;
352 if (lstrcmpiW(s
->path
, path
) != 0) continue;
353 if ((s
->name
&& name
) && lstrcmpiW(s
->name
, name
) != 0) continue;
355 /* are we attempting a double delete? */
356 if (!s
->name
&& !name
) return;
358 /* do we want to undelete this key? */
359 if (!s
->name
&& name
) s
->name
= strdupW(name
);
361 /* yes, we have already set it, so just replace the content and return */
362 HeapFree(GetProcessHeap(), 0, s
->value
);
367 s
->value
= value
? strdupW(value
) : NULL
;
370 s
->value
= HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD
));
371 memcpy( s
->value
, value
, sizeof(DWORD
) );
375 /* are we deleting this key? this won't remove any of the
376 * children from the overlay so if the user adds it again in
377 * that session it will appear to undelete the settings, but
378 * in reality only the settings actually modified by the user
379 * in that session will be restored. we might want to fix this
380 * corner case in future by actually deleting all the children
381 * here so that once it's gone, it's gone.
383 if (!name
) s
->name
= NULL
;
388 /* otherwise add a new setting for it */
389 s
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct setting
));
391 s
->path
= strdupW(path
);
392 s
->name
= name
? strdupW(name
) : NULL
;
397 s
->value
= value
? strdupW(value
) : NULL
;
400 s
->value
= HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD
));
401 memcpy( s
->value
, value
, sizeof(DWORD
) );
405 list_add_tail(settings
, &s
->entry
);
408 void set_reg_key(HKEY root
, const char *path
, const char *name
, const char *value
)
410 WCHAR
*wpath
, *wname
= NULL
, *wvalue
= NULL
;
412 wpath
= HeapAlloc(GetProcessHeap(), 0, (strlen(path
)+1)*sizeof(WCHAR
));
413 MultiByteToWideChar(CP_ACP
, 0, path
, -1, wpath
, strlen(path
)+1);
417 wname
= HeapAlloc(GetProcessHeap(), 0, (strlen(name
)+1)*sizeof(WCHAR
));
418 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wname
, strlen(name
)+1);
423 wvalue
= HeapAlloc(GetProcessHeap(), 0, (strlen(value
)+1)*sizeof(WCHAR
));
424 MultiByteToWideChar(CP_ACP
, 0, value
, -1, wvalue
, strlen(value
)+1);
427 set_reg_key_ex(root
, wpath
, wname
, wvalue
, REG_SZ
);
429 HeapFree(GetProcessHeap(), 0, wpath
);
430 HeapFree(GetProcessHeap(), 0, wname
);
431 HeapFree(GetProcessHeap(), 0, wvalue
);
434 void set_reg_key_dword(HKEY root
, const char *path
, const char *name
, DWORD value
)
436 WCHAR
*wpath
, *wname
;
438 wpath
= HeapAlloc(GetProcessHeap(), 0, (strlen(path
)+1)*sizeof(WCHAR
));
439 wname
= HeapAlloc(GetProcessHeap(), 0, (strlen(name
)+1)*sizeof(WCHAR
));
441 MultiByteToWideChar(CP_ACP
, 0, path
, -1, wpath
, strlen(path
)+1);
442 MultiByteToWideChar(CP_ACP
, 0, name
, -1, wname
, strlen(name
)+1);
444 set_reg_key_ex(root
, wpath
, wname
, &value
, REG_DWORD
);
446 HeapFree(GetProcessHeap(), 0, wpath
);
447 HeapFree(GetProcessHeap(), 0, wname
);
450 void set_reg_keyW(HKEY root
, const WCHAR
*path
, const WCHAR
*name
, const WCHAR
*value
)
452 set_reg_key_ex(root
, path
, name
, value
, REG_SZ
);
455 void set_reg_key_dwordW(HKEY root
, const WCHAR
*path
, const WCHAR
*name
, DWORD value
)
457 set_reg_key_ex(root
, path
, name
, &value
, REG_DWORD
);
461 * enumerates the value names at the given path, taking into account
462 * the changes in the settings list.
464 * you are expected to HeapFree each element of the array, which is null
465 * terminated, as well as the array itself.
467 static WCHAR
**enumerate_valuesW(HKEY root
, WCHAR
*path
)
470 DWORD res
, i
= 0, valueslen
= 0;
471 WCHAR
**values
= NULL
;
474 res
= RegOpenKeyExW(root
, path
, 0, MAXIMUM_ALLOWED
, &key
);
475 if (res
== ERROR_SUCCESS
)
480 DWORD namesize
= sizeof(name
)/sizeof(name
[0]);
481 BOOL removed
= FALSE
;
483 /* find out the needed size, allocate a buffer, read the value */
484 if ((res
= RegEnumValueW(key
, i
, name
, &namesize
, NULL
, NULL
, NULL
, NULL
)) != ERROR_SUCCESS
)
487 WINE_TRACE("name=%s\n", wine_dbgstr_w(name
));
489 /* check if this value name has been removed in the settings list */
490 LIST_FOR_EACH( cursor
, settings
)
492 struct setting
*s
= LIST_ENTRY(cursor
, struct setting
, entry
);
493 if (lstrcmpiW(s
->path
, path
) != 0) continue;
494 if (lstrcmpiW(s
->name
, name
) != 0) continue;
498 WINE_TRACE("this key has been removed, so skipping\n");
504 if (removed
) /* this value was deleted by the user, so don't include it */
506 HeapFree(GetProcessHeap(), 0, name
);
511 /* grow the array if necessary, add buffer to it, iterate */
512 if (values
) values
= HeapReAlloc(GetProcessHeap(), 0, values
, sizeof(WCHAR
*) * (valueslen
+ 1));
513 else values
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
*));
515 values
[valueslen
++] = strdupW(name
);
516 WINE_TRACE("valueslen is now %d\n", valueslen
);
522 WINE_WARN("failed opening registry key %s, res=0x%x\n",
523 wine_dbgstr_w(path
), res
);
526 WINE_TRACE("adding settings in list but not registry\n");
528 /* now we have to add the values that aren't in the registry but are in the settings list */
529 LIST_FOR_EACH( cursor
, settings
)
531 struct setting
*setting
= LIST_ENTRY(cursor
, struct setting
, entry
);
534 if (lstrcmpiW(setting
->path
, path
) != 0) continue;
536 if (!setting
->value
) continue;
538 for (i
= 0; i
< valueslen
; i
++)
540 if (lstrcmpiW(setting
->name
, values
[i
]) == 0)
549 WINE_TRACE("%s in list but not registry\n", wine_dbgstr_w(setting
->name
));
551 /* otherwise it's been set by the user but isn't in the registry */
552 if (values
) values
= HeapReAlloc(GetProcessHeap(), 0, values
, sizeof(WCHAR
*) * (valueslen
+ 1));
553 else values
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
*));
555 values
[valueslen
++] = strdupW(setting
->name
);
558 WINE_TRACE("adding null terminator\n");
561 values
= HeapReAlloc(GetProcessHeap(), 0, values
, sizeof(WCHAR
*) * (valueslen
+ 1));
562 values
[valueslen
] = NULL
;
570 char **enumerate_values(HKEY root
, char *path
)
577 wpath
= HeapAlloc(GetProcessHeap(), 0, (strlen(path
)+1)*sizeof(WCHAR
));
578 MultiByteToWideChar(CP_ACP
, 0, path
, -1, wpath
, strlen(path
)+1);
580 wret
= enumerate_valuesW(root
, wpath
);
584 for(len
=0; wret
[len
]; len
++);
585 ret
= HeapAlloc(GetProcessHeap(), 0, (len
+1)*sizeof(char*));
587 /* convert WCHAR ** to char ** and HeapFree each WCHAR * element on our way */
588 for (i
=0; i
<len
; i
++)
590 ret
[i
] = HeapAlloc(GetProcessHeap(), 0,
591 (lstrlenW(wret
[i
]) + 1) * sizeof(char));
592 WideCharToMultiByte(CP_ACP
, 0, wret
[i
], -1, ret
[i
],
593 lstrlenW(wret
[i
]) + 1, NULL
, NULL
);
594 HeapFree(GetProcessHeap(), 0, wret
[i
]);
599 HeapFree(GetProcessHeap(), 0, wpath
);
600 HeapFree(GetProcessHeap(), 0, wret
);
606 * returns true if the given key/value pair exists in the registry or
607 * has been written to.
609 BOOL
reg_key_exists(HKEY root
, const char *path
, const char *name
)
611 char *val
= get_reg_key(root
, path
, name
, NULL
);
615 HeapFree(GetProcessHeap(), 0, val
);
622 static void process_setting(struct setting
*s
)
624 static const WCHAR softwareW
[] = {'S','o','f','t','w','a','r','e','\\'};
626 BOOL needs_wow64
= (is_win64
&& s
->root
== HKEY_LOCAL_MACHINE
&& s
->path
&&
627 !strncmpiW( s
->path
, softwareW
, sizeof(softwareW
)/sizeof(WCHAR
) ));
631 WINE_TRACE("Setting %s:%s to '%s'\n", wine_dbgstr_w(s
->path
),
632 wine_dbgstr_w(s
->name
), wine_dbgstr_w(s
->value
));
633 set_config_key(s
->root
, s
->path
, MAXIMUM_ALLOWED
, s
->name
, s
->value
, s
->type
);
636 WINE_TRACE("Setting 32-bit %s:%s to '%s'\n", wine_dbgstr_w(s
->path
),
637 wine_dbgstr_w(s
->name
), wine_dbgstr_w(s
->value
));
638 set_config_key(s
->root
, s
->path
, MAXIMUM_ALLOWED
| KEY_WOW64_32KEY
, s
->name
, s
->value
, s
->type
);
643 WINE_TRACE("Removing %s:%s\n", wine_dbgstr_w(s
->path
), wine_dbgstr_w(s
->name
));
644 if (!RegOpenKeyExW( s
->root
, s
->path
, 0, MAXIMUM_ALLOWED
, &key
))
646 /* NULL name means remove that path/section entirely */
647 if (s
->name
) RegDeleteValueW( key
, s
->name
);
650 RegDeleteTreeW( key
, NULL
);
651 RegDeleteKeyW( s
->root
, s
->path
);
657 WINE_TRACE("Removing 32-bit %s:%s\n", wine_dbgstr_w(s
->path
), wine_dbgstr_w(s
->name
));
658 if (!RegOpenKeyExW( s
->root
, s
->path
, 0, MAXIMUM_ALLOWED
| KEY_WOW64_32KEY
, &key
))
660 if (s
->name
) RegDeleteValueW( key
, s
->name
);
663 RegDeleteTreeW( key
, NULL
);
664 RegDeleteKeyExW( s
->root
, s
->path
, KEY_WOW64_32KEY
, 0 );
674 if (list_empty(settings
)) return; /* we will be called for each page when the user clicks OK */
678 while (!list_empty(settings
))
680 struct setting
*s
= (struct setting
*) list_head(settings
);
686 /* ================================== utility functions ============================ */
688 WCHAR
* current_app
= NULL
; /* the app we are currently editing, or NULL if editing global */
690 /* returns a registry key path suitable for passing to addTransaction */
691 char *keypath(const char *section
)
693 static char *result
= NULL
;
695 HeapFree(GetProcessHeap(), 0, result
);
699 result
= HeapAlloc(GetProcessHeap(), 0, strlen("AppDefaults\\") + lstrlenW(current_app
)*2 + 2 /* \\ */ + strlen(section
) + 1 /* terminator */);
700 wsprintfA(result
, "AppDefaults\\%ls", current_app
);
701 if (section
[0]) sprintf( result
+ strlen(result
), "\\%s", section
);
705 result
= strdupA(section
);
711 WCHAR
*keypathW(const WCHAR
*section
)
713 static const WCHAR appdefaultsW
[] = {'A','p','p','D','e','f','a','u','l','t','s','\\',0};
714 static WCHAR
*result
= NULL
;
716 HeapFree(GetProcessHeap(), 0, result
);
720 DWORD len
= sizeof(appdefaultsW
) + (lstrlenW(current_app
) + lstrlenW(section
) + 1) * sizeof(WCHAR
);
721 result
= HeapAlloc(GetProcessHeap(), 0, len
);
722 lstrcpyW( result
, appdefaultsW
);
723 lstrcatW( result
, current_app
);
726 len
= lstrlenW(result
);
727 result
[len
++] = '\\';
728 lstrcpyW( result
+ len
, section
);
733 result
= strdupW(section
);
739 void PRINTERROR(void)
743 FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
|FORMAT_MESSAGE_FROM_SYSTEM
,
744 0, GetLastError(), MAKELANGID(LANG_NEUTRAL
,SUBLANG_DEFAULT
),
745 (LPSTR
)&msg
, 0, NULL
);
747 /* eliminate trailing newline, is this a Wine bug? */
748 *(strrchr(msg
, '\r')) = '\0';
750 WINE_TRACE("error: '%s'\n", msg
);
753 int initialize(HINSTANCE hInstance
)
755 DWORD res
= RegCreateKeyA(HKEY_CURRENT_USER
, WINE_KEY_ROOT
, &config_key
);
757 if (res
!= ERROR_SUCCESS
) {
758 WINE_ERR("RegOpenKey failed on wine config key (%d)\n", res
);
762 /* we could probably just have the list as static data */
763 settings
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct list
));