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 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #include <windef.h>
  28 #include <winbase.h>
  29 #include <winreg.h>
  30 #include <shellapi.h>
  31 #include <objbase.h>
  32 #include <shlguid.h>
  33 #include <shlwapi.h>
  34 #include <shlobj.h>
  35 #include <winuser.h>
  36
  37 #include <wine/debug.h>
  38
  39 #include "winecfg.h"
  40 #include "resource.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  43
  44 #define BOX_MODE_CD_ASSIGN 1
  45 #define BOX_MODE_CD_AUTODETECT 2
  46 #define BOX_MODE_NONE 3
  47 #define BOX_MODE_NORMAL 4
  48
  49 static BOOL advanced = FALSE;
  50 static BOOL updating_ui = FALSE;
  51 static struct drive* current_drive;
  52
  53 static void get_etched_rect(HWND dialog, RECT *rect);
  54 static void update_controls(HWND dialog);
  55
  56 static void set_advanced(HWND dialog)
  57 {
  58     int state;
  59     char *text;
  60     RECT rect;
  61
  62     /* FIXME: internationalization  */
  63     if (advanced)
  64     {
  65         state = SW_NORMAL;
  66         text = "&Hide Advanced";
  67     }
  68     else
  69     {
  70         state = SW_HIDE;
  71         text = "&Show Advanced";
  72     }
  73
  74     ShowWindow(GetDlgItem(dialog, IDC_RADIO_AUTODETECT), state);
  75     ShowWindow(GetDlgItem(dialog, IDC_RADIO_ASSIGN), state);
  76     ShowWindow(GetDlgItem(dialog, IDC_EDIT_LABEL), state);
  77     ShowWindow(GetDlgItem(dialog, IDC_EDIT_DEVICE), state);
  78     ShowWindow(GetDlgItem(dialog, IDC_STATIC_LABEL), state);
  79     ShowWindow(GetDlgItem(dialog, IDC_BUTTON_BROWSE_DEVICE), state);
  80     ShowWindow(GetDlgItem(dialog, IDC_EDIT_SERIAL), state);
  81     ShowWindow(GetDlgItem(dialog, IDC_STATIC_SERIAL), state);
  82     ShowWindow(GetDlgItem(dialog, IDC_LABELSERIAL_STATIC), state);
  83
  84     /* update the button text based on the state */
  85     SetWindowText(GetDlgItem(dialog, IDC_BUTTON_SHOW_HIDE_ADVANCED), text);
  86
  87     /* redraw for the etched line */
  88     get_etched_rect(dialog, &rect);
  89     InflateRect(&rect, 5, 5);
  90     InvalidateRect(dialog, &rect, TRUE);
  91 }
  92
  93 struct drive_typemap {
  94     unsigned int sCode;
  95     const char *sDesc;
  96 };
  97
  98 static const struct drive_typemap type_pairs[] = {
  99   { DRIVE_FIXED,      "Local hard disk" },
 100   { DRIVE_REMOTE,     "Network share"   },
 101   { DRIVE_REMOVABLE,  "Floppy disk"     },
 102   { DRIVE_CDROM,      "CD-ROM"          }
 103 };
 104
 105 #define DRIVE_TYPE_DEFAULT 1
 106
 107 void fill_drive_droplist(long mask, char curletter, HWND dialog)
 108 {
 109     int i;
 110     int selection;
 111     int count;
 112     int next_letter;
 113     char sName[4] = "A:";
 114
 115     for (i = 0, count = 0, selection = -1, next_letter = -1; i <= 'Z'-'A'; ++i)
 116     {
 117         if (mask & DRIVE_MASK_BIT('A' + i))
 118         {
 119             int index;
 120
 121             sName[0] = 'A' + i;
 122             index = SendDlgItemMessage(dialog, IDC_COMBO_LETTER, CB_ADDSTRING, 0, (LPARAM) sName);
 123
 124             if (toupper(curletter) == 'A' + i)
 125             {
 126                 selection = count;
 127             }
 128
 129             if (i >= 2 && next_letter == -1)
 130             {
 131                 /* default drive is first one of C-Z */
 132                 next_letter = count;
 133             }
 134
 135             count++;
 136         }
 137     }
 138
 139     if (selection == -1)
 140     {
 141         selection = next_letter;
 142     }
 143
 144     SendDlgItemMessage(dialog, IDC_COMBO_LETTER, CB_SETCURSEL, selection, 0);
 145 }
 146
 147
 148 void enable_labelserial_box(HWND dialog, int mode)
 149 {
 150     WINE_TRACE("mode=%d\n", mode);
 151
 152     switch (mode)
 153     {
 154         case BOX_MODE_CD_ASSIGN:
 155             enable(IDC_RADIO_ASSIGN);
 156             disable(IDC_EDIT_DEVICE);
 157             disable(IDC_BUTTON_BROWSE_DEVICE);
 158             enable(IDC_EDIT_SERIAL);
 159             enable(IDC_EDIT_LABEL);
 160             enable(IDC_STATIC_SERIAL);
 161             enable(IDC_STATIC_LABEL);
 162             break;
 163
 164         case BOX_MODE_CD_AUTODETECT:
 165             enable(IDC_RADIO_ASSIGN);
 166             enable(IDC_EDIT_DEVICE);
 167             enable(IDC_BUTTON_BROWSE_DEVICE);
 168             disable(IDC_EDIT_SERIAL);
 169             disable(IDC_EDIT_LABEL);
 170             disable(IDC_STATIC_SERIAL);
 171             disable(IDC_STATIC_LABEL);
 172             break;
 173
 174         case BOX_MODE_NONE:
 175             disable(IDC_RADIO_ASSIGN);
 176             disable(IDC_EDIT_DEVICE);
 177             disable(IDC_BUTTON_BROWSE_DEVICE);
 178             disable(IDC_EDIT_SERIAL);
 179             disable(IDC_EDIT_LABEL);
 180             disable(IDC_STATIC_SERIAL);
 181             disable(IDC_STATIC_LABEL);
 182             break;
 183
 184         case BOX_MODE_NORMAL:
 185             enable(IDC_RADIO_ASSIGN);
 186             disable(IDC_EDIT_DEVICE);
 187             disable(IDC_BUTTON_BROWSE_DEVICE);
 188             enable(IDC_EDIT_SERIAL);
 189             enable(IDC_EDIT_LABEL);
 190             enable(IDC_STATIC_SERIAL);
 191             enable(IDC_STATIC_LABEL);
 192             break;
 193     }
 194 }
 195
 196 int fill_drives_list(HWND dialog)
 197 {
 198     int count = 0;
 199     BOOL drivec_present = FALSE;
 200     int i;
 201     int prevsel = -1;
 202
 203     WINE_TRACE("\n");
 204
 205     updating_ui = TRUE;
 206
 207     prevsel = SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_GETCURSEL, 0, 0);
 208
 209     /* Clear the listbox */
 210     SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES), LB_RESETCONTENT, 0, 0);
 211
 212     for(i = 0; i < 26; i++)
 213     {
 214         char *title = 0;
 215         int len;
 216         int index;
 217
 218         /* skip over any unused drives */
 219         if (!drives[i].in_use)
 220             continue;
 221
 222         if (drives[i].letter == 'C')
 223             drivec_present = TRUE;
 224
 225         len = snprintf(title, 0, "%c:    %s", 'A' + i,
 226                        drives[i].unixpath);
 227         len++; /* add a byte for the trailing null */
 228
 229         title = HeapAlloc(GetProcessHeap(), 0, len);
 230
 231         /* the %s in the item label will be replaced by the drive letter, so -1, then
 232            -2 for the second %s which will be expanded to the label, finally + 1 for terminating #0 */
 233         snprintf(title, len, "%c:    %s", 'A' + i,
 234                  drives[i].unixpath);
 235
 236         WINE_TRACE("title is '%s'\n", title);
 237
 238         /* the first SendMessage call adds the string and returns the index, the second associates that index with it */
 239         index = SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES), LB_ADDSTRING ,(WPARAM) -1, (LPARAM) title);
 240         SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES), LB_SETITEMDATA, index, (LPARAM) &drives[i]);
 241
 242         HeapFree(GetProcessHeap(), 0, title);
 243         count++;
 244     }
 245
 246     WINE_TRACE("loaded %d drives\n", count);
 247
 248     /* show the warning if there is no Drive C */
 249     if (!drivec_present)
 250         ShowWindow(GetDlgItem(dialog, IDS_DRIVE_NO_C), SW_NORMAL);
 251     else
 252         ShowWindow(GetDlgItem(dialog, IDS_DRIVE_NO_C), SW_HIDE);
 253
 254     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_SETCURSEL, prevsel == -1 ? 0 : prevsel, 0);
 255
 256     updating_ui = FALSE;
 257     return count;
 258 }
 259
 260
 261 void on_add_click(HWND dialog)
 262 {
 263     /* we should allocate a drive letter automatically. We also need
 264        some way to let the user choose the mapping point, for now we
 265        will just force them to enter a path automatically, with / being
 266        the default. In future we should be able to temporarily map /
 267        then invoke the directory chooser dialog. */
 268
 269     char new = 'C'; /* we skip A and B, they are historically floppy drives */
 270     long mask = ~drive_available_mask(0); /* the mask is now which drives aren't available */
 271     int i, c;
 272
 273     while (mask & (1 << (new - 'A')))
 274     {
 275         new++;
 276         if (new > 'Z')
 277         {
 278             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);
 279             return;
 280         }
 281     }
 282
 283     WINE_TRACE("allocating drive letter %c\n", new);
 284
 285     if (new == 'C') add_drive(new, "../drive_c", "System Drive", "", DRIVE_FIXED);
 286     else add_drive(new, "/", "", "", DRIVE_FIXED);
 287
 288     fill_drives_list(dialog);
 289
 290     /* select the newly created drive */
 291     mask = ~drive_available_mask(0);
 292     c = 0;
 293     for (i = 0; i < 26; i++)
 294     {
 295         if ('A' + i == new) break;
 296         if ((1 << i) & mask) c++;
 297     }
 298     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_SETCURSEL, c, 0);
 299
 300     SetFocus(GetDlgItem(dialog, IDC_LIST_DRIVES));
 301
 302     update_controls(dialog);
 303 }
 304
 305 void on_remove_click(HWND dialog)
 306 {
 307     int item;
 308     struct drive *drive;
 309
 310     item = SendDlgItemMessage(dialog, IDC_LIST_DRIVES,  LB_GETCURSEL, 0, 0);
 311     if (item == -1) return; /* no selection */
 312
 313     drive = (struct drive *) SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_GETITEMDATA, item, 0);
 314
 315     if (drive->letter == 'C')
 316     {
 317         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);
 318         if (result == IDNO) return;
 319     }
 320
 321     delete_drive(drive);
 322
 323     fill_drives_list(dialog);
 324
 325     item = item - 1;
 326     if (item < 0) item = 0;
 327     SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_SETCURSEL, item, 0);   /* previous item */
 328
 329     SetFocus(GetDlgItem(dialog, IDC_LIST_DRIVES));
 330
 331     update_controls(dialog);
 332 }
 333
 334 static void update_controls(HWND dialog)
 335 {
 336     char *path;
 337     unsigned int type;
 338     char *label;
 339     char *serial;
 340     char *device;
 341     int i, selection = -1;
 342
 343     updating_ui = TRUE;
 344
 345     i = SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_GETCURSEL, 0, 0);
 346     if (i == -1)
 347     {
 348         /* no selection? let's select something for the user. this will re-enter */
 349         SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_SETCURSEL, 0, 0);
 350         return;
 351     }
 352     current_drive = (struct drive *) SendDlgItemMessage(dialog, IDC_LIST_DRIVES, LB_GETITEMDATA, i, 0);
 353
 354     WINE_TRACE("Updating sheet for drive %c\n", current_drive->letter);
 355
 356     /* Drive letters */
 357     fill_drive_droplist(drive_available_mask(current_drive->letter), current_drive->letter, dialog);
 358
 359     /* path */
 360     path = current_drive->unixpath;
 361     WINE_TRACE("set path control text to '%s'\n", path);
 362     set_text(dialog, IDC_EDIT_PATH, path);
 363
 364     /* drive type */
 365     type = current_drive->type;
 366     if (type)
 367     {
 368         SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_RESETCONTENT, 0, 0);
 369
 370         for (i = 0; i < sizeof(type_pairs) / sizeof(struct drive_typemap); i++)
 371         {
 372             SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_ADDSTRING, 0, (LPARAM) type_pairs[i].sDesc);
 373
 374             if (type_pairs[i].sCode ==  type)
 375             {
 376                 selection = i;
 377             }
 378         }
 379
 380         if (selection == -1) selection = DRIVE_TYPE_DEFAULT;
 381         SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_SETCURSEL, selection, 0);
 382     } else WINE_WARN("no Type field?\n");
 383
 384
 385     /* removeable media properties */
 386     label = current_drive->label;
 387     set_text(dialog, IDC_EDIT_LABEL, label);
 388
 389     /* set serial edit text */
 390     serial = current_drive->serial;
 391     set_text(dialog, IDC_EDIT_SERIAL, serial);
 392
 393     /* TODO: get the device here to put into the edit box */
 394     device = "Not implemented yet";
 395     set_text(dialog, IDC_EDIT_DEVICE, device);
 396     device = NULL;
 397
 398     selection = IDC_RADIO_ASSIGN;
 399     if ((type == DRIVE_CDROM) || (type == DRIVE_REMOVABLE))
 400     {
 401         if (device)
 402         {
 403             selection = IDC_RADIO_AUTODETECT;
 404             enable_labelserial_box(dialog, BOX_MODE_CD_AUTODETECT);
 405         }
 406         else
 407         {
 408             selection = IDC_RADIO_ASSIGN;
 409             enable_labelserial_box(dialog, BOX_MODE_CD_ASSIGN);
 410         }
 411     }
 412     else
 413     {
 414         enable_labelserial_box(dialog, BOX_MODE_NORMAL);
 415         selection = IDC_RADIO_ASSIGN;
 416     }
 417
 418     CheckRadioButton(dialog, IDC_RADIO_AUTODETECT, IDC_RADIO_ASSIGN, selection);
 419
 420     updating_ui = FALSE;
 421
 422     return;
 423 }
 424
 425 void on_edit_changed(HWND dialog, WORD id)
 426 {
 427     if (updating_ui) return;
 428
 429     WINE_TRACE("edit id %d changed\n", id);
 430
 431     /* using fill_drives_list here is pretty lazy, but i'm tired
 432
 433        fortunately there are only 26 letters in the alphabet, so
 434        we don't have to worry about efficiency too much here :)  */
 435
 436     switch (id)
 437     {
 438         case IDC_EDIT_LABEL:
 439         {
 440             char *label;
 441
 442             label = get_text(dialog, id);
 443             HeapFree(GetProcessHeap(), 0, current_drive->label);
 444             current_drive->label = label ? label :  strdupA("");
 445
 446             WINE_TRACE("set label to %s\n", current_drive->label);
 447
 448             fill_drives_list(dialog);
 449             break;
 450         }
 451
 452         case IDC_EDIT_PATH:
 453         {
 454             char *path;
 455
 456             path = get_text(dialog, id);
 457             HeapFree(GetProcessHeap(), 0, current_drive->unixpath);
 458             current_drive->unixpath = path ? path : strdupA("drive_c");
 459
 460             WINE_TRACE("set path to %s\n", current_drive->unixpath);
 461
 462             fill_drives_list(dialog);
 463             break;
 464         }
 465
 466         case IDC_EDIT_SERIAL:
 467         {
 468             char *serial;
 469
 470             serial = get_text(dialog, id);
 471             HeapFree(GetProcessHeap(), 0, current_drive->serial);
 472             current_drive->serial = serial ? serial : strdupA("");
 473
 474             WINE_TRACE("set serial to %s", current_drive->serial);
 475
 476             break;
 477         }
 478
 479         case IDC_EDIT_DEVICE:
 480         {
 481             char *device = get_text(dialog, id);
 482             /* TODO: handle device if/when it makes sense to do so.... */
 483             HeapFree(GetProcessHeap(), 0, device);
 484             fill_drives_list(dialog);
 485             break;
 486         }
 487     }
 488 }
 489
 490 static void get_etched_rect(HWND dialog, RECT *rect)
 491 {
 492     GetClientRect(dialog, rect);
 493
 494     /* these dimensions from the labelserial static in En.rc  */
 495     rect->top = 265;
 496     rect->bottom = 265;
 497     rect->left += 25;
 498     rect->right -= 25;
 499 }
 500
 501 /* this just draws a nice line to separate the advanced gui from the n00b gui :) */
 502 static void paint(HWND dialog)
 503 {
 504     PAINTSTRUCT ps;
 505
 506     BeginPaint(dialog, &ps);
 507
 508     if (advanced)
 509     {
 510         RECT rect;
 511
 512         get_etched_rect(dialog, &rect);
 513
 514         DrawEdge(ps.hdc, &rect, EDGE_ETCHED, BF_TOP);
 515     }
 516
 517     EndPaint(dialog, &ps);
 518 }
 519
 520 static void browse_for_folder(HWND dialog)
 521 {
 522     static WCHAR wszUnixRootDisplayName[] =
 523         { ':',':','{','C','C','7','0','2','E','B','2','-','7','D','C','5','-','1','1','D','9','-',
 524           'C','6','8','7','-','0','0','0','4','2','3','8','A','0','1','C','D','}','\\','/', 0 };
 525     BROWSEINFOA bi = {
 526         dialog,
 527         NULL,
 528         NULL,
 529         "Select the unix directory to be mapped, please.",
 530         0,
 531         NULL,
 532         0,
 533         0
 534     };
 535     IShellFolder *pDesktop;
 536     LPITEMIDLIST pidlUnixRoot, pidlSelectedPath;
 537     HRESULT hr;
 538
 539     hr = SHGetDesktopFolder(&pDesktop);
 540     if (!SUCCEEDED(hr)) return;
 541
 542     hr = pDesktop->lpVtbl->ParseDisplayName(pDesktop, NULL, NULL, wszUnixRootDisplayName, NULL,
 543                                             &pidlUnixRoot, NULL);
 544     if (!SUCCEEDED(hr)) {
 545         pDesktop->lpVtbl->Release(pDesktop);
 546         return;
 547     }
 548
 549     bi.pidlRoot = pidlUnixRoot;
 550     pidlSelectedPath = SHBrowseForFolderA(&bi);
 551
 552     SHFree(pidlUnixRoot);
 553
 554     if (pidlSelectedPath) {
 555         STRRET strSelectedPath;
 556         char *pszSelectedPath;
 557         HRESULT hr;
 558
 559         hr = pDesktop->lpVtbl->GetDisplayNameOf(pDesktop, pidlSelectedPath, SHGDN_FORPARSING,
 560                                                 &strSelectedPath);
 561         pDesktop->lpVtbl->Release(pDesktop);
 562         if (!SUCCEEDED(hr)) {
 563             SHFree(pidlSelectedPath);
 564             return;
 565         }
 566
 567         hr = StrRetToStr(&strSelectedPath, pidlSelectedPath, &pszSelectedPath);
 568         SHFree(pidlSelectedPath);
 569         if (!SUCCEEDED(hr)) return;
 570
 571         HeapFree(GetProcessHeap(), 0, current_drive->unixpath);
 572         current_drive->unixpath = strdupA(pszSelectedPath);
 573         fill_drives_list(dialog);
 574         update_controls(dialog);
 575
 576         CoTaskMemFree(pszSelectedPath);
 577     }
 578 }
 579
 580 INT_PTR CALLBACK
 581 DriveDlgProc (HWND dialog, UINT msg, WPARAM wParam, LPARAM lParam)
 582 {
 583     int item;
 584     struct drive *drive;
 585
 586     switch (msg)
 587     {
 588         case WM_INITDIALOG:
 589             load_drives();
 590
 591             if (!drives[2].in_use)
 592                 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);
 593
 594             fill_drives_list(dialog);
 595             update_controls(dialog);
 596             /* put in non-advanced mode by default  */
 597             set_advanced(dialog);
 598             break;
 599
 600         case WM_SHOWWINDOW:
 601             set_window_title(dialog);
 602             break;
 603
 604         case WM_PAINT:
 605             paint(dialog);
 606             break;
 607
 608         case WM_COMMAND:
 609             if (HIWORD(wParam) == EN_CHANGE)
 610             {
 611                 on_edit_changed(dialog, LOWORD(wParam));
 612                 break;
 613             }
 614
 615             switch (LOWORD(wParam))
 616             {
 617                 case IDC_LIST_DRIVES:
 618                     if (HIWORD(wParam) == LBN_SELCHANGE)
 619                         update_controls(dialog);
 620
 621                     break;
 622
 623                 case IDC_BUTTON_ADD:
 624                     if (HIWORD(wParam) != BN_CLICKED) break;
 625                     on_add_click(dialog);
 626                     break;
 627
 628                 case IDC_BUTTON_REMOVE:
 629                     if (HIWORD(wParam) != BN_CLICKED) break;
 630                     on_remove_click(dialog);
 631                     break;
 632
 633                 case IDC_BUTTON_EDIT:
 634                     if (HIWORD(wParam) != BN_CLICKED) break;
 635                     item = SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES),  LB_GETCURSEL, 0, 0);
 636                     drive = (struct drive *) SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES), LB_GETITEMDATA, item, 0);
 637                     /*DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_DRIVE_EDIT), NULL, (DLGPROC) DriveEditDlgProc, (LPARAM) drive); */
 638                     break;
 639
 640                 case IDC_BUTTON_AUTODETECT:
 641                     autodetect_drives();
 642                     fill_drives_list(dialog);
 643                     break;
 644
 645                 case IDC_BUTTON_SHOW_HIDE_ADVANCED:
 646                     advanced = !advanced;
 647                     set_advanced(dialog);
 648                     break;
 649
 650                 case IDC_BUTTON_BROWSE_PATH:
 651                     browse_for_folder(dialog);
 652                     break;
 653
 654                 case IDC_RADIO_ASSIGN:
 655                 {
 656                     char *str;
 657
 658                     str = get_text(dialog, IDC_EDIT_LABEL);
 659                     HeapFree(GetProcessHeap(), 0, current_drive->label);
 660                     current_drive->label = str ? str : strdupA("");
 661
 662                     str = get_text(dialog, IDC_EDIT_SERIAL);
 663                     HeapFree(GetProcessHeap(), 0, current_drive->serial);
 664                     current_drive->serial = str ? str : strdupA("");
 665
 666                     /* TODO: we don't have a device at this point */
 667
 668                     enable_labelserial_box(dialog, BOX_MODE_CD_ASSIGN);
 669
 670                     break;
 671                 }
 672
 673
 674                 case IDC_COMBO_TYPE:
 675                 {
 676                     int mode = BOX_MODE_NORMAL;
 677                     int selection;
 678
 679                     if (HIWORD(wParam) != CBN_SELCHANGE) break;
 680
 681                     selection = SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_GETCURSEL, 0, 0);
 682
 683                     if (selection == 2 || selection == 3) /* cdrom or floppy */
 684                     {
 685                         if (IsDlgButtonChecked(dialog, IDC_RADIO_AUTODETECT))
 686                             mode = BOX_MODE_CD_AUTODETECT;
 687                         else
 688                             mode = BOX_MODE_CD_ASSIGN;
 689                     }
 690
 691                     enable_labelserial_box(dialog, mode);
 692
 693                     current_drive->type = type_pairs[selection].sCode;
 694                     break;
 695                 }
 696
 697             }
 698             break;
 699
 700         case WM_NOTIFY:
 701             switch (((LPNMHDR)lParam)->code)
 702             {
 703                 case PSN_KILLACTIVE:
 704                     WINE_TRACE("PSN_KILLACTIVE\n");
 705                     SetWindowLongPtr(dialog, DWLP_MSGRESULT, FALSE);
 706                     break;
 707                 case PSN_APPLY:
 708                     apply_drive_changes();
 709                     SetWindowLongPtr(dialog, DWLP_MSGRESULT, PSNRET_NOERROR);
 710                     break;
 711                 case PSN_SETACTIVE:
 712                     break;
 713             }
 714             break;
 715     }
 716
 717     return FALSE;
 718 }