programs/winecfg/driveui.c

   1 /*
   2  * Drive management UI code
   3  *
   4  * Copyright 2003 Mark Westcott
   5  * Copyright 2004 Chris Morgan
   6  * Copyright 2003-2004 Mike Hearn
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #define WIN32_LEAN_AND_MEAN
  25 #define COBJMACROS
  26
  27 #include <windows.h>
  28 #include <shellapi.h>
  29 #include <objbase.h>
  30 #include <shlguid.h>
  31 #include <shlwapi.h>
  32 #include <shlobj.h>
  33
  34 #include <wine/debug.h>
  35
  36 #include "winecfg.h"
  37 #include "resource.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  40
  41 #define BOX_MODE_CD_ASSIGN 1
  42 #define BOX_MODE_CD_AUTODETECT 2
  43 #define BOX_MODE_NONE 3
  44 #define BOX_MODE_NORMAL 4
  45
  46 static BOOL advanced = FALSE;
  47 static BOOL updating_ui = FALSE;
  48 static struct drive* current_drive;
  49
  50 static void get_etched_rect(HWND dialog, RECT *rect);
  51 static void update_controls(HWND dialog);
  52
  53 /**** listview helper functions ****/
  54
  55 /* clears the item at index in the listview */
  56 static void lv_clear_curr_select(HWND dialog, int index)
  57 {
  58     ListView_SetItemState(GetDlgItem(dialog, IDC_LIST_DRIVES), index, 0, LVIS_SELECTED);
  59 }
  60
  61 /* selects the item at index in the listview */
  62 static void lv_set_curr_select(HWND dialog, int index)
  63 {
  64     /* no more than one item can be selected in our listview */
  65     lv_clear_curr_select(dialog, -1);
  66     ListView_SetItemState(GetDlgItem(dialog, IDC_LIST_DRIVES), index, LVIS_SELECTED, LVIS_SELECTED);
  67 }
  68
  69 /* returns the currently selected item in the listview */
  70 static int lv_get_curr_select(HWND dialog)
  71 {
  72     return SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
  73 }
  74
  75 /* sets the item in the listview at item->iIndex */
  76 static void lv_set_item(HWND dialog, LVITEM *item)
  77 {
  78     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_SETITEM, 0, (LPARAM) item);
  79 }
  80
  81 /* sets specified item's text */
  82 static void lv_set_item_text(HWND dialog, int item, int subItem, char *text)
  83 {
  84     LVITEM lvItem;
  85     if (item < 0 || subItem < 0) return;
  86     lvItem.mask = LVIF_TEXT;
  87     lvItem.iItem = item;
  88     lvItem.iSubItem = subItem;
  89     lvItem.pszText = text;
  90     lvItem.cchTextMax = lstrlen(lvItem.pszText);
  91     lv_set_item(dialog, &lvItem);
  92 }
  93
  94 /* inserts an item into the listview */
  95 static void lv_insert_item(HWND dialog, LVITEM *item)
  96 {
  97     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_INSERTITEM, 0, (LPARAM) item);
  98 }
  99
 100 /* retrieve the item at index item->iIndex */
 101 static void lv_get_item(HWND dialog, LVITEM *item)
 102 {
 103     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_GETITEM, 0, (LPARAM) item);
 104 }
 105
 106 static void set_advanced(HWND dialog)
 107 {
 108     int state;
 109     char text[256];
 110     RECT rect;
 111
 112     if (advanced)
 113     {
 114         state = SW_NORMAL;
 115         LoadString(GetModuleHandle(NULL), IDS_HIDE_ADVANCED, text, 256);
 116     }
 117     else
 118     {
 119         state = SW_HIDE;
 120         LoadString(GetModuleHandle(NULL), IDS_SHOW_ADVANCED, text, 256);
 121     }
 122
 123     ShowWindow(GetDlgItem(dialog, IDC_RADIO_AUTODETECT), state);
 124     ShowWindow(GetDlgItem(dialog, IDC_RADIO_ASSIGN), state);
 125     ShowWindow(GetDlgItem(dialog, IDC_EDIT_LABEL), state);
 126     ShowWindow(GetDlgItem(dialog, IDC_EDIT_DEVICE), state);
 127     ShowWindow(GetDlgItem(dialog, IDC_STATIC_LABEL), state);
 128     ShowWindow(GetDlgItem(dialog, IDC_BUTTON_BROWSE_DEVICE), state);
 129     ShowWindow(GetDlgItem(dialog, IDC_EDIT_SERIAL), state);
 130     ShowWindow(GetDlgItem(dialog, IDC_STATIC_SERIAL), state);
 131     ShowWindow(GetDlgItem(dialog, IDC_LABELSERIAL_STATIC), state);
 132     ShowWindow(GetDlgItem(dialog, IDC_COMBO_TYPE), state);
 133     ShowWindow(GetDlgItem(dialog, IDC_STATIC_TYPE), state);
 134
 135     /* update the button text based on the state */
 136     SetWindowText(GetDlgItem(dialog, IDC_BUTTON_SHOW_HIDE_ADVANCED), text);
 137
 138     /* redraw for the etched line */
 139     get_etched_rect(dialog, &rect);
 140     InflateRect(&rect, 5, 5);
 141     InvalidateRect(dialog, &rect, TRUE);
 142 }
 143
 144 struct drive_typemap {
 145     unsigned int sCode;
 146     const char *sDesc;
 147 };
 148
 149 static const struct drive_typemap type_pairs[] = {
 150   { DRIVE_UNKNOWN,    "Autodetect"      },
 151   { DRIVE_FIXED,      "Local hard disk" },
 152   { DRIVE_REMOTE,     "Network share"   },
 153   { DRIVE_REMOVABLE,  "Floppy disk"     },
 154   { DRIVE_CDROM,      "CD-ROM"          }
 155 };
 156
 157 #define DRIVE_TYPE_DEFAULT 0
 158
 159 static void fill_drive_droplist(long mask, char curletter, HWND dialog)
 160 {
 161     int i;
 162     int selection;
 163     int count;
 164     int next_letter;
 165     char sName[4];
 166
 167     strcpy(sName, "A:");
 168     for (i = 0, count = 0, selection = -1, next_letter = -1; i <= 'Z'-'A'; ++i)
 169     {
 170         if (mask & DRIVE_MASK_BIT('A' + i))
 171         {
 172             int index;
 173
 174             sName[0] = 'A' + i;
 175             index = SendDlgItemMessage(dialog, IDC_COMBO_LETTER, CB_ADDSTRING, 0, (LPARAM) sName);
 176
 177             if (toupper(curletter) == 'A' + i)
 178             {
 179                 selection = count;
 180             }
 181
 182             if (i >= 2 && next_letter == -1)
 183             {
 184                 /* default drive is first one of C-Z */
 185                 next_letter = count;
 186             }
 187
 188             count++;
 189         }
 190     }
 191
 192     if (selection == -1)
 193     {
 194         selection = next_letter;
 195     }
 196
 197     SendDlgItemMessage(dialog, IDC_COMBO_LETTER, CB_SETCURSEL, selection, 0);
 198 }
 199
 200
 201 static void enable_labelserial_box(HWND dialog, int mode)
 202 {
 203     WINE_TRACE("mode=%d\n", mode);
 204
 205     switch (mode)
 206     {
 207         case BOX_MODE_CD_ASSIGN:
 208             enable(IDC_RADIO_ASSIGN);
 209             disable(IDC_EDIT_DEVICE);
 210             disable(IDC_BUTTON_BROWSE_DEVICE);
 211             enable(IDC_EDIT_SERIAL);
 212             enable(IDC_EDIT_LABEL);
 213             enable(IDC_STATIC_SERIAL);
 214             enable(IDC_STATIC_LABEL);
 215             break;
 216
 217         case BOX_MODE_CD_AUTODETECT:
 218             enable(IDC_RADIO_ASSIGN);
 219             enable(IDC_EDIT_DEVICE);
 220             enable(IDC_BUTTON_BROWSE_DEVICE);
 221             disable(IDC_EDIT_SERIAL);
 222             disable(IDC_EDIT_LABEL);
 223             disable(IDC_STATIC_SERIAL);
 224             disable(IDC_STATIC_LABEL);
 225             break;
 226
 227         case BOX_MODE_NONE:
 228             disable(IDC_RADIO_ASSIGN);
 229             disable(IDC_EDIT_DEVICE);
 230             disable(IDC_BUTTON_BROWSE_DEVICE);
 231             disable(IDC_EDIT_SERIAL);
 232             disable(IDC_EDIT_LABEL);
 233             disable(IDC_STATIC_SERIAL);
 234             disable(IDC_STATIC_LABEL);
 235             break;
 236
 237         case BOX_MODE_NORMAL:
 238             enable(IDC_RADIO_ASSIGN);
 239             disable(IDC_EDIT_DEVICE);
 240             disable(IDC_BUTTON_BROWSE_DEVICE);
 241             enable(IDC_EDIT_SERIAL);
 242             enable(IDC_EDIT_LABEL);
 243             enable(IDC_STATIC_SERIAL);
 244             enable(IDC_STATIC_LABEL);
 245             break;
 246     }
 247 }
 248
 249 static int fill_drives_list(HWND dialog)
 250 {
 251     int count = 0;
 252     BOOL drivec_present = FALSE;
 253     int i;
 254     int prevsel = -1;
 255
 256     WINE_TRACE("\n");
 257
 258     updating_ui = TRUE;
 259
 260     prevsel = lv_get_curr_select(dialog);
 261
 262     /* Clear the listbox */
 263     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_DELETEALLITEMS, 0, 0);
 264
 265     for(i = 0; i < 26; i++)
 266     {
 267         LVITEM item;
 268         char letter[4];
 269
 270         /* skip over any unused drives */
 271         if (!drives[i].in_use)
 272             continue;
 273
 274         if (drives[i].letter == 'C')
 275             drivec_present = TRUE;
 276
 277         letter[0] = 'A' + i;
 278         letter[1] = ':';
 279         letter[2] = 0;
 280
 281         memset(&item, 0, sizeof(item));
 282         item.mask = LVIF_TEXT | LVIF_PARAM;
 283         item.iItem = count;
 284         item.iSubItem = 0;
 285         item.pszText = letter;
 286         item.cchTextMax = lstrlen(item.pszText);
 287         item.lParam = (LPARAM) &drives[i];
 288
 289         lv_insert_item(dialog, &item);
 290         lv_set_item_text(dialog, count, 1, drives[i].unixpath);
 291
 292         count++;
 293     }
 294
 295     WINE_TRACE("loaded %d drives\n", count);
 296
 297     /* show the warning if there is no Drive C */
 298     if (!drivec_present)
 299         ShowWindow(GetDlgItem(dialog, IDS_DRIVE_NO_C), SW_NORMAL);
 300     else
 301         ShowWindow(GetDlgItem(dialog, IDS_DRIVE_NO_C), SW_HIDE);
 302
 303     lv_set_curr_select(dialog, prevsel == -1 ? 0 : prevsel);
 304
 305     updating_ui = FALSE;
 306     return count;
 307 }
 308
 309 static void on_options_click(HWND dialog)
 310 {
 311     if (IsDlgButtonChecked(dialog, IDC_SHOW_DOT_FILES) == BST_CHECKED)
 312         set_reg_key(config_key, "", "ShowDotFiles", "Y");
 313     else
 314         set_reg_key(config_key, "", "ShowDotFiles", "N");
 315
 316     SendMessage(GetParent(dialog), PSM_CHANGED, 0, 0);
 317 }
 318
 319 static void on_add_click(HWND dialog)
 320 {
 321     /* we should allocate a drive letter automatically. We also need
 322        some way to let the user choose the mapping point, for now we
 323        will just force them to enter a path automatically, with / being
 324        the default. In future we should be able to temporarily map /
 325        then invoke the directory chooser dialog. */
 326
 327     char new = 'C'; /* we skip A and B, they are historically floppy drives */
 328     long mask = ~drive_available_mask(0); /* the mask is now which drives aren't available */
 329     int i, c;
 330
 331     while (mask & (1 << (new - 'A')))
 332     {
 333         new++;
 334         if (new > 'Z')
 335         {
 336             MessageBox(dialog, "You cannot add any more drives.\n\nEach drive must have a letter, from A to Z, so you cannot have more than 26", "", MB_OK | MB_ICONEXCLAMATION);
 337             return;
 338         }
 339     }
 340
 341     WINE_TRACE("allocating drive letter %c\n", new);
 342
 343     if (new == 'C') add_drive(new, "../drive_c", "System Drive", "", DRIVE_FIXED);
 344     else add_drive(new, "/", "", "", DRIVE_UNKNOWN);
 345
 346     fill_drives_list(dialog);
 347
 348     /* select the newly created drive */
 349     mask = ~drive_available_mask(0);
 350     c = 0;
 351     for (i = 0; i < 26; i++)
 352     {
 353         if ('A' + i == new) break;
 354         if ((1 << i) & mask) c++;
 355     }
 356     lv_set_curr_select(dialog, c);
 357
 358     SetFocus(GetDlgItem(dialog, IDC_LIST_DRIVES));
 359
 360     update_controls(dialog);
 361 }
 362
 363 static void on_remove_click(HWND dialog)
 364 {
 365     int itemIndex;
 366     struct drive *drive;
 367     LVITEM item;
 368
 369     itemIndex = lv_get_curr_select(dialog);
 370     if (itemIndex == -1) return; /* no selection */
 371
 372     memset(&item, 0, sizeof(item));
 373     item.mask = LVIF_PARAM;
 374     item.iItem = itemIndex;
 375     item.iSubItem = 0;
 376
 377     lv_get_item(dialog, &item);
 378
 379     drive = (struct drive *) item.lParam;
 380
 381     WINE_ERR("unixpath: %s\n", drive->unixpath);
 382
 383     if (drive->letter == 'C')
 384     {
 385         DWORD result = MessageBox(dialog, "Are you sure you want to delete drive C?\n\nMost Windows applications expect drive C to exist, and will die messily if it doesn't. If you proceed remember to recreate it!", "", MB_YESNO | MB_ICONEXCLAMATION);
 386         if (result == IDNO) return;
 387     }
 388
 389     delete_drive(drive);
 390
 391     fill_drives_list(dialog);
 392
 393     itemIndex = itemIndex - 1;
 394     if (itemIndex < 0) itemIndex = 0;
 395     lv_set_curr_select(dialog, itemIndex);   /* previous item */
 396
 397     SetFocus(GetDlgItem(dialog, IDC_LIST_DRIVES));
 398
 399     update_controls(dialog);
 400 }
 401
 402 static void update_controls(HWND dialog)
 403 {
 404     char *path;
 405     unsigned int type;
 406     char *label;
 407     char *serial;
 408     const char *device;
 409     int i, selection = -1;
 410     LVITEM item;
 411
 412     updating_ui = TRUE;
 413
 414     i = lv_get_curr_select(dialog);
 415     if (i == -1)
 416     {
 417         /* no selection? let's select something for the user. this will re-enter */
 418         lv_set_curr_select(dialog, i);
 419         return;
 420     }
 421
 422     memset(&item, 0, sizeof(item));
 423     item.mask = LVIF_PARAM;
 424     item.iItem = i;
 425     item.iSubItem = 0;
 426
 427     lv_get_item(dialog, &item);
 428     current_drive = (struct drive *) item.lParam;
 429
 430     WINE_TRACE("Updating sheet for drive %c\n", current_drive->letter);
 431
 432     /* Drive letters */
 433     fill_drive_droplist(drive_available_mask(current_drive->letter), current_drive->letter, dialog);
 434
 435     /* path */
 436     path = current_drive->unixpath;
 437     WINE_TRACE("set path control text to '%s'\n", path);
 438     set_text(dialog, IDC_EDIT_PATH, path);
 439
 440     /* drive type */
 441     type = current_drive->type;
 442     SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_RESETCONTENT, 0, 0);
 443
 444     for (i = 0; i < sizeof(type_pairs) / sizeof(struct drive_typemap); i++)
 445     {
 446         SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_ADDSTRING, 0, (LPARAM) type_pairs[i].sDesc);
 447
 448         if (type_pairs[i].sCode ==  type)
 449         {
 450             selection = i;
 451         }
 452     }
 453
 454     if (selection == -1) selection = DRIVE_TYPE_DEFAULT;
 455     SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_SETCURSEL, selection, 0);
 456
 457     /* removeable media properties */
 458     label = current_drive->label;
 459     set_text(dialog, IDC_EDIT_LABEL, label);
 460
 461     /* set serial edit text */
 462     serial = current_drive->serial;
 463     set_text(dialog, IDC_EDIT_SERIAL, serial);
 464
 465     /* TODO: get the device here to put into the edit box */
 466     device = "Not implemented yet";
 467     set_text(dialog, IDC_EDIT_DEVICE, device);
 468     device = NULL;
 469
 470     selection = IDC_RADIO_ASSIGN;
 471     if ((type == DRIVE_CDROM) || (type == DRIVE_REMOVABLE))
 472     {
 473         if (device)
 474         {
 475             selection = IDC_RADIO_AUTODETECT;
 476             enable_labelserial_box(dialog, BOX_MODE_CD_AUTODETECT);
 477         }
 478         else
 479         {
 480             selection = IDC_RADIO_ASSIGN;
 481             enable_labelserial_box(dialog, BOX_MODE_CD_ASSIGN);
 482         }
 483     }
 484     else
 485     {
 486         enable_labelserial_box(dialog, BOX_MODE_NORMAL);
 487         selection = IDC_RADIO_ASSIGN;
 488     }
 489
 490     CheckRadioButton(dialog, IDC_RADIO_AUTODETECT, IDC_RADIO_ASSIGN, selection);
 491
 492     updating_ui = FALSE;
 493
 494     return;
 495 }
 496
 497 static void on_edit_changed(HWND dialog, WORD id)
 498 {
 499     if (updating_ui) return;
 500
 501     WINE_TRACE("edit id %d changed\n", id);
 502
 503     switch (id)
 504     {
 505         case IDC_EDIT_LABEL:
 506         {
 507             char *label;
 508
 509             label = get_text(dialog, id);
 510             HeapFree(GetProcessHeap(), 0, current_drive->label);
 511             current_drive->label = label ? label :  strdupA("");
 512
 513             WINE_TRACE("set label to %s\n", current_drive->label);
 514
 515             /* enable the apply button  */
 516             SendMessage(GetParent(dialog), PSM_CHANGED, (WPARAM) dialog, 0);
 517             break;
 518         }
 519
 520         case IDC_EDIT_PATH:
 521         {
 522             char *path;
 523
 524             path = get_text(dialog, id);
 525             HeapFree(GetProcessHeap(), 0, current_drive->unixpath);
 526             current_drive->unixpath = path ? path : strdupA("drive_c");
 527
 528             WINE_TRACE("set path to %s\n", current_drive->unixpath);
 529
 530             lv_set_item_text(dialog, lv_get_curr_select(dialog), 1,
 531                              current_drive->unixpath);
 532
 533             /* enable the apply button  */
 534             SendMessage(GetParent(dialog), PSM_CHANGED, (WPARAM) dialog, 0);
 535             break;
 536         }
 537
 538         case IDC_EDIT_SERIAL:
 539         {
 540             char *serial;
 541
 542             serial = get_text(dialog, id);
 543             HeapFree(GetProcessHeap(), 0, current_drive->serial);
 544             current_drive->serial = serial ? serial : strdupA("");
 545
 546             WINE_TRACE("set serial to %s", current_drive->serial);
 547
 548             /* enable the apply button  */
 549             SendMessage(GetParent(dialog), PSM_CHANGED, (WPARAM) dialog, 0);
 550             break;
 551         }
 552
 553         case IDC_EDIT_DEVICE:
 554         {
 555             char *device = get_text(dialog, id);
 556             /* TODO: handle device if/when it makes sense to do so.... */
 557             HeapFree(GetProcessHeap(), 0, device);
 558             break;
 559         }
 560     }
 561 }
 562
 563 static void get_etched_rect(HWND dialog, RECT *rect)
 564 {
 565     GetClientRect(dialog, rect);
 566
 567     /* these dimensions from the labelserial static in En.rc  */
 568     rect->top = 265;
 569     rect->bottom = 265;
 570     rect->left += 25;
 571     rect->right -= 25;
 572 }
 573
 574 /* this just draws a nice line to separate the advanced gui from the n00b gui :) */
 575 static void paint(HWND dialog)
 576 {
 577     PAINTSTRUCT ps;
 578
 579     BeginPaint(dialog, &ps);
 580
 581     if (advanced)
 582     {
 583         RECT rect;
 584
 585         get_etched_rect(dialog, &rect);
 586
 587         DrawEdge(ps.hdc, &rect, EDGE_ETCHED, BF_TOP);
 588     }
 589
 590     EndPaint(dialog, &ps);
 591 }
 592
 593 static void browse_for_folder(HWND dialog)
 594 {
 595     static WCHAR wszUnixRootDisplayName[] =
 596         { ':',':','{','C','C','7','0','2','E','B','2','-','7','D','C','5','-','1','1','D','9','-',
 597           'C','6','8','7','-','0','0','0','4','2','3','8','A','0','1','C','D','}', 0 };
 598     char pszChoosePath[256];
 599     BROWSEINFOA bi = {
 600         dialog,
 601         NULL,
 602         NULL,
 603         pszChoosePath,
 604         0,
 605         NULL,
 606         0,
 607         0
 608     };
 609     IShellFolder *pDesktop;
 610     LPITEMIDLIST pidlUnixRoot, pidlSelectedPath;
 611     HRESULT hr;
 612
 613     LoadString(GetModuleHandle(NULL), IDS_CHOOSE_PATH, pszChoosePath, 256);
 614
 615     hr = SHGetDesktopFolder(&pDesktop);
 616     if (!SUCCEEDED(hr)) return;
 617
 618     hr = IShellFolder_ParseDisplayName(pDesktop, NULL, NULL, wszUnixRootDisplayName, NULL,
 619                                        &pidlUnixRoot, NULL);
 620     if (!SUCCEEDED(hr)) {
 621         IShellFolder_Release(pDesktop);
 622         return;
 623     }
 624
 625     bi.pidlRoot = pidlUnixRoot;
 626     pidlSelectedPath = SHBrowseForFolderA(&bi);
 627     SHFree(pidlUnixRoot);
 628
 629     if (pidlSelectedPath) {
 630         STRRET strSelectedPath;
 631         char *pszSelectedPath;
 632         HRESULT hr;
 633
 634         hr = IShellFolder_GetDisplayNameOf(pDesktop, pidlSelectedPath, SHGDN_FORPARSING,
 635                                            &strSelectedPath);
 636         IShellFolder_Release(pDesktop);
 637         if (!SUCCEEDED(hr)) {
 638             SHFree(pidlSelectedPath);
 639             return;
 640         }
 641
 642         hr = StrRetToStr(&strSelectedPath, pidlSelectedPath, &pszSelectedPath);
 643         SHFree(pidlSelectedPath);
 644         if (!SUCCEEDED(hr)) return;
 645
 646         set_text(dialog, IDC_EDIT_PATH, pszSelectedPath);
 647
 648         CoTaskMemFree(pszSelectedPath);
 649     }
 650 }
 651
 652 static void init_listview_columns(HWND dialog)
 653 {
 654     LVCOLUMN listColumn;
 655     RECT viewRect;
 656     int width;
 657
 658     GetClientRect(GetDlgItem(dialog, IDC_LIST_DRIVES), &viewRect);
 659     width = (viewRect.right - viewRect.left) / 6 - 5;
 660
 661     listColumn.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
 662     listColumn.pszText = (char*) "Letter";
 663     listColumn.cchTextMax = lstrlen(listColumn.pszText);
 664     listColumn.cx = width;
 665
 666     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_INSERTCOLUMN, 0, (LPARAM) &listColumn);
 667
 668     listColumn.cx = viewRect.right - viewRect.left - width;
 669     listColumn.pszText = (char*) "Drive Mapping";
 670     listColumn.cchTextMax = lstrlen(listColumn.pszText);
 671
 672     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LVM_INSERTCOLUMN, 1, (LPARAM) &listColumn);
 673 }
 674
 675 static void load_drive_options(HWND dialog)
 676 {
 677     if (!strcmp(get_reg_key(config_key, "", "ShowDotFiles", "N"), "Y"))
 678         CheckDlgButton(dialog, IDC_SHOW_DOT_FILES, BST_CHECKED);
 679 }
 680
 681 INT_PTR CALLBACK
 682 DriveDlgProc (HWND dialog, UINT msg, WPARAM wParam, LPARAM lParam)
 683 {
 684     int item;
 685     struct drive *drive;
 686
 687     switch (msg)
 688     {
 689         case WM_INITDIALOG:
 690             init_listview_columns(dialog);
 691             load_drives();
 692             load_drive_options(dialog);
 693
 694             if (!drives[2].in_use)
 695                 MessageBox(dialog, "You don't have a drive C. This is not so great.\n\nRemember to click 'Add' in the Drives tab to create one!\n", "", MB_OK | MB_ICONEXCLAMATION);
 696
 697             fill_drives_list(dialog);
 698             update_controls(dialog);
 699             /* put in non-advanced mode by default  */
 700             set_advanced(dialog);
 701             break;
 702
 703         case WM_SHOWWINDOW:
 704             set_window_title(dialog);
 705             break;
 706
 707         case WM_PAINT:
 708             paint(dialog);
 709             break;
 710
 711         case WM_COMMAND:
 712             switch (HIWORD(wParam))
 713             {
 714                 case EN_CHANGE:
 715                     on_edit_changed(dialog, LOWORD(wParam));
 716                     break;
 717
 718                 case BN_CLICKED:
 719                     switch (LOWORD(wParam))
 720                     {
 721                         case IDC_SHOW_DOT_FILES:
 722                             on_options_click(dialog);
 723                         break;
 724                     }
 725                     break;
 726
 727                 case CBN_SELCHANGE:
 728                     SendMessage(GetParent(dialog), PSM_CHANGED, 0, 0);
 729                     break;
 730             }
 731
 732             switch (LOWORD(wParam))
 733             {
 734                 case IDC_BUTTON_ADD:
 735                     if (HIWORD(wParam) != BN_CLICKED) break;
 736                     on_add_click(dialog);
 737                     break;
 738
 739                 case IDC_BUTTON_REMOVE:
 740                     if (HIWORD(wParam) != BN_CLICKED) break;
 741                     on_remove_click(dialog);
 742                     break;
 743
 744                 case IDC_BUTTON_EDIT:
 745                     if (HIWORD(wParam) != BN_CLICKED) break;
 746                     item = SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES),  LB_GETCURSEL, 0, 0);
 747                     drive = (struct drive *) SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES), LB_GETITEMDATA, item, 0);
 748                     /*DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_DRIVE_EDIT), NULL, (DLGPROC) DriveEditDlgProc, (LPARAM) drive); */
 749                     break;
 750
 751                 case IDC_BUTTON_AUTODETECT:
 752                     autodetect_drives();
 753                     fill_drives_list(dialog);
 754                     SendMessage(GetParent(dialog), PSM_CHANGED, 0, 0);
 755                     break;
 756
 757                 case IDC_BUTTON_SHOW_HIDE_ADVANCED:
 758                     advanced = !advanced;
 759                     set_advanced(dialog);
 760                     break;
 761
 762                 case IDC_BUTTON_BROWSE_PATH:
 763                     browse_for_folder(dialog);
 764                     break;
 765
 766                 case IDC_RADIO_ASSIGN:
 767                 {
 768                     char *str;
 769
 770                     str = get_text(dialog, IDC_EDIT_LABEL);
 771                     HeapFree(GetProcessHeap(), 0, current_drive->label);
 772                     current_drive->label = str ? str : strdupA("");
 773
 774                     str = get_text(dialog, IDC_EDIT_SERIAL);
 775                     HeapFree(GetProcessHeap(), 0, current_drive->serial);
 776                     current_drive->serial = str ? str : strdupA("");
 777
 778                     /* TODO: we don't have a device at this point */
 779
 780                     enable_labelserial_box(dialog, BOX_MODE_CD_ASSIGN);
 781
 782                     break;
 783                 }
 784
 785
 786                 case IDC_COMBO_TYPE:
 787                 {
 788                     int mode = BOX_MODE_NORMAL;
 789                     int selection;
 790
 791                     if (HIWORD(wParam) != CBN_SELCHANGE) break;
 792
 793                     selection = SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_GETCURSEL, 0, 0);
 794
 795                     if (selection >= 0 &&
 796                         (type_pairs[selection].sCode == DRIVE_CDROM ||
 797                          type_pairs[selection].sCode == DRIVE_REMOVABLE))
 798                     {
 799                         if (IsDlgButtonChecked(dialog, IDC_RADIO_AUTODETECT))
 800                             mode = BOX_MODE_CD_AUTODETECT;
 801                         else
 802                             mode = BOX_MODE_CD_ASSIGN;
 803                     }
 804
 805                     enable_labelserial_box(dialog, mode);
 806
 807                     current_drive->type = type_pairs[selection].sCode;
 808                     break;
 809                 }
 810
 811             }
 812             break;
 813
 814         case WM_NOTIFY:
 815             switch (((LPNMHDR)lParam)->code)
 816             {
 817                 case PSN_KILLACTIVE:
 818                     WINE_TRACE("PSN_KILLACTIVE\n");
 819                     SetWindowLongPtr(dialog, DWLP_MSGRESULT, FALSE);
 820                     break;
 821                 case PSN_APPLY:
 822                     apply_drive_changes();
 823                     SetWindowLongPtr(dialog, DWLP_MSGRESULT, PSNRET_NOERROR);
 824                     break;
 825                 case PSN_SETACTIVE:
 826                     break;
 827                 case LVN_ITEMCHANGED:
 828                 {
 829                     LPNMLISTVIEW lpnm = (LPNMLISTVIEW)lParam;
 830                     if (!(lpnm->uOldState & LVIS_SELECTED) &&
 831                          (lpnm->uNewState & LVIS_SELECTED))
 832                     update_controls(dialog);
 833                     break;
 834                 }
 835             }
 836             break;
 837     }
 838
 839     return FALSE;
 840 }