?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winecfg: Use the available ARRAY_SIZE() macro.
[wine.git] / programs / winecfg / theme.c
blobf98dcc3ae75d7338d421aae0371e98c6d12b90a4
1 /*
2 * Desktop Integration
3 * - Theme configuration code
4 * - User Shell Folder mapping
5 *
6 * Copyright (c) 2005 by Frank Richter
7 * Copyright (c) 2006 by Michael Jung
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 *
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <stdarg.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #ifdef HAVE_SYS_STAT_H
32 #include <sys/stat.h>
33 #endif
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37 #ifdef HAVE_DIRECT_H
38 #include <direct.h>
39 #endif
40
41 #define COBJMACROS
42
43 #include <windows.h>
44 #include <commdlg.h>
45 #include <shellapi.h>
46 #include <uxtheme.h>
47 #include <tmschema.h>
48 #include <shlobj.h>
49 #include <shlwapi.h>
50 #include <wine/debug.h>
51 #include <wine/unicode.h>
52
53 #include "resource.h"
54 #include "winecfg.h"
55
56 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
57
58 /* UXTHEME functions not in the headers */
59
60 typedef struct tagTHEMENAMES
61 {
62 WCHAR szName[MAX_PATH+1];
63 WCHAR szDisplayName[MAX_PATH+1];
64 WCHAR szTooltip[MAX_PATH+1];
65 } THEMENAMES, *PTHEMENAMES;
66
67 typedef void* HTHEMEFILE;
68 typedef BOOL (CALLBACK *EnumThemeProc)(LPVOID lpReserved,
69 LPCWSTR pszThemeFileName,
70 LPCWSTR pszThemeName,
71 LPCWSTR pszToolTip, LPVOID lpReserved2,
72 LPVOID lpData);
73
74 HRESULT WINAPI EnumThemeColors (LPCWSTR pszThemeFileName, LPWSTR pszSizeName,
75 DWORD dwColorNum, PTHEMENAMES pszColorNames);
76 HRESULT WINAPI EnumThemeSizes (LPCWSTR pszThemeFileName, LPWSTR pszColorName,
77 DWORD dwSizeNum, PTHEMENAMES pszSizeNames);
78 HRESULT WINAPI ApplyTheme (HTHEMEFILE hThemeFile, char* unknown, HWND hWnd);
79 HRESULT WINAPI OpenThemeFile (LPCWSTR pszThemeFileName, LPCWSTR pszColorName,
80 LPCWSTR pszSizeName, HTHEMEFILE* hThemeFile,
81 DWORD unknown);
82 HRESULT WINAPI CloseThemeFile (HTHEMEFILE hThemeFile);
83 HRESULT WINAPI EnumThemes (LPCWSTR pszThemePath, EnumThemeProc callback,
84 LPVOID lpData);
85
86 static void refresh_sysparams(HWND hDlg);
87 static void on_sysparam_change(HWND hDlg);
88
89 /* A struct to keep both the internal and "fancy" name of a color or size */
90 typedef struct
91 {
92 WCHAR* name;
93 WCHAR* fancyName;
94 } ThemeColorOrSize;
95
96 /* wrapper around DSA that also keeps an item count */
97 typedef struct
98 {
99 HDSA dsa;
100 int count;
101 } WrappedDsa;
102
103 /* Some helper functions to deal with ThemeColorOrSize structs in WrappedDSAs */
104
105 static void color_or_size_dsa_add (WrappedDsa* wdsa, const WCHAR* name,
106 const WCHAR* fancyName)
107 {
108 ThemeColorOrSize item;
109
110 item.name = HeapAlloc (GetProcessHeap(), 0,
111 (lstrlenW (name) + 1) * sizeof(WCHAR));
112 lstrcpyW (item.name, name);
113
114 item.fancyName = HeapAlloc (GetProcessHeap(), 0,
115 (lstrlenW (fancyName) + 1) * sizeof(WCHAR));
116 lstrcpyW (item.fancyName, fancyName);
117
118 DSA_InsertItem (wdsa->dsa, wdsa->count, &item);
119 wdsa->count++;
120 }
121
122 static int CALLBACK dsa_destroy_callback (LPVOID p, LPVOID pData)
123 {
124 ThemeColorOrSize* item = p;
125 HeapFree (GetProcessHeap(), 0, item->name);
126 HeapFree (GetProcessHeap(), 0, item->fancyName);
127 return 1;
128 }
129
130 static void free_color_or_size_dsa (WrappedDsa* wdsa)
131 {
132 DSA_DestroyCallback (wdsa->dsa, dsa_destroy_callback, NULL);
133 }
134
135 static void create_color_or_size_dsa (WrappedDsa* wdsa)
136 {
137 wdsa->dsa = DSA_Create (sizeof (ThemeColorOrSize), 1);
138 wdsa->count = 0;
139 }
140
141 static ThemeColorOrSize* color_or_size_dsa_get (WrappedDsa* wdsa, int index)
142 {
143 return DSA_GetItemPtr (wdsa->dsa, index);
144 }
145
146 static int color_or_size_dsa_find (WrappedDsa* wdsa, const WCHAR* name)
147 {
148 int i = 0;
149 for (; i < wdsa->count; i++)
150 {
151 ThemeColorOrSize* item = color_or_size_dsa_get (wdsa, i);
152 if (lstrcmpiW (item->name, name) == 0) break;
153 }
154 return i;
155 }
156
157 /* A theme file, contains file name, display name, color and size scheme names */
158 typedef struct
159 {
160 WCHAR* themeFileName;
161 WCHAR* fancyName;
162 WrappedDsa colors;
163 WrappedDsa sizes;
164 } ThemeFile;
165
166 static HDSA themeFiles = NULL;
167 static int themeFilesCount = 0;
168
169 static int CALLBACK theme_dsa_destroy_callback (LPVOID p, LPVOID pData)
170 {
171 ThemeFile* item = p;
172 HeapFree (GetProcessHeap(), 0, item->themeFileName);
173 HeapFree (GetProcessHeap(), 0, item->fancyName);
174 free_color_or_size_dsa (&item->colors);
175 free_color_or_size_dsa (&item->sizes);
176 return 1;
177 }
178
179 /* Free memory occupied by the theme list */
180 static void free_theme_files(void)
181 {
182 if (themeFiles == NULL) return;
183
184 DSA_DestroyCallback (themeFiles , theme_dsa_destroy_callback, NULL);
185 themeFiles = NULL;
186 themeFilesCount = 0;
187 }
188
189 typedef HRESULT (WINAPI * EnumTheme) (LPCWSTR, LPWSTR, DWORD, PTHEMENAMES);
190
191 /* fill a string list with either colors or sizes of a theme */
192 static void fill_theme_string_array (const WCHAR* filename,
193 WrappedDsa* wdsa,
194 EnumTheme enumTheme)
195 {
196 DWORD index = 0;
197 THEMENAMES names;
198
199 WINE_TRACE ("%s %p %p\n", wine_dbgstr_w (filename), wdsa, enumTheme);
200
201 while (SUCCEEDED (enumTheme (filename, NULL, index++, &names)))
202 {
203 WINE_TRACE ("%s: %s\n", wine_dbgstr_w (names.szName),
204 wine_dbgstr_w (names.szDisplayName));
205 color_or_size_dsa_add (wdsa, names.szName, names.szDisplayName);
206 }
207 }
208
209 /* Theme enumeration callback, adds theme to theme list */
210 static BOOL CALLBACK myEnumThemeProc (LPVOID lpReserved,
211 LPCWSTR pszThemeFileName,
212 LPCWSTR pszThemeName,
213 LPCWSTR pszToolTip,
214 LPVOID lpReserved2, LPVOID lpData)
215 {
216 ThemeFile newEntry;
217
218 /* fill size/color lists */
219 create_color_or_size_dsa (&newEntry.colors);
220 fill_theme_string_array (pszThemeFileName, &newEntry.colors, EnumThemeColors);
221 create_color_or_size_dsa (&newEntry.sizes);
222 fill_theme_string_array (pszThemeFileName, &newEntry.sizes, EnumThemeSizes);
223
224 newEntry.themeFileName = HeapAlloc (GetProcessHeap(), 0,
225 (lstrlenW (pszThemeFileName) + 1) * sizeof(WCHAR));
226 lstrcpyW (newEntry.themeFileName, pszThemeFileName);
227
228 newEntry.fancyName = HeapAlloc (GetProcessHeap(), 0,
229 (lstrlenW (pszThemeName) + 1) * sizeof(WCHAR));
230 lstrcpyW (newEntry.fancyName, pszThemeName);
231
232 /*list_add_tail (&themeFiles, &newEntry->entry);*/
233 DSA_InsertItem (themeFiles, themeFilesCount, &newEntry);
234 themeFilesCount++;
235
236 return TRUE;
237 }
238
239 /* Scan for themes */
240 static void scan_theme_files(void)
241 {
242 static const WCHAR themesSubdir[] = { '\\','T','h','e','m','e','s',0 };
243 WCHAR themesPath[MAX_PATH];
244
245 free_theme_files();
246
247 if (FAILED (SHGetFolderPathW (NULL, CSIDL_RESOURCES, NULL,
248 SHGFP_TYPE_CURRENT, themesPath))) return;
249
250 themeFiles = DSA_Create (sizeof (ThemeFile), 1);
251 lstrcatW (themesPath, themesSubdir);
252
253 EnumThemes (themesPath, myEnumThemeProc, 0);
254 }
255
256 /* fill the color & size combo boxes for a given theme */
257 static void fill_color_size_combos (ThemeFile* theme, HWND comboColor,
258 HWND comboSize)
259 {
260 int i;
261
262 SendMessageW (comboColor, CB_RESETCONTENT, 0, 0);
263 for (i = 0; i < theme->colors.count; i++)
264 {
265 ThemeColorOrSize* item = color_or_size_dsa_get (&theme->colors, i);
266 SendMessageW (comboColor, CB_ADDSTRING, 0, (LPARAM)item->fancyName);
267 }
268
269 SendMessageW (comboSize, CB_RESETCONTENT, 0, 0);
270 for (i = 0; i < theme->sizes.count; i++)
271 {
272 ThemeColorOrSize* item = color_or_size_dsa_get (&theme->sizes, i);
273 SendMessageW (comboSize, CB_ADDSTRING, 0, (LPARAM)item->fancyName);
274 }
275 }
276
277 /* Select the item of a combo box that matches a theme's color and size
278 * scheme. */
279 static void select_color_and_size (ThemeFile* theme,
280 const WCHAR* colorName, HWND comboColor,
281 const WCHAR* sizeName, HWND comboSize)
282 {
283 SendMessageW (comboColor, CB_SETCURSEL,
284 color_or_size_dsa_find (&theme->colors, colorName), 0);
285 SendMessageW (comboSize, CB_SETCURSEL,
286 color_or_size_dsa_find (&theme->sizes, sizeName), 0);
287 }
288
289 /* Fill theme, color and sizes combo boxes with the know themes and select
290 * the entries matching the currently active theme. */
291 static BOOL fill_theme_list (HWND comboTheme, HWND comboColor, HWND comboSize)
292 {
293 WCHAR textNoTheme[256];
294 int themeIndex = 0;
295 BOOL ret = TRUE;
296 int i;
297 WCHAR currentTheme[MAX_PATH];
298 WCHAR currentColor[MAX_PATH];
299 WCHAR currentSize[MAX_PATH];
300 ThemeFile* theme = NULL;
301
302 LoadStringW(GetModuleHandleW(NULL), IDS_NOTHEME, textNoTheme, ARRAY_SIZE(textNoTheme));
303
304 SendMessageW (comboTheme, CB_RESETCONTENT, 0, 0);
305 SendMessageW (comboTheme, CB_ADDSTRING, 0, (LPARAM)textNoTheme);
306
307 for (i = 0; i < themeFilesCount; i++)
308 {
309 ThemeFile* item = DSA_GetItemPtr (themeFiles, i);
310 SendMessageW (comboTheme, CB_ADDSTRING, 0,
311 (LPARAM)item->fancyName);
312 }
313
314 if (IsThemeActive() && SUCCEEDED(GetCurrentThemeName(currentTheme, ARRAY_SIZE(currentTheme),
315 currentColor, ARRAY_SIZE(currentColor), currentSize, ARRAY_SIZE(currentSize))))
316 {
317 /* Determine the index of the currently active theme. */
318 BOOL found = FALSE;
319 for (i = 0; i < themeFilesCount; i++)
320 {
321 theme = DSA_GetItemPtr (themeFiles, i);
322 if (lstrcmpiW (theme->themeFileName, currentTheme) == 0)
323 {
324 found = TRUE;
325 themeIndex = i+1;
326 break;
327 }
328 }
329 if (!found)
330 {
331 /* Current theme not found?... add to the list, then... */
332 WINE_TRACE("Theme %s not in list of enumerated themes\n",
333 wine_dbgstr_w (currentTheme));
334 myEnumThemeProc (NULL, currentTheme, currentTheme,
335 currentTheme, NULL, NULL);
336 themeIndex = themeFilesCount;
337 theme = DSA_GetItemPtr (themeFiles, themeFilesCount-1);
338 }
339 fill_color_size_combos (theme, comboColor, comboSize);
340 select_color_and_size (theme, currentColor, comboColor,
341 currentSize, comboSize);
342 }
343 else
344 {
345 /* No theme selected */
346 ret = FALSE;
347 }
348
349 SendMessageW (comboTheme, CB_SETCURSEL, themeIndex, 0);
350 return ret;
351 }
352
353 /* Update the color & size combo boxes when the selection of the theme
354 * combo changed. Selects the current color and size scheme if the theme
355 * is currently active, otherwise the first color and size. */
356 static BOOL update_color_and_size (int themeIndex, HWND comboColor,
357 HWND comboSize)
358 {
359 if (themeIndex == 0)
360 {
361 return FALSE;
362 }
363 else
364 {
365 WCHAR currentTheme[MAX_PATH];
366 WCHAR currentColor[MAX_PATH];
367 WCHAR currentSize[MAX_PATH];
368 ThemeFile* theme = DSA_GetItemPtr (themeFiles, themeIndex - 1);
369
370 fill_color_size_combos (theme, comboColor, comboSize);
371
372 if ((SUCCEEDED(GetCurrentThemeName (currentTheme, ARRAY_SIZE(currentTheme),
373 currentColor, ARRAY_SIZE(currentColor), currentSize, ARRAY_SIZE(currentSize))))
374 && (lstrcmpiW (currentTheme, theme->themeFileName) == 0))
375 {
376 select_color_and_size (theme, currentColor, comboColor,
377 currentSize, comboSize);
378 }
379 else
380 {
381 SendMessageW (comboColor, CB_SETCURSEL, 0, 0);
382 SendMessageW (comboSize, CB_SETCURSEL, 0, 0);
383 }
384 }
385 return TRUE;
386 }
387
388 /* Apply a theme from a given theme, color and size combo box item index. */
389 static void do_apply_theme (HWND dialog, int themeIndex, int colorIndex, int sizeIndex)
390 {
391 static char b[] = "\0";
392
393 if (themeIndex == 0)
394 {
395 /* no theme */
396 ApplyTheme (NULL, b, NULL);
397 }
398 else
399 {
400 ThemeFile* theme = DSA_GetItemPtr (themeFiles, themeIndex-1);
401 const WCHAR* themeFileName = theme->themeFileName;
402 const WCHAR* colorName = NULL;
403 const WCHAR* sizeName = NULL;
404 HTHEMEFILE hTheme;
405 ThemeColorOrSize* item;
406
407 item = color_or_size_dsa_get (&theme->colors, colorIndex);
408 colorName = item->name;
409
410 item = color_or_size_dsa_get (&theme->sizes, sizeIndex);
411 sizeName = item->name;
412
413 if (SUCCEEDED (OpenThemeFile (themeFileName, colorName, sizeName,
414 &hTheme, 0)))
415 {
416 ApplyTheme (hTheme, b, NULL);
417 CloseThemeFile (hTheme);
418 }
419 else
420 {
421 ApplyTheme (NULL, b, NULL);
422 }
423 }
424
425 refresh_sysparams(dialog);
426 }
427
428 static BOOL updating_ui;
429 static BOOL theme_dirty;
430
431 static void enable_size_and_color_controls (HWND dialog, BOOL enable)
432 {
433 EnableWindow (GetDlgItem (dialog, IDC_THEME_COLORCOMBO), enable);
434 EnableWindow (GetDlgItem (dialog, IDC_THEME_COLORTEXT), enable);
435 EnableWindow (GetDlgItem (dialog, IDC_THEME_SIZECOMBO), enable);
436 EnableWindow (GetDlgItem (dialog, IDC_THEME_SIZETEXT), enable);
437 }
438
439 static void init_dialog (HWND dialog)
440 {
441 updating_ui = TRUE;
442
443 scan_theme_files();
444 if (!fill_theme_list (GetDlgItem (dialog, IDC_THEME_THEMECOMBO),
445 GetDlgItem (dialog, IDC_THEME_COLORCOMBO),
446 GetDlgItem (dialog, IDC_THEME_SIZECOMBO)))
447 {
448 SendMessageW (GetDlgItem (dialog, IDC_THEME_COLORCOMBO), CB_SETCURSEL, (WPARAM)-1, 0);
449 SendMessageW (GetDlgItem (dialog, IDC_THEME_SIZECOMBO), CB_SETCURSEL, (WPARAM)-1, 0);
450 enable_size_and_color_controls (dialog, FALSE);
451 }
452 else
453 {
454 enable_size_and_color_controls (dialog, TRUE);
455 }
456 theme_dirty = FALSE;
457
458 SendDlgItemMessageW(dialog, IDC_SYSPARAM_SIZE_UD, UDM_SETBUDDY, (WPARAM)GetDlgItem(dialog, IDC_SYSPARAM_SIZE), 0);
459 SendDlgItemMessageW(dialog, IDC_SYSPARAM_SIZE_UD, UDM_SETRANGE, 0, MAKELONG(100, 8));
460
461 updating_ui = FALSE;
462 }
463
464 static void on_theme_changed(HWND dialog) {
465 int index = SendMessageW (GetDlgItem (dialog, IDC_THEME_THEMECOMBO),
466 CB_GETCURSEL, 0, 0);
467 if (!update_color_and_size (index, GetDlgItem (dialog, IDC_THEME_COLORCOMBO),
468 GetDlgItem (dialog, IDC_THEME_SIZECOMBO)))
469 {
470 SendMessageW (GetDlgItem (dialog, IDC_THEME_COLORCOMBO), CB_SETCURSEL, -1, 0);
471 SendMessageW (GetDlgItem (dialog, IDC_THEME_SIZECOMBO), CB_SETCURSEL, -1, 0);
472 enable_size_and_color_controls (dialog, FALSE);
473 }
474 else
475 {
476 enable_size_and_color_controls (dialog, TRUE);
477 }
478 theme_dirty = TRUE;
479 }
480
481 static void apply_theme(HWND dialog)
482 {
483 int themeIndex, colorIndex, sizeIndex;
484
485 if (!theme_dirty) return;
486
487 themeIndex = SendMessageW (GetDlgItem (dialog, IDC_THEME_THEMECOMBO),
488 CB_GETCURSEL, 0, 0);
489 colorIndex = SendMessageW (GetDlgItem (dialog, IDC_THEME_COLORCOMBO),
490 CB_GETCURSEL, 0, 0);
491 sizeIndex = SendMessageW (GetDlgItem (dialog, IDC_THEME_SIZECOMBO),
492 CB_GETCURSEL, 0, 0);
493
494 do_apply_theme (dialog, themeIndex, colorIndex, sizeIndex);
495 theme_dirty = FALSE;
496 }
497
498 static struct
499 {
500 int sm_idx, color_idx;
501 const char *color_reg;
502 int size;
503 COLORREF color;
504 LOGFONTW lf;
505 } metrics[] =
506 {
507 {-1, COLOR_BTNFACE, "ButtonFace" }, /* IDC_SYSPARAMS_BUTTON */
508 {-1, COLOR_BTNTEXT, "ButtonText" }, /* IDC_SYSPARAMS_BUTTON_TEXT */
509 {-1, COLOR_BACKGROUND, "Background" }, /* IDC_SYSPARAMS_DESKTOP */
510 {SM_CXMENUSIZE, COLOR_MENU, "Menu" }, /* IDC_SYSPARAMS_MENU */
511 {-1, COLOR_MENUTEXT, "MenuText" }, /* IDC_SYSPARAMS_MENU_TEXT */
512 {SM_CXVSCROLL, COLOR_SCROLLBAR, "Scrollbar" }, /* IDC_SYSPARAMS_SCROLLBAR */
513 {-1, COLOR_HIGHLIGHT, "Hilight" }, /* IDC_SYSPARAMS_SELECTION */
514 {-1, COLOR_HIGHLIGHTTEXT, "HilightText" }, /* IDC_SYSPARAMS_SELECTION_TEXT */
515 {-1, COLOR_INFOBK, "InfoWindow" }, /* IDC_SYSPARAMS_TOOLTIP */
516 {-1, COLOR_INFOTEXT, "InfoText" }, /* IDC_SYSPARAMS_TOOLTIP_TEXT */
517 {-1, COLOR_WINDOW, "Window" }, /* IDC_SYSPARAMS_WINDOW */
518 {-1, COLOR_WINDOWTEXT, "WindowText" }, /* IDC_SYSPARAMS_WINDOW_TEXT */
519 {SM_CXSIZE, COLOR_ACTIVECAPTION, "ActiveTitle" }, /* IDC_SYSPARAMS_ACTIVE_TITLE */
520 {-1, COLOR_CAPTIONTEXT, "TitleText" }, /* IDC_SYSPARAMS_ACTIVE_TITLE_TEXT */
521 {-1, COLOR_INACTIVECAPTION, "InactiveTitle" }, /* IDC_SYSPARAMS_INACTIVE_TITLE */
522 {-1, COLOR_INACTIVECAPTIONTEXT,"InactiveTitleText" }, /* IDC_SYSPARAMS_INACTIVE_TITLE_TEXT */
523 {-1, -1, "MsgBoxText" }, /* IDC_SYSPARAMS_MSGBOX_TEXT */
524 {-1, COLOR_APPWORKSPACE, "AppWorkSpace" }, /* IDC_SYSPARAMS_APPWORKSPACE */
525 {-1, COLOR_WINDOWFRAME, "WindowFrame" }, /* IDC_SYSPARAMS_WINDOW_FRAME */
526 {-1, COLOR_ACTIVEBORDER, "ActiveBorder" }, /* IDC_SYSPARAMS_ACTIVE_BORDER */
527 {-1, COLOR_INACTIVEBORDER, "InactiveBorder" }, /* IDC_SYSPARAMS_INACTIVE_BORDER */
528 {-1, COLOR_BTNSHADOW, "ButtonShadow" }, /* IDC_SYSPARAMS_BUTTON_SHADOW */
529 {-1, COLOR_GRAYTEXT, "GrayText" }, /* IDC_SYSPARAMS_GRAY_TEXT */
530 {-1, COLOR_BTNHIGHLIGHT, "ButtonHilight" }, /* IDC_SYSPARAMS_BUTTON_HIGHLIGHT */
531 {-1, COLOR_3DDKSHADOW, "ButtonDkShadow" }, /* IDC_SYSPARAMS_BUTTON_DARK_SHADOW */
532 {-1, COLOR_3DLIGHT, "ButtonLight" }, /* IDC_SYSPARAMS_BUTTON_LIGHT */
533 {-1, COLOR_ALTERNATEBTNFACE, "ButtonAlternateFace" }, /* IDC_SYSPARAMS_BUTTON_ALTERNATE */
534 {-1, COLOR_HOTLIGHT, "HotTrackingColor" }, /* IDC_SYSPARAMS_HOT_TRACKING */
535 {-1, COLOR_GRADIENTACTIVECAPTION, "GradientActiveTitle" }, /* IDC_SYSPARAMS_ACTIVE_TITLE_GRADIENT */
536 {-1, COLOR_GRADIENTINACTIVECAPTION, "GradientInactiveTitle" }, /* IDC_SYSPARAMS_INACTIVE_TITLE_GRADIENT */
537 {-1, COLOR_MENUHILIGHT, "MenuHilight" }, /* IDC_SYSPARAMS_MENU_HIGHLIGHT */
538 {-1, COLOR_MENUBAR, "MenuBar" }, /* IDC_SYSPARAMS_MENUBAR */
539 };
540
541 static void save_sys_color(int idx, COLORREF clr)
542 {
543 char buffer[13];
544
545 sprintf(buffer, "%d %d %d", GetRValue (clr), GetGValue (clr), GetBValue (clr));
546 set_reg_key(HKEY_CURRENT_USER, "Control Panel\\Colors", metrics[idx].color_reg, buffer);
547 }
548
549 static void set_color_from_theme(WCHAR *keyName, COLORREF color)
550 {
551 char *keyNameA = NULL;
552 int keyNameSize=0, i=0;
553
554 keyNameSize = WideCharToMultiByte(CP_ACP, 0, keyName, -1, keyNameA, 0, NULL, NULL);
555 keyNameA = HeapAlloc(GetProcessHeap(), 0, keyNameSize);
556 WideCharToMultiByte(CP_ACP, 0, keyName, -1, keyNameA, keyNameSize, NULL, NULL);
557
558 for (i=0; i < ARRAY_SIZE(metrics); i++)
559 {
560 if (lstrcmpiA(metrics[i].color_reg, keyNameA)==0)
561 {
562 metrics[i].color = color;
563 save_sys_color(i, color);
564 break;
565 }
566 }
567 HeapFree(GetProcessHeap(), 0, keyNameA);
568 }
569
570 static void do_parse_theme(WCHAR *file)
571 {
572 static const WCHAR colorSect[] = {
573 'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
574 'C','o','l','o','r','s',0};
575 WCHAR keyName[MAX_PATH], keyNameValue[MAX_PATH];
576 WCHAR *keyNamePtr = NULL;
577 char *keyNameValueA = NULL;
578 int keyNameValueSize = 0;
579 int red = 0, green = 0, blue = 0;
580 COLORREF color;
581
582 WINE_TRACE("%s\n", wine_dbgstr_w(file));
583
584 GetPrivateProfileStringW(colorSect, NULL, NULL, keyName,
585 MAX_PATH, file);
586
587 keyNamePtr = keyName;
588 while (*keyNamePtr!=0) {
589 GetPrivateProfileStringW(colorSect, keyNamePtr, NULL, keyNameValue,
590 MAX_PATH, file);
591
592 keyNameValueSize = WideCharToMultiByte(CP_ACP, 0, keyNameValue, -1,
593 keyNameValueA, 0, NULL, NULL);
594 keyNameValueA = HeapAlloc(GetProcessHeap(), 0, keyNameValueSize);
595 WideCharToMultiByte(CP_ACP, 0, keyNameValue, -1, keyNameValueA, keyNameValueSize, NULL, NULL);
596
597 WINE_TRACE("parsing key: %s with value: %s\n",
598 wine_dbgstr_w(keyNamePtr), wine_dbgstr_w(keyNameValue));
599
600 sscanf(keyNameValueA, "%d %d %d", &red, &green, &blue);
601
602 color = RGB((BYTE)red, (BYTE)green, (BYTE)blue);
603
604 HeapFree(GetProcessHeap(), 0, keyNameValueA);
605
606 set_color_from_theme(keyNamePtr, color);
607
608 keyNamePtr+=lstrlenW(keyNamePtr);
609 keyNamePtr++;
610 }
611 }
612
613 static void on_theme_install(HWND dialog)
614 {
615 static const WCHAR filterMask[] = {0,'*','.','m','s','s','t','y','l','e','s',';',
616 '*','.','t','h','e','m','e',0,0};
617 static const WCHAR themeExt[] = {'.','T','h','e','m','e',0};
618 const int filterMaskLen = ARRAY_SIZE(filterMask);
619 OPENFILENAMEW ofn;
620 WCHAR filetitle[MAX_PATH];
621 WCHAR file[MAX_PATH];
622 WCHAR filter[100];
623 WCHAR title[100];
624
625 LoadStringW(GetModuleHandleW(NULL), IDS_THEMEFILE, filter, ARRAY_SIZE(filter) - filterMaskLen);
626 memcpy(filter + lstrlenW (filter), filterMask, filterMaskLen * sizeof (WCHAR));
627 LoadStringW(GetModuleHandleW(NULL), IDS_THEMEFILE_SELECT, title, ARRAY_SIZE(title));
628
629 ofn.lStructSize = sizeof(OPENFILENAMEW);
630 ofn.hwndOwner = dialog;
631 ofn.hInstance = 0;
632 ofn.lpstrFilter = filter;
633 ofn.lpstrCustomFilter = NULL;
634 ofn.nMaxCustFilter = 0;
635 ofn.nFilterIndex = 0;
636 ofn.lpstrFile = file;
637 ofn.lpstrFile[0] = '\0';
638 ofn.nMaxFile = sizeof(file)/sizeof(filetitle[0]);
639 ofn.lpstrFileTitle = filetitle;
640 ofn.lpstrFileTitle[0] = '\0';
641 ofn.nMaxFileTitle = ARRAY_SIZE(filetitle);
642 ofn.lpstrInitialDir = NULL;
643 ofn.lpstrTitle = title;
644 ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_ENABLESIZING;
645 ofn.nFileOffset = 0;
646 ofn.nFileExtension = 0;
647 ofn.lpstrDefExt = NULL;
648 ofn.lCustData = 0;
649 ofn.lpfnHook = NULL;
650 ofn.lpTemplateName = NULL;
651
652 if (GetOpenFileNameW(&ofn))
653 {
654 static const WCHAR themesSubdir[] = { '\\','T','h','e','m','e','s',0 };
655 static const WCHAR backslash[] = { '\\',0 };
656 WCHAR themeFilePath[MAX_PATH];
657 SHFILEOPSTRUCTW shfop;
658
659 if (FAILED (SHGetFolderPathW (NULL, CSIDL_RESOURCES|CSIDL_FLAG_CREATE, NULL,
660 SHGFP_TYPE_CURRENT, themeFilePath))) return;
661
662 if (lstrcmpiW(PathFindExtensionW(filetitle), themeExt)==0)
663 {
664 do_parse_theme(file);
665 SendMessageW(GetParent(dialog), PSM_CHANGED, 0, 0);
666 return;
667 }
668
669 PathRemoveExtensionW (filetitle);
670
671 /* Construct path into which the theme file goes */
672 lstrcatW (themeFilePath, themesSubdir);
673 lstrcatW (themeFilePath, backslash);
674 lstrcatW (themeFilePath, filetitle);
675
676 /* Create the directory */
677 SHCreateDirectoryExW (dialog, themeFilePath, NULL);
678
679 /* Append theme file name itself */
680 lstrcatW (themeFilePath, backslash);
681 lstrcatW (themeFilePath, PathFindFileNameW (file));
682 /* SHFileOperation() takes lists as input, so double-nullterminate */
683 themeFilePath[lstrlenW (themeFilePath)+1] = 0;
684 file[lstrlenW (file)+1] = 0;
685
686 /* Do the copying */
687 WINE_TRACE("copying: %s -> %s\n", wine_dbgstr_w (file),
688 wine_dbgstr_w (themeFilePath));
689 shfop.hwnd = dialog;
690 shfop.wFunc = FO_COPY;
691 shfop.pFrom = file;
692 shfop.pTo = themeFilePath;
693 shfop.fFlags = FOF_NOCONFIRMMKDIR;
694 if (SHFileOperationW (&shfop) == 0)
695 {
696 scan_theme_files();
697 if (!fill_theme_list (GetDlgItem (dialog, IDC_THEME_THEMECOMBO),
698 GetDlgItem (dialog, IDC_THEME_COLORCOMBO),
699 GetDlgItem (dialog, IDC_THEME_SIZECOMBO)))
700 {
701 SendMessageW (GetDlgItem (dialog, IDC_THEME_COLORCOMBO), CB_SETCURSEL, -1, 0);
702 SendMessageW (GetDlgItem (dialog, IDC_THEME_SIZECOMBO), CB_SETCURSEL, -1, 0);
703 enable_size_and_color_controls (dialog, FALSE);
704 }
705 else
706 {
707 enable_size_and_color_controls (dialog, TRUE);
708 }
709 }
710 else
711 WINE_TRACE("copy operation failed\n");
712 }
713 else WINE_TRACE("user cancelled\n");
714 }
715
716 /* Information about symbolic link targets of certain User Shell Folders. */
717 struct ShellFolderInfo {
718 int nFolder;
719 char szLinkTarget[FILENAME_MAX]; /* in unix locale */
720 };
721
722 static struct ShellFolderInfo asfiInfo[] = {
723 { CSIDL_DESKTOP, "" },
724 { CSIDL_PERSONAL, "" },
725 { CSIDL_MYPICTURES, "" },
726 { CSIDL_MYMUSIC, "" },
727 { CSIDL_MYVIDEO, "" }
728 };
729
730 static struct ShellFolderInfo *psfiSelected = NULL;
731
732 #define NUM_ELEMS(x) (sizeof(x)/sizeof(*(x)))
733
734 static void init_shell_folder_listview_headers(HWND dialog) {
735 LVCOLUMNW listColumn;
736 RECT viewRect;
737 WCHAR szShellFolder[64] = {'S','h','e','l','l',' ','F','o','l','d','e','r',0};
738 WCHAR szLinksTo[64] = {'L','i','n','k','s',' ','t','o',0};
739 int width;
740
741 LoadStringW(GetModuleHandleW(NULL), IDS_SHELL_FOLDER, szShellFolder, ARRAY_SIZE(szShellFolder));
742 LoadStringW(GetModuleHandleW(NULL), IDS_LINKS_TO, szLinksTo, ARRAY_SIZE(szLinksTo));
743
744 GetClientRect(GetDlgItem(dialog, IDC_LIST_SFPATHS), &viewRect);
745 width = (viewRect.right - viewRect.left) / 3;
746
747 listColumn.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
748 listColumn.pszText = szShellFolder;
749 listColumn.cchTextMax = strlenW(listColumn.pszText);
750 listColumn.cx = width;
751
752 SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_INSERTCOLUMNW, 0, (LPARAM) &listColumn);
753
754 listColumn.pszText = szLinksTo;
755 listColumn.cchTextMax = strlenW(listColumn.pszText);
756 listColumn.cx = viewRect.right - viewRect.left - width - 1;
757
758 SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_INSERTCOLUMNW, 1, (LPARAM) &listColumn);
759 }
760
761 /* Reads the currently set shell folder symbol link targets into asfiInfo. */
762 static void read_shell_folder_link_targets(void) {
763 WCHAR wszPath[MAX_PATH];
764 HRESULT hr;
765 int i;
766
767 for (i=0; i<NUM_ELEMS(asfiInfo); i++) {
768 asfiInfo[i].szLinkTarget[0] = '\0';
769 hr = SHGetFolderPathW(NULL, asfiInfo[i].nFolder|CSIDL_FLAG_DONT_VERIFY, NULL,
770 SHGFP_TYPE_CURRENT, wszPath);
771 if (SUCCEEDED(hr)) {
772 char *pszUnixPath = wine_get_unix_file_name(wszPath);
773 if (pszUnixPath) {
774 struct stat statPath;
775 if (!lstat(pszUnixPath, &statPath) && S_ISLNK(statPath.st_mode)) {
776 int cLen = readlink(pszUnixPath, asfiInfo[i].szLinkTarget, FILENAME_MAX-1);
777 if (cLen >= 0) asfiInfo[i].szLinkTarget[cLen] = '\0';
778 }
779 HeapFree(GetProcessHeap(), 0, pszUnixPath);
780 }
781 }
782 }
783 }
784
785 static void update_shell_folder_listview(HWND dialog) {
786 int i;
787 LVITEMW item;
788 LONG lSelected = SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_GETNEXTITEM, -1,
789 MAKELPARAM(LVNI_SELECTED,0));
790
791 SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_DELETEALLITEMS, 0, 0);
792
793 for (i=0; i<NUM_ELEMS(asfiInfo); i++) {
794 WCHAR buffer[MAX_PATH];
795 HRESULT hr;
796 LPITEMIDLIST pidlCurrent;
797
798 /* Some acrobatic to get the localized name of the shell folder */
799 hr = SHGetFolderLocation(dialog, asfiInfo[i].nFolder, NULL, 0, &pidlCurrent);
800 if (SUCCEEDED(hr)) {
801 LPSHELLFOLDER psfParent;
802 LPCITEMIDLIST pidlLast;
803 hr = SHBindToParent(pidlCurrent, &IID_IShellFolder, (LPVOID*)&psfParent, &pidlLast);
804 if (SUCCEEDED(hr)) {
805 STRRET strRet;
806 hr = IShellFolder_GetDisplayNameOf(psfParent, pidlLast, SHGDN_FORADDRESSBAR, &strRet);
807 if (SUCCEEDED(hr)) {
808 hr = StrRetToBufW(&strRet, pidlLast, buffer, MAX_PATH);
809 }
810 IShellFolder_Release(psfParent);
811 }
812 ILFree(pidlCurrent);
813 }
814
815 /* If there's a dangling symlink for the current shell folder, SHGetFolderLocation
816 * will fail above. We fall back to the (non-verified) path of the shell folder. */
817 if (FAILED(hr)) {
818 hr = SHGetFolderPathW(dialog, asfiInfo[i].nFolder|CSIDL_FLAG_DONT_VERIFY, NULL,
819 SHGFP_TYPE_CURRENT, buffer);
820 }
821
822 item.mask = LVIF_TEXT | LVIF_PARAM;
823 item.iItem = i;
824 item.iSubItem = 0;
825 item.pszText = buffer;
826 item.lParam = (LPARAM)&asfiInfo[i];
827 SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_INSERTITEMW, 0, (LPARAM)&item);
828
829 item.mask = LVIF_TEXT;
830 item.iItem = i;
831 item.iSubItem = 1;
832 item.pszText = strdupU2W(asfiInfo[i].szLinkTarget);
833 SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_SETITEMW, 0, (LPARAM)&item);
834 HeapFree(GetProcessHeap(), 0, item.pszText);
835 }
836
837 /* Ensure that the previously selected item is selected again. */
838 if (lSelected >= 0) {
839 item.mask = LVIF_STATE;
840 item.state = LVIS_SELECTED;
841 item.stateMask = LVIS_SELECTED;
842 SendDlgItemMessageW(dialog, IDC_LIST_SFPATHS, LVM_SETITEMSTATE, lSelected, (LPARAM)&item);
843 }
844 }
845
846 static void on_shell_folder_selection_changed(HWND hDlg, LPNMLISTVIEW lpnm) {
847 if (lpnm->uNewState & LVIS_SELECTED) {
848 psfiSelected = (struct ShellFolderInfo *)lpnm->lParam;
849 EnableWindow(GetDlgItem(hDlg, IDC_LINK_SFPATH), 1);
850 if (strlen(psfiSelected->szLinkTarget)) {
851 WCHAR *link;
852 CheckDlgButton(hDlg, IDC_LINK_SFPATH, BST_CHECKED);
853 EnableWindow(GetDlgItem(hDlg, IDC_EDIT_SFPATH), 1);
854 EnableWindow(GetDlgItem(hDlg, IDC_BROWSE_SFPATH), 1);
855 link = strdupU2W(psfiSelected->szLinkTarget);
856 set_textW(hDlg, IDC_EDIT_SFPATH, link);
857 HeapFree(GetProcessHeap(), 0, link);
858 } else {
859 CheckDlgButton(hDlg, IDC_LINK_SFPATH, BST_UNCHECKED);
860 EnableWindow(GetDlgItem(hDlg, IDC_EDIT_SFPATH), 0);
861 EnableWindow(GetDlgItem(hDlg, IDC_BROWSE_SFPATH), 0);
862 set_text(hDlg, IDC_EDIT_SFPATH, "");
863 }
864 } else {
865 psfiSelected = NULL;
866 CheckDlgButton(hDlg, IDC_LINK_SFPATH, BST_UNCHECKED);
867 set_text(hDlg, IDC_EDIT_SFPATH, "");
868 EnableWindow(GetDlgItem(hDlg, IDC_LINK_SFPATH), 0);
869 EnableWindow(GetDlgItem(hDlg, IDC_EDIT_SFPATH), 0);
870 EnableWindow(GetDlgItem(hDlg, IDC_BROWSE_SFPATH), 0);
871 }
872 }
873
874 /* Keep the contents of the edit control, the listview control and the symlink
875 * information in sync. */
876 static void on_shell_folder_edit_changed(HWND hDlg) {
877 LVITEMW item;
878 WCHAR *text = get_textW(hDlg, IDC_EDIT_SFPATH);
879 LONG iSel = SendDlgItemMessageW(hDlg, IDC_LIST_SFPATHS, LVM_GETNEXTITEM, -1,
880 MAKELPARAM(LVNI_SELECTED,0));
881
882 if (!text || !psfiSelected || iSel < 0) {
883 HeapFree(GetProcessHeap(), 0, text);
884 return;
885 }
886
887 WideCharToMultiByte(CP_UNIXCP, 0, text, -1,
888 psfiSelected->szLinkTarget, FILENAME_MAX, NULL, NULL);
889
890 item.mask = LVIF_TEXT;
891 item.iItem = iSel;
892 item.iSubItem = 1;
893 item.pszText = text;
894 SendDlgItemMessageW(hDlg, IDC_LIST_SFPATHS, LVM_SETITEMW, 0, (LPARAM)&item);
895
896 HeapFree(GetProcessHeap(), 0, text);
897
898 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
899 }
900
901 static void apply_shell_folder_changes(void) {
902 WCHAR wszPath[MAX_PATH];
903 char szBackupPath[FILENAME_MAX], szUnixPath[FILENAME_MAX], *pszUnixPath = NULL;
904 int i;
905 struct stat statPath;
906 HRESULT hr;
907
908 for (i=0; i<NUM_ELEMS(asfiInfo); i++) {
909 /* Ignore nonexistent link targets */
910 if (asfiInfo[i].szLinkTarget[0] && stat(asfiInfo[i].szLinkTarget, &statPath))
911 continue;
912
913 hr = SHGetFolderPathW(NULL, asfiInfo[i].nFolder|CSIDL_FLAG_CREATE, NULL,
914 SHGFP_TYPE_CURRENT, wszPath);
915 if (FAILED(hr)) continue;
916
917 /* Retrieve the corresponding unix path. */
918 pszUnixPath = wine_get_unix_file_name(wszPath);
919 if (!pszUnixPath) continue;
920 lstrcpyA(szUnixPath, pszUnixPath);
921 HeapFree(GetProcessHeap(), 0, pszUnixPath);
922
923 /* Derive name for folder backup. */
924 lstrcpyA(szBackupPath, szUnixPath);
925 lstrcatA(szBackupPath, ".winecfg");
926
927 if (lstat(szUnixPath, &statPath)) continue;
928
929 /* Move old folder/link out of the way. */
930 if (S_ISLNK(statPath.st_mode)) {
931 if (unlink(szUnixPath)) continue; /* Unable to remove link. */
932 } else {
933 if (!*asfiInfo[i].szLinkTarget) {
934 continue; /* We are done. Old was real folder, as new shall be. */
935 } else {
936 if (rename(szUnixPath, szBackupPath)) { /* Move folder out of the way. */
937 continue; /* Unable to move old folder. */
938 }
939 }
940 }
941
942 /* Create new link/folder. */
943 if (*asfiInfo[i].szLinkTarget) {
944 symlink(asfiInfo[i].szLinkTarget, szUnixPath);
945 } else {
946 /* If there's a backup folder, restore it. Else create new folder. */
947 if (!lstat(szBackupPath, &statPath) && S_ISDIR(statPath.st_mode)) {
948 rename(szBackupPath, szUnixPath);
949 } else {
950 mkdir(szUnixPath, 0777);
951 }
952 }
953 }
954 }
955
956 static void refresh_sysparams(HWND hDlg)
957 {
958 int i;
959
960 for (i = 0; i < ARRAY_SIZE(metrics); i++)
961 {
962 if (metrics[i].sm_idx != -1)
963 metrics[i].size = GetSystemMetrics(metrics[i].sm_idx);
964 if (metrics[i].color_idx != -1)
965 metrics[i].color = GetSysColor(metrics[i].color_idx);
966 }
967
968 on_sysparam_change(hDlg);
969 }
970
971 static void read_sysparams(HWND hDlg)
972 {
973 WCHAR buffer[256];
974 HWND list = GetDlgItem(hDlg, IDC_SYSPARAM_COMBO);
975 NONCLIENTMETRICSW nonclient_metrics;
976 int i, idx;
977
978 for (i = 0; i < ARRAY_SIZE(metrics); i++)
979 {
980 LoadStringW(GetModuleHandleW(NULL), i + IDC_SYSPARAMS_BUTTON, buffer, ARRAY_SIZE(buffer));
981 idx = SendMessageW(list, CB_ADDSTRING, 0, (LPARAM)buffer);
982 if (idx != CB_ERR) SendMessageW(list, CB_SETITEMDATA, idx, i);
983
984 if (metrics[i].sm_idx != -1)
985 metrics[i].size = GetSystemMetrics(metrics[i].sm_idx);
986 if (metrics[i].color_idx != -1)
987 metrics[i].color = GetSysColor(metrics[i].color_idx);
988 }
989
990 nonclient_metrics.cbSize = sizeof(NONCLIENTMETRICSW);
991 SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSW), &nonclient_metrics, 0);
992
993 memcpy(&(metrics[IDC_SYSPARAMS_MENU_TEXT - IDC_SYSPARAMS_BUTTON].lf),
994 &(nonclient_metrics.lfMenuFont), sizeof(LOGFONTW));
995 memcpy(&(metrics[IDC_SYSPARAMS_ACTIVE_TITLE_TEXT - IDC_SYSPARAMS_BUTTON].lf),
996 &(nonclient_metrics.lfCaptionFont), sizeof(LOGFONTW));
997 memcpy(&(metrics[IDC_SYSPARAMS_TOOLTIP_TEXT - IDC_SYSPARAMS_BUTTON].lf),
998 &(nonclient_metrics.lfStatusFont), sizeof(LOGFONTW));
999 memcpy(&(metrics[IDC_SYSPARAMS_MSGBOX_TEXT - IDC_SYSPARAMS_BUTTON].lf),
1000 &(nonclient_metrics.lfMessageFont), sizeof(LOGFONTW));
1001 }
1002
1003 static void apply_sysparams(void)
1004 {
1005 NONCLIENTMETRICSW ncm;
1006 int i, cnt = 0;
1007 int colors_idx[ARRAY_SIZE(metrics)];
1008 COLORREF colors[ARRAY_SIZE(metrics)];
1009 HDC hdc;
1010 int dpi;
1011
1012 hdc = GetDC( 0 );
1013 dpi = GetDeviceCaps( hdc, LOGPIXELSY );
1014 ReleaseDC( 0, hdc );
1015
1016 ncm.cbSize = sizeof(ncm);
1017 SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
1018
1019 /* convert metrics back to twips */
1020 ncm.iMenuWidth = ncm.iMenuHeight =
1021 MulDiv( metrics[IDC_SYSPARAMS_MENU - IDC_SYSPARAMS_BUTTON].size, -1440, dpi );
1022 ncm.iCaptionWidth = ncm.iCaptionHeight =
1023 MulDiv( metrics[IDC_SYSPARAMS_ACTIVE_TITLE - IDC_SYSPARAMS_BUTTON].size, -1440, dpi );
1024 ncm.iScrollWidth = ncm.iScrollHeight =
1025 MulDiv( metrics[IDC_SYSPARAMS_SCROLLBAR - IDC_SYSPARAMS_BUTTON].size, -1440, dpi );
1026 ncm.iSmCaptionWidth = MulDiv( ncm.iSmCaptionWidth, -1440, dpi );
1027 ncm.iSmCaptionHeight = MulDiv( ncm.iSmCaptionHeight, -1440, dpi );
1028
1029 ncm.lfMenuFont = metrics[IDC_SYSPARAMS_MENU_TEXT - IDC_SYSPARAMS_BUTTON].lf;
1030 ncm.lfCaptionFont = metrics[IDC_SYSPARAMS_ACTIVE_TITLE_TEXT - IDC_SYSPARAMS_BUTTON].lf;
1031 ncm.lfStatusFont = metrics[IDC_SYSPARAMS_TOOLTIP_TEXT - IDC_SYSPARAMS_BUTTON].lf;
1032 ncm.lfMessageFont = metrics[IDC_SYSPARAMS_MSGBOX_TEXT - IDC_SYSPARAMS_BUTTON].lf;
1033
1034 ncm.lfMenuFont.lfHeight = MulDiv( ncm.lfMenuFont.lfHeight, -72, dpi );
1035 ncm.lfCaptionFont.lfHeight = MulDiv( ncm.lfCaptionFont.lfHeight, -72, dpi );
1036 ncm.lfStatusFont.lfHeight = MulDiv( ncm.lfStatusFont.lfHeight, -72, dpi );
1037 ncm.lfMessageFont.lfHeight = MulDiv( ncm.lfMessageFont.lfHeight, -72, dpi );
1038 ncm.lfSmCaptionFont.lfHeight = MulDiv( ncm.lfSmCaptionFont.lfHeight, -72, dpi );
1039
1040 SystemParametersInfoW(SPI_SETNONCLIENTMETRICS, sizeof(ncm), &ncm,
1041 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
1042
1043 for (i = 0; i < ARRAY_SIZE(metrics); i++)
1044 if (metrics[i].color_idx != -1)
1045 {
1046 colors_idx[cnt] = metrics[i].color_idx;
1047 colors[cnt++] = metrics[i].color;
1048 }
1049 SetSysColors(cnt, colors_idx, colors);
1050 }
1051
1052 static void on_sysparam_change(HWND hDlg)
1053 {
1054 int index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETCURSEL, 0, 0);
1055
1056 index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETITEMDATA, index, 0);
1057
1058 updating_ui = TRUE;
1059
1060 EnableWindow(GetDlgItem(hDlg, IDC_SYSPARAM_COLOR_TEXT), metrics[index].color_idx != -1);
1061 EnableWindow(GetDlgItem(hDlg, IDC_SYSPARAM_COLOR), metrics[index].color_idx != -1);
1062 InvalidateRect(GetDlgItem(hDlg, IDC_SYSPARAM_COLOR), NULL, TRUE);
1063
1064 EnableWindow(GetDlgItem(hDlg, IDC_SYSPARAM_SIZE_TEXT), metrics[index].sm_idx != -1);
1065 EnableWindow(GetDlgItem(hDlg, IDC_SYSPARAM_SIZE), metrics[index].sm_idx != -1);
1066 EnableWindow(GetDlgItem(hDlg, IDC_SYSPARAM_SIZE_UD), metrics[index].sm_idx != -1);
1067 if (metrics[index].sm_idx != -1)
1068 SendDlgItemMessageW(hDlg, IDC_SYSPARAM_SIZE_UD, UDM_SETPOS, 0, MAKELONG(metrics[index].size, 0));
1069 else
1070 set_text(hDlg, IDC_SYSPARAM_SIZE, "");
1071
1072 EnableWindow(GetDlgItem(hDlg, IDC_SYSPARAM_FONT),
1073 index == IDC_SYSPARAMS_MENU_TEXT-IDC_SYSPARAMS_BUTTON ||
1074 index == IDC_SYSPARAMS_ACTIVE_TITLE_TEXT-IDC_SYSPARAMS_BUTTON ||
1075 index == IDC_SYSPARAMS_TOOLTIP_TEXT-IDC_SYSPARAMS_BUTTON ||
1076 index == IDC_SYSPARAMS_MSGBOX_TEXT-IDC_SYSPARAMS_BUTTON
1077 );
1078
1079 updating_ui = FALSE;
1080 }
1081
1082 static void on_draw_item(HWND hDlg, WPARAM wParam, LPARAM lParam)
1083 {
1084 static HBRUSH black_brush = 0;
1085 LPDRAWITEMSTRUCT draw_info = (LPDRAWITEMSTRUCT)lParam;
1086
1087 if (!black_brush) black_brush = CreateSolidBrush(0);
1088
1089 if (draw_info->CtlID == IDC_SYSPARAM_COLOR)
1090 {
1091 UINT state;
1092 HTHEME theme;
1093 RECT buttonrect;
1094
1095 theme = OpenThemeData(NULL, WC_BUTTONW);
1096
1097 if (theme) {
1098 MARGINS margins;
1099
1100 if (draw_info->itemState & ODS_DISABLED)
1101 state = PBS_DISABLED;
1102 else if (draw_info->itemState & ODS_SELECTED)
1103 state = PBS_PRESSED;
1104 else
1105 state = PBS_NORMAL;
1106
1107 if (IsThemeBackgroundPartiallyTransparent(theme, BP_PUSHBUTTON, state))
1108 DrawThemeParentBackground(draw_info->hwndItem, draw_info->hDC, NULL);
1109
1110 DrawThemeBackground(theme, draw_info->hDC, BP_PUSHBUTTON, state, &draw_info->rcItem, NULL);
1111
1112 buttonrect = draw_info->rcItem;
1113
1114 GetThemeMargins(theme, draw_info->hDC, BP_PUSHBUTTON, state, TMT_CONTENTMARGINS, &draw_info->rcItem, &margins);
1115
1116 buttonrect.left += margins.cxLeftWidth;
1117 buttonrect.top += margins.cyTopHeight;
1118 buttonrect.right -= margins.cxRightWidth;
1119 buttonrect.bottom -= margins.cyBottomHeight;
1120
1121 if (draw_info->itemState & ODS_FOCUS)
1122 DrawFocusRect(draw_info->hDC, &buttonrect);
1123
1124 CloseThemeData(theme);
1125 } else {
1126 state = DFCS_ADJUSTRECT | DFCS_BUTTONPUSH;
1127
1128 if (draw_info->itemState & ODS_DISABLED)
1129 state |= DFCS_INACTIVE;
1130 else
1131 state |= draw_info->itemState & ODS_SELECTED ? DFCS_PUSHED : 0;
1132
1133 DrawFrameControl(draw_info->hDC, &draw_info->rcItem, DFC_BUTTON, state);
1134
1135 buttonrect = draw_info->rcItem;
1136 }
1137
1138 if (!(draw_info->itemState & ODS_DISABLED))
1139 {
1140 HBRUSH brush;
1141 int index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETCURSEL, 0, 0);
1142
1143 index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETITEMDATA, index, 0);
1144 brush = CreateSolidBrush(metrics[index].color);
1145
1146 InflateRect(&buttonrect, -1, -1);
1147 FrameRect(draw_info->hDC, &buttonrect, black_brush);
1148 InflateRect(&buttonrect, -1, -1);
1149 FillRect(draw_info->hDC, &buttonrect, brush);
1150 DeleteObject(brush);
1151 }
1152 }
1153 }
1154
1155 static void on_select_font(HWND hDlg)
1156 {
1157 CHOOSEFONTW cf;
1158 int index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETCURSEL, 0, 0);
1159 index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETITEMDATA, index, 0);
1160
1161 ZeroMemory(&cf, sizeof(cf));
1162 cf.lStructSize = sizeof(CHOOSEFONTW);
1163 cf.hwndOwner = hDlg;
1164 cf.lpLogFont = &(metrics[index].lf);
1165 cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_NOSCRIPTSEL | CF_NOVERTFONTS;
1166
1167 if (ChooseFontW(&cf))
1168 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1169 }
1170
1171 INT_PTR CALLBACK
1172 ThemeDlgProc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
1173 {
1174 switch (uMsg) {
1175 case WM_INITDIALOG:
1176 read_shell_folder_link_targets();
1177 init_shell_folder_listview_headers(hDlg);
1178 update_shell_folder_listview(hDlg);
1179 read_sysparams(hDlg);
1180 break;
1181
1182 case WM_DESTROY:
1183 free_theme_files();
1184 break;
1185
1186 case WM_SHOWWINDOW:
1187 set_window_title(hDlg);
1188 break;
1189
1190 case WM_COMMAND:
1191 switch(HIWORD(wParam)) {
1192 case CBN_SELCHANGE: {
1193 if (updating_ui) break;
1194 switch (LOWORD(wParam))
1195 {
1196 case IDC_THEME_THEMECOMBO: on_theme_changed(hDlg); break;
1197 case IDC_THEME_COLORCOMBO: /* fall through */
1198 case IDC_THEME_SIZECOMBO: theme_dirty = TRUE; break;
1199 case IDC_SYSPARAM_COMBO: on_sysparam_change(hDlg); return FALSE;
1200 }
1201 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1202 break;
1203 }
1204 case EN_CHANGE: {
1205 if (updating_ui) break;
1206 switch (LOWORD(wParam))
1207 {
1208 case IDC_EDIT_SFPATH: on_shell_folder_edit_changed(hDlg); break;
1209 case IDC_SYSPARAM_SIZE:
1210 {
1211 char *text = get_text(hDlg, IDC_SYSPARAM_SIZE);
1212 int index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETCURSEL, 0, 0);
1213
1214 index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETITEMDATA, index, 0);
1215
1216 if (text)
1217 {
1218 metrics[index].size = atoi(text);
1219 HeapFree(GetProcessHeap(), 0, text);
1220 }
1221 else
1222 {
1223 /* for empty string set to minimum value */
1224 SendDlgItemMessageW(hDlg, IDC_SYSPARAM_SIZE_UD, UDM_GETRANGE32, (WPARAM)&metrics[index].size, 0);
1225 }
1226
1227 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1228 break;
1229 }
1230 }
1231 break;
1232 }
1233 case BN_CLICKED:
1234 switch (LOWORD(wParam))
1235 {
1236 case IDC_THEME_INSTALL:
1237 on_theme_install (hDlg);
1238 break;
1239
1240 case IDC_SYSPARAM_FONT:
1241 on_select_font(hDlg);
1242 break;
1243
1244 case IDC_BROWSE_SFPATH:
1245 {
1246 WCHAR link[FILENAME_MAX];
1247 if (browse_for_unix_folder(hDlg, link)) {
1248 WideCharToMultiByte(CP_UNIXCP, 0, link, -1,
1249 psfiSelected->szLinkTarget, FILENAME_MAX,
1250 NULL, NULL);
1251 update_shell_folder_listview(hDlg);
1252 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1253 }
1254 break;
1255 }
1256
1257 case IDC_LINK_SFPATH:
1258 if (IsDlgButtonChecked(hDlg, IDC_LINK_SFPATH)) {
1259 WCHAR link[FILENAME_MAX];
1260 if (browse_for_unix_folder(hDlg, link)) {
1261 WideCharToMultiByte(CP_UNIXCP, 0, link, -1,
1262 psfiSelected->szLinkTarget, FILENAME_MAX,
1263 NULL, NULL);
1264 update_shell_folder_listview(hDlg);
1265 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1266 } else {
1267 CheckDlgButton(hDlg, IDC_LINK_SFPATH, BST_UNCHECKED);
1268 }
1269 } else {
1270 psfiSelected->szLinkTarget[0] = '\0';
1271 update_shell_folder_listview(hDlg);
1272 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1273 }
1274 break;
1275
1276 case IDC_SYSPARAM_COLOR:
1277 {
1278 static COLORREF user_colors[16];
1279 CHOOSECOLORW c_color;
1280 int index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETCURSEL, 0, 0);
1281
1282 index = SendDlgItemMessageW(hDlg, IDC_SYSPARAM_COMBO, CB_GETITEMDATA, index, 0);
1283
1284 memset(&c_color, 0, sizeof(c_color));
1285 c_color.lStructSize = sizeof(c_color);
1286 c_color.lpCustColors = user_colors;
1287 c_color.rgbResult = metrics[index].color;
1288 c_color.Flags = CC_ANYCOLOR | CC_RGBINIT;
1289 c_color.hwndOwner = hDlg;
1290 if (ChooseColorW(&c_color))
1291 {
1292 metrics[index].color = c_color.rgbResult;
1293 save_sys_color(index, metrics[index].color);
1294 InvalidateRect(GetDlgItem(hDlg, IDC_SYSPARAM_COLOR), NULL, TRUE);
1295 SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0);
1296 }
1297 break;
1298 }
1299 }
1300 break;
1301 }
1302 break;
1303
1304 case WM_NOTIFY:
1305 switch (((LPNMHDR)lParam)->code) {
1306 case PSN_KILLACTIVE: {
1307 SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, FALSE);
1308 break;
1309 }
1310 case PSN_APPLY: {
1311 apply();
1312 apply_theme(hDlg);
1313 apply_shell_folder_changes();
1314 apply_sysparams();
1315 read_shell_folder_link_targets();
1316 update_shell_folder_listview(hDlg);
1317 SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
1318 break;
1319 }
1320 case LVN_ITEMCHANGED: {
1321 if (wParam == IDC_LIST_SFPATHS)
1322 on_shell_folder_selection_changed(hDlg, (LPNMLISTVIEW)lParam);
1323 break;
1324 }
1325 case PSN_SETACTIVE: {
1326 init_dialog (hDlg);
1327 break;
1328 }
1329 }
1330 break;
1331
1332 case WM_DRAWITEM:
1333 on_draw_item(hDlg, wParam, lParam);
1334 break;
1335
1336 default:
1337 break;
1338 }
1339 return FALSE;
1340 }
Windows API implementation