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     const uint sCode;
  95     const char *sDesc;
  96 };
  97
  98 static 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     uint 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         for (i = 0; i < sizeof(type_pairs) / sizeof(struct drive_typemap); i++)
 369         {
 370             SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_ADDSTRING, 0, (LPARAM) type_pairs[i].sDesc);
 371
 372             if (type_pairs[i].sCode ==  type)
 373             {
 374                 selection = i;
 375             }
 376         }
 377
 378         if (selection == -1) selection = DRIVE_TYPE_DEFAULT;
 379         SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_SETCURSEL, selection, 0);
 380     } else WINE_WARN("no Type field?\n");
 381
 382
 383     /* removeable media properties */
 384     label = current_drive->label;
 385     set_text(dialog, IDC_EDIT_LABEL, label);
 386
 387     /* set serial edit text */
 388     serial = current_drive->serial;
 389     set_text(dialog, IDC_EDIT_SERIAL, serial);
 390
 391     /* TODO: get the device here to put into the edit box */
 392     device = "Not implemented yet";
 393     set_text(dialog, IDC_EDIT_DEVICE, device);
 394     device = NULL;
 395
 396     selection = IDC_RADIO_ASSIGN;
 397     if ((type == DRIVE_CDROM) || (type == DRIVE_REMOVABLE))
 398     {
 399         if (device)
 400         {
 401             selection = IDC_RADIO_AUTODETECT;
 402             enable_labelserial_box(dialog, BOX_MODE_CD_AUTODETECT);
 403         }
 404         else
 405         {
 406             selection = IDC_RADIO_ASSIGN;
 407             enable_labelserial_box(dialog, BOX_MODE_CD_ASSIGN);
 408         }
 409     }
 410     else
 411     {
 412         enable_labelserial_box(dialog, BOX_MODE_NORMAL);
 413         selection = IDC_RADIO_ASSIGN;
 414     }
 415
 416     CheckRadioButton(dialog, IDC_RADIO_AUTODETECT, IDC_RADIO_ASSIGN, selection);
 417
 418     updating_ui = FALSE;
 419
 420     return;
 421 }
 422
 423 void on_edit_changed(HWND dialog, WORD id)
 424 {
 425     if (updating_ui) return;
 426
 427     WINE_TRACE("edit id %d changed\n", id);
 428
 429     /* using fill_drives_list here is pretty lazy, but i'm tired
 430
 431        fortunately there are only 26 letters in the alphabet, so
 432        we don't have to worry about efficiency too much here :)  */
 433
 434     switch (id)
 435     {
 436         case IDC_EDIT_LABEL:
 437         {
 438             char *label;
 439
 440             label = get_text(dialog, id);
 441             HeapFree(GetProcessHeap(), 0, current_drive->label);
 442             current_drive->label = label ? label :  strdupA("");
 443
 444             WINE_TRACE("set label to %s\n", current_drive->label);
 445
 446             fill_drives_list(dialog);
 447             break;
 448         }
 449
 450         case IDC_EDIT_PATH:
 451         {
 452             char *path;
 453
 454             path = get_text(dialog, id);
 455             HeapFree(GetProcessHeap(), 0, current_drive->unixpath);
 456             current_drive->unixpath = path ? path : strdupA("drive_c");
 457
 458             WINE_TRACE("set path to %s\n", current_drive->unixpath);
 459
 460             fill_drives_list(dialog);
 461             break;
 462         }
 463
 464         case IDC_EDIT_SERIAL:
 465         {
 466             char *serial;
 467
 468             serial = get_text(dialog, id);
 469             HeapFree(GetProcessHeap(), 0, current_drive->serial);
 470             current_drive->serial = serial ? serial : strdupA("");
 471
 472             WINE_TRACE("set serial to %s", current_drive->serial);
 473
 474             break;
 475         }
 476
 477         case IDC_EDIT_DEVICE:
 478         {
 479             char *device = get_text(dialog, id);
 480             /* TODO: handle device if/when it makes sense to do so.... */
 481             HeapFree(GetProcessHeap(), 0, device);
 482             fill_drives_list(dialog);
 483             break;
 484         }
 485     }
 486 }
 487
 488 static void get_etched_rect(HWND dialog, RECT *rect)
 489 {
 490     GetClientRect(dialog, rect);
 491
 492     /* these dimensions from the labelserial static in En.rc  */
 493     rect->top = 258;
 494     rect->bottom = 258;
 495     rect->left += 35;
 496     rect->right -= 25;
 497 }
 498
 499 /* this just draws a nice line to separate the advanced gui from the n00b gui :) */
 500 static void paint(HWND dialog)
 501 {
 502     PAINTSTRUCT ps;
 503
 504     BeginPaint(dialog, &ps);
 505
 506     if (advanced)
 507     {
 508         RECT rect;
 509
 510         get_etched_rect(dialog, &rect);
 511
 512         DrawEdge(ps.hdc, &rect, EDGE_ETCHED, BF_TOP);
 513     }
 514
 515     EndPaint(dialog, &ps);
 516 }
 517
 518 INT_PTR CALLBACK
 519 DriveDlgProc (HWND dialog, UINT msg, WPARAM wParam, LPARAM lParam)
 520 {
 521     int item;
 522     struct drive *drive;
 523
 524     switch (msg)
 525     {
 526         case WM_INITDIALOG:
 527             load_drives();
 528
 529             if (!drives[2].in_use)
 530                 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);
 531
 532             fill_drives_list(dialog);
 533             update_controls(dialog);
 534             /* put in non-advanced mode by default  */
 535             set_advanced(dialog);
 536             break;
 537
 538         case WM_SHOWWINDOW:
 539             set_window_title(dialog);
 540             break;
 541
 542         case WM_PAINT:
 543             paint(dialog);
 544             break;
 545
 546         case WM_COMMAND:
 547             if (HIWORD(wParam) == EN_CHANGE)
 548             {
 549                 on_edit_changed(dialog, LOWORD(wParam));
 550                 break;
 551             }
 552
 553             switch (LOWORD(wParam))
 554             {
 555                 case IDC_LIST_DRIVES:
 556                     if (HIWORD(wParam) == LBN_SELCHANGE)
 557                         update_controls(dialog);
 558
 559                     break;
 560
 561                 case IDC_BUTTON_ADD:
 562                     if (HIWORD(wParam) != BN_CLICKED) break;
 563                     on_add_click(dialog);
 564                     break;
 565
 566                 case IDC_BUTTON_REMOVE:
 567                     if (HIWORD(wParam) != BN_CLICKED) break;
 568                     on_remove_click(dialog);
 569                     break;
 570
 571                 case IDC_BUTTON_EDIT:
 572                     if (HIWORD(wParam) != BN_CLICKED) break;
 573                     item = SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES),  LB_GETCURSEL, 0, 0);
 574                     drive = (struct drive *) SendMessage(GetDlgItem(dialog, IDC_LIST_DRIVES), LB_GETITEMDATA, item, 0);
 575                     /*DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_DRIVE_EDIT), NULL, (DLGPROC) DriveEditDlgProc, (LPARAM) drive); */
 576                     break;
 577
 578                 case IDC_BUTTON_AUTODETECT:
 579                     autodetect_drives();
 580                     fill_drives_list(dialog);
 581                     break;
 582
 583                 case IDC_BUTTON_SHOW_HIDE_ADVANCED:
 584                     advanced = !advanced;
 585                     set_advanced(dialog);
 586                     break;
 587
 588                 case IDC_BUTTON_BROWSE_PATH:
 589                     MessageBox(dialog, "", "Write me!", MB_OK);
 590                     break;
 591
 592                 case IDC_RADIO_ASSIGN:
 593                 {
 594                     char *str;
 595
 596                     str = get_text(dialog, IDC_EDIT_LABEL);
 597                     HeapFree(GetProcessHeap(), 0, current_drive->label);
 598                     current_drive->label = str ? str : strdupA("");
 599
 600                     str = get_text(dialog, IDC_EDIT_SERIAL);
 601                     HeapFree(GetProcessHeap(), 0, current_drive->serial);
 602                     current_drive->serial = str ? str : strdupA("");
 603
 604                     /* TODO: we don't have a device at this point */
 605
 606                     enable_labelserial_box(dialog, BOX_MODE_CD_ASSIGN);
 607
 608                     break;
 609                 }
 610
 611
 612                 case IDC_COMBO_TYPE:
 613                 {
 614                     int mode = BOX_MODE_NORMAL;
 615                     int selection;
 616
 617                     if (HIWORD(wParam) != CBN_SELCHANGE) break;
 618
 619                     selection = SendDlgItemMessage(dialog, IDC_COMBO_TYPE, CB_GETCURSEL, 0, 0);
 620
 621                     if (selection == 2 || selection == 3) /* cdrom or floppy */
 622                     {
 623                         if (IsDlgButtonChecked(dialog, IDC_RADIO_AUTODETECT))
 624                             mode = BOX_MODE_CD_AUTODETECT;
 625                         else
 626                             mode = BOX_MODE_CD_ASSIGN;
 627                     }
 628
 629                     enable_labelserial_box(dialog, mode);
 630
 631                     current_drive->type = type_pairs[selection].sCode;
 632                     break;
 633                 }
 634
 635             }
 636             break;
 637
 638         case WM_NOTIFY:
 639             switch (((LPNMHDR)lParam)->code)
 640             {
 641                 case PSN_KILLACTIVE:
 642                     WINE_TRACE("PSN_KILLACTIVE\n");
 643                     SetWindowLong(dialog, DWL_MSGRESULT, FALSE);
 644                     break;
 645                 case PSN_APPLY:
 646                     apply_drive_changes();
 647                     SetWindowLong(dialog, DWL_MSGRESULT, PSNRET_NOERROR);
 648                     break;
 649                 case PSN_SETACTIVE:
 650                     break;
 651             }
 652             break;
 653     }
 654
 655     return FALSE;
 656 }