dll/cpl/desk/background.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Display Control Panel
   4  * FILE:            dll/cpl/desk/background.c
   5  * PURPOSE:         Background property page
   6  *
   7  * PROGRAMMERS:     Trevor McCort (lycan359@gmail.com)
   8  *                  Alexey Minnekhanov (minlexx@rambler.ru)
   9  */
  10
  11 #include "desk.h"
  12
  13 #include <shellapi.h>
  14 #include <shlwapi.h>
  15
  16 #define MAX_BACKGROUNDS     100
  17
  18 typedef enum
  19 {
  20     PLACEMENT_CENTER = 0,
  21     PLACEMENT_STRETCH,
  22     PLACEMENT_TILE,
  23     PLACEMENT_FIT,
  24     PLACEMENT_FILL
  25 } PLACEMENT;
  26
  27 /* The tile placement is stored in different registry
  28  * key, but due to a condition in win32k it needs to be
  29  * zero when stored in the same key as others.
  30  */
  31 typedef enum
  32 {
  33     PLACEMENT_VALUE_CENTER    = 0,
  34     PLACEMENT_VALUE_STRETCH   = 2,
  35     PLACEMENT_VALUE_TILE      = 0,
  36     PLACEMENT_VALUE_FIT       = 6,
  37     PLACEMENT_VALUE_FILL      = 10
  38 } PLACEMENT_VALUE;
  39
  40 /* The values in these macros are dependent on the
  41  * layout of the monitor image and they must be adjusted
  42  * if that image will be changed.
  43  */
  44 #define MONITOR_LEFT        18
  45 #define MONITOR_TOP         18
  46 #define MONITOR_RIGHT       168
  47 #define MONITOR_BOTTOM      128
  48
  49 #define MONITOR_WIDTH       (MONITOR_RIGHT-MONITOR_LEFT)
  50 #define MONITOR_HEIGHT      (MONITOR_BOTTOM-MONITOR_TOP)
  51
  52 typedef struct
  53 {
  54     BOOL bWallpaper; /* Is this background a wallpaper */
  55
  56     TCHAR szFilename[MAX_PATH];
  57     TCHAR szDisplayName[256];
  58
  59 } BackgroundItem;
  60
  61 typedef struct _BACKGROUND_DATA
  62 {
  63     BOOL bWallpaperChanged;
  64     BOOL bClrBackgroundChanged;
  65
  66     BackgroundItem backgroundItems[MAX_BACKGROUNDS];
  67
  68     PDIBITMAP pWallpaperBitmap;
  69
  70     int placementSelection;
  71     int backgroundSelection;
  72
  73     COLORREF custom_colors[16];
  74
  75     int listViewItemCount;
  76
  77     HBITMAP hBitmap;
  78     int cxSource;
  79     int cySource;
  80
  81     ULONG_PTR gdipToken;
  82 } BACKGROUND_DATA, *PBACKGROUND_DATA;
  83
  84 GLOBAL_DATA g_GlobalData;
  85
  86
  87 HRESULT
  88 GdipGetEncoderClsid(PCWSTR MimeType, CLSID *pClsid)
  89 {
  90     UINT num;
  91     UINT size;
  92     UINT i;
  93     ImageCodecInfo *codecInfo;
  94
  95     if (GdipGetImageEncodersSize(&num, &size) != Ok ||
  96         size == 0)
  97     {
  98         return E_FAIL;
  99     }
 100
 101     codecInfo = HeapAlloc(GetProcessHeap(), 0, size);
 102     if (!codecInfo)
 103     {
 104         return E_OUTOFMEMORY;
 105     }
 106
 107     if (GdipGetImageEncoders(num, size, codecInfo) != Ok)
 108     {
 109         HeapFree(GetProcessHeap(), 0, codecInfo);
 110         return E_FAIL;
 111     }
 112
 113     for (i = 0; i < num; i++)
 114     {
 115         if (!_wcsicmp(codecInfo[i].MimeType, MimeType))
 116         {
 117             *pClsid = codecInfo[i].Clsid;
 118             HeapFree(GetProcessHeap(), 0, codecInfo);
 119             return S_OK;
 120         }
 121     }
 122
 123     HeapFree(GetProcessHeap(), 0, codecInfo);
 124     return E_FAIL;
 125 }
 126
 127
 128 LPWSTR
 129 GdipGetSupportedFileExtensions(VOID)
 130 {
 131     ImageCodecInfo *codecInfo;
 132     UINT num;
 133     UINT size;
 134     UINT i;
 135     LPWSTR lpBuffer = NULL;
 136
 137     if (GdipGetImageDecodersSize(&num, &size) != Ok ||
 138         size == 0)
 139     {
 140         return NULL;
 141     }
 142
 143     codecInfo = HeapAlloc(GetProcessHeap(), 0, size);
 144     if (!codecInfo)
 145     {
 146         return NULL;
 147     }
 148
 149     if (GdipGetImageDecoders(num, size, codecInfo) != Ok)
 150     {
 151         HeapFree(GetProcessHeap(), 0, codecInfo);
 152         return NULL;
 153     }
 154
 155     size = 0;
 156     for (i = 0; i < num; ++i)
 157     {
 158         size = size + (UINT)wcslen(codecInfo[i].FilenameExtension) + 1;
 159     }
 160
 161     size = (size + 1) * sizeof(WCHAR);
 162
 163     lpBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 164     if (!lpBuffer)
 165     {
 166         HeapFree(GetProcessHeap(), 0, codecInfo);
 167         return NULL;
 168     }
 169
 170     for (i = 0; i < num; ++i)
 171     {
 172         StringCbCatW(lpBuffer, size, codecInfo[i].FilenameExtension);
 173         if (i < (num - 1))
 174         {
 175             StringCbCatW(lpBuffer, size, L";");
 176         }
 177     }
 178
 179     HeapFree(GetProcessHeap(), 0, codecInfo);
 180
 181     return lpBuffer;
 182 }
 183
 184
 185 static UINT
 186 AddWallpapersFromDirectory(UINT uCounter, HWND hwndBackgroundList, BackgroundItem *backgroundItem, PBACKGROUND_DATA pData, LPCTSTR wallpaperFilename, LPCTSTR wallpaperDirectory)
 187 {
 188     WIN32_FIND_DATA fd;
 189     HANDLE hFind;
 190     TCHAR szSearchPath[MAX_PATH];
 191     LPTSTR szFileTypes = NULL;
 192     TCHAR separators[] = TEXT(";");
 193     TCHAR *token;
 194     HRESULT hr;
 195     SHFILEINFO sfi;
 196     UINT i = uCounter;
 197     LV_ITEM listItem;
 198     HIMAGELIST himl;
 199
 200     szFileTypes = GdipGetSupportedFileExtensions();
 201     if (!szFileTypes)
 202     {
 203         return i;
 204     }
 205
 206     token = _tcstok(szFileTypes, separators);
 207     while (token != NULL)
 208     {
 209         if (!PathCombine(szSearchPath, wallpaperDirectory, token))
 210         {
 211             HeapFree(GetProcessHeap(), 0, szFileTypes);
 212             return i;
 213         }
 214
 215         hFind = FindFirstFile(szSearchPath, &fd);
 216         while (hFind != INVALID_HANDLE_VALUE)
 217         {
 218             TCHAR filename[MAX_PATH];
 219
 220             if (!PathCombine(filename, wallpaperDirectory, fd.cFileName))
 221             {
 222                 FindClose(hFind);
 223                 HeapFree(GetProcessHeap(), 0, szFileTypes);
 224                 return i;
 225             }
 226
 227             /* Don't add any hidden bitmaps. Also don't add current wallpaper once more. */
 228             if (((fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) == 0) && (_tcsicmp(wallpaperFilename, filename) != 0))
 229             {
 230                 himl = (HIMAGELIST)SHGetFileInfo(filename,
 231                                                 0,
 232                                                 &sfi,
 233                                                 sizeof(sfi),
 234                                                 SHGFI_SYSICONINDEX | SHGFI_SMALLICON |
 235                                                 SHGFI_DISPLAYNAME);
 236                 if (himl == NULL)
 237                     break;
 238
 239                 if (i++ == 0)
 240                 {
 241                     (void)ListView_SetImageList(hwndBackgroundList, himl, LVSIL_SMALL);
 242                 }
 243
 244                 backgroundItem = &pData->backgroundItems[pData->listViewItemCount];
 245
 246                 backgroundItem->bWallpaper = TRUE;
 247
 248                 hr = StringCbCopy(backgroundItem->szDisplayName, sizeof(backgroundItem->szDisplayName), sfi.szDisplayName);
 249                 if (FAILED(hr))
 250                 {
 251                     FindClose(hFind);
 252                     HeapFree(GetProcessHeap(), 0, szFileTypes);
 253                     return i;
 254                 }
 255
 256                 PathRemoveExtension(backgroundItem->szDisplayName);
 257
 258                 hr = StringCbCopy(backgroundItem->szFilename, sizeof(backgroundItem->szFilename), filename);
 259                 if (FAILED(hr))
 260                 {
 261                     FindClose(hFind);
 262                     HeapFree(GetProcessHeap(), 0, szFileTypes);
 263                     return i;
 264                 }
 265
 266                 ZeroMemory(&listItem, sizeof(LV_ITEM));
 267                 listItem.mask       = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
 268                 listItem.pszText    = backgroundItem->szDisplayName;
 269                 listItem.state      = 0;
 270                 listItem.iImage     = sfi.iIcon;
 271                 listItem.iItem      = pData->listViewItemCount;
 272                 listItem.lParam     = pData->listViewItemCount;
 273
 274                 (void)ListView_InsertItem(hwndBackgroundList, &listItem);
 275
 276                 pData->listViewItemCount++;
 277             }
 278
 279             if (!FindNextFile(hFind, &fd))
 280                 break;
 281         }
 282
 283         token = _tcstok(NULL, separators);
 284         FindClose(hFind);
 285     }
 286
 287     HeapFree(GetProcessHeap(), 0, szFileTypes);
 288
 289     return i;
 290 }
 291
 292
 293 /* Add the images in the C:\ReactOS, the wallpaper directory and the current wallpaper if any */
 294 static VOID
 295 AddListViewItems(HWND hwndDlg, PBACKGROUND_DATA pData)
 296 {
 297     TCHAR szSearchPath[MAX_PATH];
 298     LV_ITEM listItem;
 299     LV_COLUMN dummy;
 300     RECT clientRect;
 301     HKEY regKey;
 302     SHFILEINFO sfi;
 303     HIMAGELIST himl;
 304     TCHAR wallpaperFilename[MAX_PATH];
 305     TCHAR originalWallpaper[MAX_PATH];
 306     DWORD bufferSize = sizeof(wallpaperFilename);
 307     TCHAR buffer[MAX_PATH];
 308     DWORD varType = REG_SZ;
 309     LONG result;
 310     UINT i = 0;
 311     BackgroundItem *backgroundItem = NULL;
 312     HWND hwndBackgroundList;
 313     HRESULT hr;
 314
 315     hwndBackgroundList = GetDlgItem(hwndDlg, IDC_BACKGROUND_LIST);
 316
 317     GetClientRect(hwndBackgroundList, &clientRect);
 318
 319     /* Add a new column to the list */
 320     ZeroMemory(&dummy, sizeof(LV_COLUMN));
 321     dummy.mask      = LVCF_SUBITEM | LVCF_WIDTH;
 322     dummy.iSubItem  = 0;
 323     dummy.cx        = (clientRect.right - clientRect.left) - GetSystemMetrics(SM_CXVSCROLL);
 324     (void)ListView_InsertColumn(hwndBackgroundList, 0, &dummy);
 325
 326     /* Add the "None" item */
 327     backgroundItem = &pData->backgroundItems[pData->listViewItemCount];
 328     backgroundItem->bWallpaper = FALSE;
 329     LoadString(hApplet,
 330                IDS_NONE,
 331                backgroundItem->szDisplayName,
 332                sizeof(backgroundItem->szDisplayName) / sizeof(TCHAR));
 333
 334     ZeroMemory(&listItem, sizeof(LV_ITEM));
 335     listItem.mask       = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
 336     listItem.state      = 0;
 337     listItem.pszText    = backgroundItem->szDisplayName;
 338     listItem.iImage     = -1;
 339     listItem.iItem      = pData->listViewItemCount;
 340     listItem.lParam     = pData->listViewItemCount;
 341
 342     (void)ListView_InsertItem(hwndBackgroundList, &listItem);
 343     ListView_SetItemState(hwndBackgroundList,
 344                           pData->listViewItemCount,
 345                           LVIS_SELECTED,
 346                           LVIS_SELECTED);
 347
 348     pData->listViewItemCount++;
 349
 350     /* Add current wallpaper if any */
 351     result = RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Control Panel\\Desktop"), 0, KEY_QUERY_VALUE, &regKey);
 352     if (result == ERROR_SUCCESS)
 353     {
 354         result = RegQueryValueEx(regKey, TEXT("Wallpaper"), 0, &varType, (LPBYTE)wallpaperFilename, &bufferSize);
 355         if ((result == ERROR_SUCCESS) && (_tcslen(wallpaperFilename) > 0))
 356         {
 357             bufferSize = sizeof(originalWallpaper);
 358             result = RegQueryValueEx(regKey, TEXT("OriginalWallpaper"), 0, &varType, (LPBYTE)originalWallpaper, &bufferSize);
 359
 360             /* If Wallpaper and OriginalWallpaper are the same, try to retrieve ConvertedWallpaper and use it instead of Wallpaper */
 361             if ((result == ERROR_SUCCESS) && (_tcslen(originalWallpaper) > 0) && (_tcsicmp(wallpaperFilename, originalWallpaper) == 0))
 362             {
 363                 bufferSize = sizeof(originalWallpaper);
 364                 result = RegQueryValueEx(regKey, TEXT("ConvertedWallpaper"), 0, &varType, (LPBYTE)originalWallpaper, &bufferSize);
 365
 366                 if ((result == ERROR_SUCCESS) && (_tcslen(originalWallpaper) > 0))
 367                 {
 368                     hr = StringCbCopy(wallpaperFilename, sizeof(wallpaperFilename), originalWallpaper);
 369                     if (FAILED(hr))
 370                     {
 371                         RegCloseKey(regKey);
 372                         return;
 373                     }
 374                 }
 375             }
 376
 377             /* Allow environment variables in file name */
 378             if (ExpandEnvironmentStrings(wallpaperFilename, buffer, MAX_PATH))
 379             {
 380                 hr = StringCbCopy(wallpaperFilename, sizeof(wallpaperFilename), buffer);
 381                 if (FAILED(hr))
 382                 {
 383                     RegCloseKey(regKey);
 384                     return;
 385                 }
 386             }
 387
 388             himl = (HIMAGELIST)SHGetFileInfo(wallpaperFilename,
 389                                              0,
 390                                              &sfi,
 391                                              sizeof(sfi),
 392                                              SHGFI_SYSICONINDEX | SHGFI_SMALLICON |
 393                                              SHGFI_DISPLAYNAME);
 394             if (himl != NULL)
 395             {
 396                 if (i++ == 0)
 397                 {
 398                     (void)ListView_SetImageList(hwndBackgroundList, himl, LVSIL_SMALL);
 399                 }
 400
 401                 backgroundItem = &pData->backgroundItems[pData->listViewItemCount];
 402
 403                 backgroundItem->bWallpaper = TRUE;
 404
 405                 hr = StringCbCopy(backgroundItem->szDisplayName, sizeof(backgroundItem->szDisplayName), sfi.szDisplayName);
 406                 if (FAILED(hr))
 407                 {
 408                     RegCloseKey(regKey);
 409                     return;
 410                 }
 411
 412                 PathRemoveExtension(backgroundItem->szDisplayName);
 413
 414                 hr = StringCbCopy(backgroundItem->szFilename, sizeof(backgroundItem->szFilename), wallpaperFilename);
 415                 if (FAILED(hr))
 416                 {
 417                     RegCloseKey(regKey);
 418                     return;
 419                 }
 420
 421                 ZeroMemory(&listItem, sizeof(LV_ITEM));
 422                 listItem.mask       = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
 423                 listItem.state      = 0;
 424                 listItem.pszText    = backgroundItem->szDisplayName;
 425                 listItem.iImage     = sfi.iIcon;
 426                 listItem.iItem      = pData->listViewItemCount;
 427                 listItem.lParam     = pData->listViewItemCount;
 428
 429                 (void)ListView_InsertItem(hwndBackgroundList, &listItem);
 430                 ListView_SetItemState(hwndBackgroundList,
 431                                       pData->listViewItemCount,
 432                                       LVIS_SELECTED,
 433                                       LVIS_SELECTED);
 434
 435                 pData->listViewItemCount++;
 436             }
 437         }
 438
 439         RegCloseKey(regKey);
 440     }
 441
 442     /* Add all the images in the C:\ReactOS directory. */
 443     if (GetWindowsDirectory(szSearchPath, MAX_PATH))
 444     {
 445         i = AddWallpapersFromDirectory(i, hwndBackgroundList, backgroundItem, pData, wallpaperFilename, szSearchPath);
 446     }
 447
 448     /* Add all the images in the wallpaper directory. */
 449     if (SHRegGetPath(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion"), TEXT("WallPaperDir"), szSearchPath, 0) == ERROR_SUCCESS)
 450     {
 451         i = AddWallpapersFromDirectory(i, hwndBackgroundList, backgroundItem, pData, wallpaperFilename, szSearchPath);
 452     }
 453 }
 454
 455
 456 static VOID
 457 InitBackgroundDialog(HWND hwndDlg, PBACKGROUND_DATA pData)
 458 {
 459     TCHAR szString[256];
 460     HKEY regKey;
 461     TCHAR szBuffer[3];
 462     DWORD bufferSize = sizeof(szBuffer);
 463     BITMAP bitmap;
 464
 465     AddListViewItems(hwndDlg, pData);
 466
 467     LoadString(hApplet, IDS_CENTER, szString, sizeof(szString) / sizeof(TCHAR));
 468     SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_INSERTSTRING, PLACEMENT_CENTER, (LPARAM)szString);
 469
 470     LoadString(hApplet, IDS_STRETCH, szString, sizeof(szString) / sizeof(TCHAR));
 471     SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_INSERTSTRING, PLACEMENT_STRETCH, (LPARAM)szString);
 472
 473     LoadString(hApplet, IDS_TILE, szString, sizeof(szString) / sizeof(TCHAR));
 474     SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_INSERTSTRING, PLACEMENT_TILE, (LPARAM)szString);
 475
 476     LoadString(hApplet, IDS_FIT, szString, sizeof(szString) / sizeof(TCHAR));
 477     SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_INSERTSTRING, PLACEMENT_FIT, (LPARAM)szString);
 478
 479     LoadString(hApplet, IDS_FILL, szString, sizeof(szString) / sizeof(TCHAR));
 480     SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_INSERTSTRING, PLACEMENT_FILL, (LPARAM)szString);
 481
 482     SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_SETCURSEL, PLACEMENT_CENTER, 0);
 483     pData->placementSelection = PLACEMENT_CENTER;
 484
 485     pData->hBitmap = (HBITMAP) LoadImage(hApplet, MAKEINTRESOURCE(IDC_MONITOR), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
 486     if (pData->hBitmap != NULL)
 487     {
 488         GetObject(pData->hBitmap, sizeof(BITMAP), &bitmap);
 489
 490         pData->cxSource = bitmap.bmWidth;
 491         pData->cySource = bitmap.bmHeight;
 492     }
 493
 494     /* Load the default settings from the registry */
 495     if (RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Control Panel\\Desktop"), 0, KEY_QUERY_VALUE, &regKey) != ERROR_SUCCESS)
 496     {
 497         return;
 498     }
 499
 500     if (RegQueryValueEx(regKey, TEXT("WallpaperStyle"), 0, NULL, (LPBYTE)szBuffer, &bufferSize) == ERROR_SUCCESS)
 501     {
 502         if (_ttoi(szBuffer) == PLACEMENT_VALUE_CENTER)
 503         {
 504             SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_SETCURSEL, PLACEMENT_CENTER, 0);
 505             pData->placementSelection = PLACEMENT_CENTER;
 506         }
 507
 508         if (_ttoi(szBuffer) == PLACEMENT_VALUE_STRETCH)
 509         {
 510             SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_SETCURSEL, PLACEMENT_STRETCH, 0);
 511             pData->placementSelection = PLACEMENT_STRETCH;
 512         }
 513
 514         if (_ttoi(szBuffer) == PLACEMENT_VALUE_FIT)
 515         {
 516             SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_SETCURSEL, PLACEMENT_FIT, 0);
 517             pData->placementSelection = PLACEMENT_FIT;
 518         }
 519
 520         if (_ttoi(szBuffer) == PLACEMENT_VALUE_FILL)
 521         {
 522             SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_SETCURSEL, PLACEMENT_FILL, 0);
 523             pData->placementSelection = PLACEMENT_FILL;
 524         }
 525     }
 526
 527     if (RegQueryValueEx(regKey, TEXT("TileWallpaper"), 0, NULL, (LPBYTE)szBuffer, &bufferSize) == ERROR_SUCCESS)
 528     {
 529         if (_ttoi(szBuffer) == 1)
 530         {
 531             SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_SETCURSEL, PLACEMENT_TILE, 0);
 532             pData->placementSelection = PLACEMENT_TILE;
 533         }
 534     }
 535
 536     RegCloseKey(regKey);
 537 }
 538
 539
 540 static VOID
 541 OnColorButton(HWND hwndDlg, PBACKGROUND_DATA pData)
 542 {
 543     /* Load custom colors from Registry */
 544     HKEY hKey = NULL;
 545     LONG res = ERROR_SUCCESS;
 546     CHOOSECOLOR cc;
 547
 548     res = RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Control Panel\\Appearance"), 0, NULL,
 549                          REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE, NULL, &hKey, NULL);
 550     /* Now the key is either created or opened existing, if res == ERROR_SUCCESS */
 551     if (res == ERROR_SUCCESS)
 552     {
 553         /* Key opened */
 554         DWORD dwType = REG_BINARY;
 555         DWORD cbData = sizeof(pData->custom_colors);
 556         res = RegQueryValueEx(hKey, TEXT("CustomColors"), NULL, &dwType,
 557                               (LPBYTE)pData->custom_colors, &cbData);
 558         RegCloseKey(hKey);
 559         hKey = NULL;
 560     }
 561
 562     /* Launch ChooseColor() dialog */
 563
 564     cc.lStructSize = sizeof(CHOOSECOLOR);
 565     cc.hwndOwner = hwndDlg;
 566     cc.hInstance = NULL;
 567     cc.rgbResult = g_GlobalData.desktop_color;
 568     cc.lpCustColors = pData->custom_colors;
 569     cc.Flags = CC_ANYCOLOR | /* Causes the dialog box to display all available colors in the set of basic colors.  */
 570                CC_FULLOPEN | /* opens dialog in full size */
 571                CC_RGBINIT ;  /* init chosen color by rgbResult value */
 572     cc.lCustData = 0;
 573     cc.lpfnHook = NULL;
 574     cc.lpTemplateName = NULL;
 575     if (ChooseColor(&cc))
 576     {
 577         /* Save selected color to var */
 578         g_GlobalData.desktop_color = cc.rgbResult;
 579         pData->bClrBackgroundChanged = TRUE;
 580
 581         /* Apply button will be activated */
 582         PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 583
 584         /* Window will be updated :) */
 585         InvalidateRect(GetDlgItem(hwndDlg, IDC_BACKGROUND_PREVIEW), NULL, TRUE);
 586
 587         /* Save custom colors to reg. To this moment key must be created already. See above */
 588         res = RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Control Panel\\Appearance"), 0,
 589                            KEY_SET_VALUE, &hKey);
 590         if (res == ERROR_SUCCESS)
 591         {
 592             /* Key opened */
 593             RegSetValueEx(hKey, TEXT("CustomColors"), 0, REG_BINARY,
 594                           (LPBYTE)pData->custom_colors, sizeof(pData->custom_colors));
 595             RegCloseKey(hKey);
 596             hKey = NULL;
 597         }
 598     }
 599 }
 600
 601
 602 /*
 603  * ListView_FindItem() Macro: Searches for a list-view item with the specified
 604  * characteristics. Returns the index of the item if successful, or -1 otherwise
 605  */
 606 static BOOL
 607 CheckListViewFilenameExists(HWND hwndList, LPCTSTR tszFileName)
 608 {
 609     LVFINDINFO lvfi;
 610     int retVal;
 611
 612     lvfi.flags = LVFI_STRING; /* Search item by EXACT string */
 613     lvfi.psz   = tszFileName; /* String to search */
 614
 615     /* Other items of this structure are not valid, besacuse flags are not set. */
 616     retVal = ListView_FindItem(hwndList, -1, &lvfi);
 617     if (retVal != -1)
 618         return TRUE; /* item found! */
 619
 620     return FALSE; /* item not found. */
 621 }
 622
 623
 624 static VOID
 625 OnBrowseButton(HWND hwndDlg, PBACKGROUND_DATA pData)
 626 {
 627     OPENFILENAME ofn;
 628     TCHAR filename[MAX_PATH];
 629     TCHAR fileTitle[256];
 630     LPTSTR filter;
 631     LPTSTR extensions;
 632     BackgroundItem *backgroundItem = NULL;
 633     SHFILEINFO sfi;
 634     LV_ITEM listItem;
 635     HWND hwndBackgroundList;
 636     TCHAR *p;
 637     HRESULT hr;
 638     TCHAR filterdesc[MAX_PATH];
 639     TCHAR *c;
 640     size_t sizeRemain;
 641     SIZE_T buffersize;
 642     BOOL success;
 643
 644     hwndBackgroundList = GetDlgItem(hwndDlg, IDC_BACKGROUND_LIST);
 645
 646     ZeroMemory(&ofn, sizeof(OPENFILENAME));
 647
 648     ofn.lStructSize = sizeof(OPENFILENAME);
 649     ofn.hwndOwner = hwndDlg;
 650     ofn.lpstrFile = filename;
 651
 652     LoadString(hApplet, IDS_BACKGROUND_COMDLG_FILTER, filterdesc, sizeof(filterdesc) / sizeof(TCHAR));
 653
 654     extensions = GdipGetSupportedFileExtensions();
 655     if (!extensions)
 656     {
 657         return;
 658     }
 659
 660     buffersize = (_tcslen(extensions) * 2 + 6) * sizeof(TCHAR) + sizeof(filterdesc);
 661
 662     filter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buffersize);
 663     if (!filter)
 664     {
 665         HeapFree(GetProcessHeap(), 0, extensions);
 666         return;
 667     }
 668
 669     sizeRemain = buffersize;
 670     c = filter;
 671
 672     if (FAILED(StringCbPrintfEx(c, sizeRemain, &c, &sizeRemain, 0, L"%ls (%ls)", filterdesc, extensions)))
 673     {
 674         HeapFree(GetProcessHeap(), 0, extensions);
 675         HeapFree(GetProcessHeap(), 0, filter);
 676         return;
 677     }
 678
 679     c++;
 680     sizeRemain -= sizeof(*c);
 681
 682     if (FAILED(StringCbPrintfEx(c, sizeRemain, &c, &sizeRemain, 0, L"%ls", extensions)))
 683     {
 684         HeapFree(GetProcessHeap(), 0, extensions);
 685         HeapFree(GetProcessHeap(), 0, filter);
 686         return;
 687     }
 688
 689     HeapFree(GetProcessHeap(), 0, extensions);
 690
 691     /* Set lpstrFile[0] to '\0' so that GetOpenFileName does not
 692      * use the contents of szFile to initialize itself */
 693     ofn.lpstrFile[0] = TEXT('\0');
 694     ofn.nMaxFile = MAX_PATH;
 695     ofn.lpstrFilter = filter;
 696     ofn.nFilterIndex = 0;
 697     ofn.lpstrFileTitle = fileTitle;
 698     ofn.nMaxFileTitle = 256;
 699     ofn.lpstrInitialDir = NULL;
 700     ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
 701
 702     success = GetOpenFileName(&ofn);
 703     HeapFree(GetProcessHeap(), 0, filter);
 704
 705     if (success)
 706     {
 707         /* Check if there is already a entry that holds this filename */
 708         if (CheckListViewFilenameExists(hwndBackgroundList, ofn.lpstrFileTitle) != FALSE)
 709             return;
 710
 711         if (pData->listViewItemCount > (MAX_BACKGROUNDS - 1))
 712             return;
 713
 714         SHGetFileInfo(filename,
 715                       0,
 716                       &sfi,
 717                       sizeof(sfi),
 718                       SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_DISPLAYNAME);
 719
 720         backgroundItem = &pData->backgroundItems[pData->listViewItemCount];
 721
 722         backgroundItem->bWallpaper = TRUE;
 723
 724         hr = StringCbCopy(backgroundItem->szDisplayName, sizeof(backgroundItem->szDisplayName), sfi.szDisplayName);
 725         if (FAILED(hr))
 726             return;
 727         p = _tcsrchr(backgroundItem->szDisplayName, _T('.'));
 728         if (p)
 729             *p = (TCHAR)0;
 730         hr = StringCbCopy(backgroundItem->szFilename, sizeof(backgroundItem->szFilename), filename);
 731         if (FAILED(hr))
 732             return;
 733
 734         ZeroMemory(&listItem, sizeof(LV_ITEM));
 735         listItem.mask       = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
 736         listItem.state      = 0;
 737         listItem.pszText    = backgroundItem->szDisplayName;
 738         listItem.iImage     = sfi.iIcon;
 739         listItem.iItem      = pData->listViewItemCount;
 740         listItem.lParam     = pData->listViewItemCount;
 741
 742         (void)ListView_InsertItem(hwndBackgroundList, &listItem);
 743         ListView_SetItemState(hwndBackgroundList,
 744                               pData->listViewItemCount,
 745                               LVIS_SELECTED,
 746                               LVIS_SELECTED);
 747         SendMessage(hwndBackgroundList, WM_VSCROLL, SB_BOTTOM, 0);
 748
 749         pData->listViewItemCount++;
 750     }
 751 }
 752
 753
 754 static VOID
 755 ListViewItemChanged(HWND hwndDlg, PBACKGROUND_DATA pData, int itemIndex)
 756 {
 757     BackgroundItem *backgroundItem = NULL;
 758
 759     pData->backgroundSelection = itemIndex;
 760     backgroundItem = &pData->backgroundItems[pData->backgroundSelection];
 761
 762     if (pData->pWallpaperBitmap != NULL)
 763     {
 764         DibFreeImage(pData->pWallpaperBitmap);
 765         pData->pWallpaperBitmap = NULL;
 766     }
 767
 768     if (backgroundItem->bWallpaper != FALSE)
 769     {
 770         pData->pWallpaperBitmap = DibLoadImage(backgroundItem->szFilename);
 771
 772         if (pData->pWallpaperBitmap == NULL)
 773             return;
 774     }
 775
 776     pData->bWallpaperChanged = TRUE;
 777
 778     InvalidateRect(GetDlgItem(hwndDlg, IDC_BACKGROUND_PREVIEW),
 779                    NULL, TRUE);
 780
 781     EnableWindow(GetDlgItem(hwndDlg, IDC_PLACEMENT_COMBO),
 782                  backgroundItem->bWallpaper);
 783
 784     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 785 }
 786
 787
 788 static VOID
 789 DrawBackgroundPreview(LPDRAWITEMSTRUCT draw, PBACKGROUND_DATA pData)
 790 {
 791     float scaleX;
 792     float scaleY;
 793     int scaledWidth;
 794     int scaledHeight;
 795     int posX, desX;
 796     int posY, desY;
 797     int fitFillScaleNum, fitFillScaleDen;
 798     int fitFillWidth, fitFillHeight;
 799     HBRUSH hBrush;
 800     int x;
 801     int y;
 802     HDC hDC;
 803     HGDIOBJ hOldObj;
 804     RECT rcItem = {
 805         MONITOR_LEFT,
 806         MONITOR_TOP,
 807         MONITOR_RIGHT,
 808         MONITOR_BOTTOM
 809     };
 810
 811     hDC = CreateCompatibleDC(draw->hDC);
 812     hOldObj = SelectObject(hDC, pData->hBitmap);
 813
 814     if (pData->backgroundItems[pData->backgroundSelection].bWallpaper == FALSE)
 815     {
 816         /* Update desktop background color image */
 817         hBrush = CreateSolidBrush(g_GlobalData.desktop_color);
 818         FillRect(hDC, &rcItem, hBrush);
 819         DeleteObject(hBrush);
 820     }
 821     else
 822     if (pData->pWallpaperBitmap != NULL)
 823     {
 824         scaleX = ((float)GetSystemMetrics(SM_CXSCREEN) - 1) / (float)MONITOR_WIDTH;
 825         scaleY = ((float)GetSystemMetrics(SM_CYSCREEN) - 1) / (float)MONITOR_HEIGHT;
 826
 827         scaledWidth = (int)(pData->pWallpaperBitmap->width / scaleX);
 828         scaledHeight = (int)(pData->pWallpaperBitmap->height / scaleY);
 829
 830         FillRect(hDC, &rcItem, GetSysColorBrush(COLOR_BACKGROUND));
 831
 832         SetStretchBltMode(hDC, COLORONCOLOR);
 833
 834         switch (pData->placementSelection)
 835         {
 836             case PLACEMENT_CENTER:
 837                 posX = (MONITOR_WIDTH - scaledWidth + 1) / 2;
 838                 posY = (MONITOR_HEIGHT - scaledHeight + 1) / 2;
 839                 desX = 0;
 840                 desY = 0;
 841
 842                 if (posX < 0) { desX = -posX / 2; posX = 0; }
 843                 if (posY < 0) { desY = -posY / 2; posY = 0; }
 844
 845                 if (scaledWidth > MONITOR_WIDTH)
 846                     scaledWidth = MONITOR_WIDTH;
 847
 848                 if (scaledHeight > MONITOR_HEIGHT)
 849                     scaledHeight = MONITOR_HEIGHT;
 850
 851                 StretchDIBits(hDC,
 852                               MONITOR_LEFT+posX,
 853                               MONITOR_TOP+posY,
 854                               scaledWidth,
 855                               scaledHeight,
 856                               desX,
 857                               desY,
 858                               pData->pWallpaperBitmap->width - (int)(desX * scaleX),
 859                               pData->pWallpaperBitmap->height - (int)(desY * scaleY),
 860                               pData->pWallpaperBitmap->bits,
 861                               pData->pWallpaperBitmap->info,
 862                               DIB_RGB_COLORS,
 863                               SRCCOPY);
 864                 break;
 865
 866             case PLACEMENT_STRETCH:
 867                 StretchDIBits(hDC,
 868                               MONITOR_LEFT,
 869                               MONITOR_TOP,
 870                               MONITOR_WIDTH,
 871                               MONITOR_HEIGHT,
 872                               0,
 873                               0,
 874                               pData->pWallpaperBitmap->width,
 875                               pData->pWallpaperBitmap->height,
 876                               pData->pWallpaperBitmap->bits,
 877                               pData->pWallpaperBitmap->info,
 878                               DIB_RGB_COLORS,
 879                               SRCCOPY);
 880                 break;
 881
 882             case PLACEMENT_TILE:
 883                 for (y = 0; y < MONITOR_HEIGHT; y += scaledHeight)
 884                 {
 885                     for (x = 0; x < MONITOR_WIDTH; x += scaledWidth)
 886                     {
 887                         if ((MONITOR_WIDTH-x) >= scaledWidth)
 888                             posX = scaledWidth;
 889                         else
 890                             posX = MONITOR_WIDTH-x;
 891
 892
 893                         if ((MONITOR_HEIGHT-y) >= scaledHeight)
 894                             posY = scaledHeight;
 895                         else
 896                             posY = MONITOR_HEIGHT-y;
 897
 898                         StretchDIBits(hDC,
 899                                       MONITOR_LEFT + x,
 900                                       MONITOR_TOP + y,
 901                                       posX,
 902                                       posY,
 903                                       0,
 904                                       0,
 905                                       pData->pWallpaperBitmap->width * posX / scaledWidth,
 906                                       pData->pWallpaperBitmap->height * posY / scaledHeight,
 907                                       pData->pWallpaperBitmap->bits,
 908                                       pData->pWallpaperBitmap->info,
 909                                       DIB_RGB_COLORS,
 910                                       SRCCOPY);
 911                     }
 912
 913                 }
 914
 915                 break;
 916
 917             case PLACEMENT_FIT:
 918                 if ((MONITOR_WIDTH * scaledHeight) <= (MONITOR_HEIGHT * scaledWidth))
 919                 {
 920                     fitFillScaleNum = MONITOR_WIDTH;
 921                     fitFillScaleDen = scaledWidth;
 922                 }
 923                 else
 924                 {
 925                     fitFillScaleNum = MONITOR_HEIGHT;
 926                     fitFillScaleDen = scaledHeight;
 927                 }
 928
 929                 fitFillWidth = MulDiv(scaledWidth, fitFillScaleNum, fitFillScaleDen);
 930                 fitFillHeight = MulDiv(scaledHeight, fitFillScaleNum, fitFillScaleDen);
 931
 932                 posX = (MONITOR_WIDTH - fitFillWidth) / 2;
 933                 posY = (MONITOR_HEIGHT - fitFillHeight) / 2;
 934
 935                 StretchDIBits(hDC,
 936                               MONITOR_LEFT + posX,
 937                               MONITOR_TOP + posY,
 938                               fitFillWidth,
 939                               fitFillHeight,
 940                               0,
 941                               0,
 942                               pData->pWallpaperBitmap->width,
 943                               pData->pWallpaperBitmap->height,
 944                               pData->pWallpaperBitmap->bits,
 945                               pData->pWallpaperBitmap->info,
 946                               DIB_RGB_COLORS,
 947                               SRCCOPY);
 948                 break;
 949
 950             case PLACEMENT_FILL:
 951                 if ((MONITOR_WIDTH * scaledHeight) > (MONITOR_HEIGHT * scaledWidth))
 952                 {
 953                     fitFillScaleNum = MONITOR_WIDTH;
 954                     fitFillScaleDen = scaledWidth;
 955                 }
 956                 else
 957                 {
 958                     fitFillScaleNum = MONITOR_HEIGHT;
 959                     fitFillScaleDen = scaledHeight;
 960                 }
 961
 962                 fitFillWidth = MulDiv(scaledWidth, fitFillScaleNum, fitFillScaleDen);
 963                 fitFillHeight = MulDiv(scaledHeight, fitFillScaleNum, fitFillScaleDen);
 964
 965                 desX = (((fitFillWidth - MONITOR_WIDTH) * pData->pWallpaperBitmap->width) / (2 * fitFillWidth));
 966                 desY = (((fitFillHeight - MONITOR_HEIGHT) * pData->pWallpaperBitmap->height) / (2 * fitFillHeight));
 967
 968                 StretchDIBits(hDC,
 969                               MONITOR_LEFT,
 970                               MONITOR_TOP,
 971                               MONITOR_WIDTH,
 972                               MONITOR_HEIGHT,
 973                               desX,
 974                               desY,
 975                               (MONITOR_WIDTH * pData->pWallpaperBitmap->width) / fitFillWidth,
 976                               (MONITOR_HEIGHT * pData->pWallpaperBitmap->height) / fitFillHeight,
 977                               pData->pWallpaperBitmap->bits,
 978                               pData->pWallpaperBitmap->info,
 979                               DIB_RGB_COLORS,
 980                               SRCCOPY);
 981                 break;
 982         }
 983     }
 984
 985     GdiTransparentBlt(draw->hDC,
 986                       draw->rcItem.left, draw->rcItem.top,
 987                       draw->rcItem.right-draw->rcItem.left+1,
 988                       draw->rcItem.bottom-draw->rcItem.top+1,
 989                       hDC,
 990                       0, 0,
 991                       pData->cxSource, pData->cySource,
 992                       0xFF00FF);
 993
 994     SelectObject(hDC, hOldObj);
 995     DeleteDC(hDC);
 996 }
 997
 998
 999 static VOID
