git.oblomov.eu Git - wine/blob - programs/winecfg/theme.c

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