1000 SetWallpaper(PBACKGROUND_DATA pData)
1001 {
1002     HKEY regKey;
1003     TCHAR szWallpaper[MAX_PATH];
1004     GpImage *image;
1005     CLSID  encoderClsid;
1006     GUID guidFormat;
1007     size_t length = 0;
1008     GpStatus status;
1009
1010     if (FAILED(SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, szWallpaper)))
1011     {
1012         return;
1013     }
1014
1015     if (FAILED(StringCbCat(szWallpaper, MAX_PATH, TEXT("\\Wallpaper1.bmp"))))
1016     {
1017         return;
1018     }
1019
1020     if (RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Control Panel\\Desktop"), 0, NULL,
1021                        REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &regKey, NULL) != ERROR_SUCCESS)
1022     {
1023         return;
1024     }
1025
1026     if (pData->placementSelection == PLACEMENT_TILE)
1027     {
1028         RegSetValueEx(regKey, TEXT("TileWallpaper"), 0, REG_SZ, (LPBYTE)TEXT("1"), sizeof(TCHAR) * 2);
1029         RegSetValueEx(regKey, TEXT("WallpaperStyle"), 0, REG_SZ, (LPBYTE)TEXT("0"), sizeof(TCHAR) * 2);
1030     }
1031
1032     if (pData->placementSelection == PLACEMENT_CENTER)
1033     {
1034         RegSetValueEx(regKey, TEXT("TileWallpaper"), 0, REG_SZ, (LPBYTE)TEXT("0"), sizeof(TCHAR) * 2);
1035         RegSetValueEx(regKey, TEXT("WallpaperStyle"), 0, REG_SZ, (LPBYTE)TEXT("0"), sizeof(TCHAR) * 2);
1036     }
1037
1038     if (pData->placementSelection == PLACEMENT_STRETCH)
1039     {
1040         RegSetValueEx(regKey, TEXT("TileWallpaper"), 0, REG_SZ, (LPBYTE)TEXT("0"), sizeof(TCHAR) * 2);
1041         RegSetValueEx(regKey, TEXT("WallpaperStyle"), 0, REG_SZ, (LPBYTE)TEXT("2"), sizeof(TCHAR) * 2);
1042     }
1043
1044     if (pData->placementSelection == PLACEMENT_FIT)
1045     {
1046         RegSetValueEx(regKey, TEXT("TileWallpaper"), 0, REG_SZ, (LPBYTE)TEXT("0"), sizeof(TCHAR) * 2);
1047         RegSetValueEx(regKey, TEXT("WallpaperStyle"), 0, REG_SZ, (LPBYTE)TEXT("6"), sizeof(TCHAR) * 2);
1048     }
1049
1050     if (pData->placementSelection == PLACEMENT_FILL)
1051     {
1052         RegSetValueEx(regKey, TEXT("TileWallpaper"), 0, REG_SZ, (LPBYTE)TEXT("0"), sizeof(TCHAR) * 2);
1053         RegSetValueEx(regKey, TEXT("WallpaperStyle"), 0, REG_SZ, (LPBYTE)TEXT("10"), sizeof(TCHAR) * 3);
1054     }
1055
1056     if (pData->backgroundItems[pData->backgroundSelection].bWallpaper != FALSE)
1057     {
1058         GdipLoadImageFromFile(pData->backgroundItems[pData->backgroundSelection].szFilename, &image);
1059         if (!image)
1060         {
1061             RegCloseKey(regKey);
1062             return;
1063         }
1064
1065         GdipGetImageRawFormat(image, &guidFormat);
1066         if (IsEqualGUID(&guidFormat, &ImageFormatBMP))
1067         {
1068             GdipDisposeImage(image);
1069             RegCloseKey(regKey);
1070             SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, pData->backgroundItems[pData->backgroundSelection].szFilename, SPIF_UPDATEINIFILE);
1071             return;
1072         }
1073
1074         if (FAILED(GdipGetEncoderClsid(L"image/bmp", &encoderClsid)))
1075         {
1076             GdipDisposeImage(image);
1077             RegCloseKey(regKey);
1078             return;
1079         }
1080
1081         status = GdipSaveImageToFile(image, szWallpaper, &encoderClsid, NULL);
1082
1083         GdipDisposeImage(image);
1084
1085         if (status != Ok)
1086         {
1087             RegCloseKey(regKey);
1088             return;
1089         }
1090
1091         if (SUCCEEDED(StringCchLength(pData->backgroundItems[pData->backgroundSelection].szFilename, MAX_PATH, &length)))
1092         {
1093             RegSetValueEx(regKey,
1094                           TEXT("ConvertedWallpaper"),
1095                           0,
1096                           REG_SZ,
1097                           (LPBYTE)pData->backgroundItems[pData->backgroundSelection].szFilename,
1098                           (DWORD)((length + 1) * sizeof(TCHAR)));
1099         }
1100
1101         if (SUCCEEDED(StringCchLength(szWallpaper, MAX_PATH, &length)))
1102         {
1103             RegSetValueEx(regKey,
1104                           TEXT("OriginalWallpaper"),
1105                           0,
1106                           REG_SZ,
1107                           (LPBYTE)szWallpaper,
1108                           (DWORD)((length + 1) * sizeof(TCHAR)));
1109         }
1110
1111         SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, szWallpaper, SPIF_UPDATEINIFILE);
1112     }
1113     else
1114     {
1115         SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, (void*) TEXT(""), SPIF_UPDATEINIFILE);
1116     }
1117
1118     RegCloseKey(regKey);
1119 }
1120
1121
1122 /* Change system color */
1123 static VOID
1124 SetDesktopBackColor(HWND hwndDlg, PBACKGROUND_DATA pData)
1125 {
1126     HKEY hKey;
1127     INT iElement = COLOR_BACKGROUND;
1128     TCHAR clText[16];
1129     BYTE red, green, blue;
1130
1131     if (!SetSysColors(1, &iElement, &g_GlobalData.desktop_color))
1132     {
1133         /* FIXME: these error texts can need internationalization? */
1134         MessageBox(hwndDlg, TEXT("SetSysColor() failed!"),
1135             TEXT("Error!"), MB_ICONSTOP );
1136     }
1137
1138     if (RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Control Panel\\Colors"), 0, NULL,
1139                        REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hKey, NULL) != ERROR_SUCCESS)
1140     {
1141         return;
1142     }
1143
1144     red   = GetRValue(g_GlobalData.desktop_color);
1145     green = GetGValue(g_GlobalData.desktop_color);
1146     blue  = GetBValue(g_GlobalData.desktop_color);
1147
1148     /* Format string to be set to registry */
1149     StringCbPrintf(clText, sizeof(clText), TEXT("%d %d %d"), red, green, blue);
1150     RegSetValueEx(hKey, TEXT("Background"), 0, REG_SZ, (LPBYTE)clText,
1151                   (wcslen(clText) + 1) * sizeof(TCHAR));
1152
1153     RegCloseKey(hKey);
1154 }
1155
1156 INT_PTR CALLBACK
1157 BackgroundPageProc(HWND hwndDlg,
1158                    UINT uMsg,
1159                    WPARAM wParam,
1160                    LPARAM lParam)
1161 {
1162     PBACKGROUND_DATA pData;
1163     struct GdiplusStartupInput gdipStartup;
1164
1165     pData = (PBACKGROUND_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
1166
1167     switch (uMsg)
1168     {
1169         case WM_INITDIALOG:
1170             pData = (PBACKGROUND_DATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BACKGROUND_DATA));
1171             SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pData);
1172             gdipStartup.GdiplusVersion = 1;
1173             gdipStartup.DebugEventCallback = NULL;
1174             gdipStartup.SuppressBackgroundThread = FALSE;
1175             gdipStartup.SuppressExternalCodecs = FALSE;
1176             GdiplusStartup(&pData->gdipToken, &gdipStartup, NULL);
1177             InitBackgroundDialog(hwndDlg, pData);
1178             break;
1179
1180         case WM_COMMAND:
1181             {
1182                 DWORD controlId = LOWORD(wParam);
1183                 DWORD command   = HIWORD(wParam);
1184
1185                 switch (controlId)
1186                 {
1187                     case IDC_COLOR_BUTTON:
1188                         if (command == BN_CLICKED)
1189                             OnColorButton(hwndDlg, pData);
1190                         break;
1191
1192                     case IDC_BROWSE_BUTTON:
1193                         if (command == BN_CLICKED)
1194                             OnBrowseButton(hwndDlg, pData);
1195                         break;
1196
1197                     case IDC_PLACEMENT_COMBO:
1198                         if (command == CBN_SELCHANGE)
1199                         {
1200                             pData->placementSelection = (int)SendDlgItemMessage(hwndDlg, IDC_PLACEMENT_COMBO, CB_GETCURSEL, 0, 0);
1201
1202                             InvalidateRect(GetDlgItem(hwndDlg, IDC_BACKGROUND_PREVIEW), NULL, TRUE);
1203
1204                             PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1205                         }
1206                         break;
1207                 }
1208             } break;
1209
1210         case WM_DRAWITEM:
1211             {
1212                 LPDRAWITEMSTRUCT drawItem;
1213                 drawItem = (LPDRAWITEMSTRUCT)lParam;
1214
1215                 if (drawItem->CtlID == IDC_BACKGROUND_PREVIEW)
1216                 {
1217                     DrawBackgroundPreview(drawItem, pData);
1218                 }
1219
1220             }
1221             break;
1222
1223         case WM_NOTIFY:
1224             {
1225                 LPNMHDR lpnm = (LPNMHDR)lParam;
1226
1227                 switch(lpnm->code)
1228                 {
1229                     case PSN_APPLY:
1230                         if (pData->bWallpaperChanged)
1231                             SetWallpaper(pData);
1232                         if (pData->bClrBackgroundChanged)
1233                             SetDesktopBackColor(hwndDlg, pData);
1234                         SendMessage(HWND_BROADCAST, WM_SETTINGCHANGE, 0, (LPARAM)_T(""));
1235                         return TRUE;
1236
1237                     case LVN_ITEMCHANGED:
1238                         {
1239                             LPNMLISTVIEW nm = (LPNMLISTVIEW)lParam;
1240
1241                             if ((nm->uNewState & LVIS_SELECTED) == 0)
1242                                 return FALSE;
1243
1244                             ListViewItemChanged(hwndDlg, pData, nm->iItem);
1245                         }
1246                         break;
1247                 }
1248             }
1249             break;
1250
1251         case WM_DESTROY:
1252             if (pData->pWallpaperBitmap != NULL)
1253                 DibFreeImage(pData->pWallpaperBitmap);
1254
1255             DeleteObject(pData->hBitmap);
1256             GdiplusShutdown(pData->gdipToken);
1257             HeapFree(GetProcessHeap(), 0, pData);
1258             break;
1259     }
1260
1261     return FALSE;
1262 }