WINGs/wfilepanel.c

   1
   2 #include "WINGsP.h"
   3
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <unistd.h>
   7 #include <dirent.h>
   8 #include <limits.h>
   9 #include <errno.h>
  10
  11 #ifndef PATH_MAX
  12 #define PATH_MAX 1024
  13 #endif
  14
  15
  16 typedef struct W_FilePanel {
  17     WMWindow *win;
  18
  19     WMLabel *iconLabel;
  20     WMLabel *titleLabel;
  21
  22     WMFrame *line;
  23
  24     WMLabel *nameLabel;
  25     WMBrowser *browser;
  26
  27     WMButton *okButton;
  28     WMButton *cancelButton;
  29
  30     WMButton *homeButton;
  31     WMButton *trashcanButton;
  32     WMButton *createDirButton;
  33     WMButton *disketteButton;
  34     WMButton *unmountButton;
  35
  36     WMView *accessoryView;
  37
  38     WMTextField *fileField;
  39
  40     char **fileTypes;
  41
  42     struct {
  43         unsigned int canExit:1;
  44         unsigned int canceled:1;       /* clicked on cancel */
  45         unsigned int filtered:1;
  46         unsigned int canChooseFiles:1;
  47         unsigned int canChooseDirectories:1;
  48         unsigned int autoCompletion:1;
  49         unsigned int showAllFiles:1;
  50         unsigned int canFreeFileTypes:1;
  51         unsigned int fileMustExist:1;
  52         unsigned int panelType:1;
  53     } flags;
  54 } W_FilePanel;
  55
  56
  57 /* Type of panel */
  58 #define WP_OPEN         0
  59 #define WP_SAVE         1
  60
  61 #define PWIDTH          330
  62 #define PHEIGHT         360
  63
  64 static void listDirectoryOnColumn(WMFilePanel *panel, int column, char *path);
  65 static void browserClick();
  66 static void browserDClick();
  67
  68 static void fillColumn(WMBrowserDelegate *self, WMBrowser *bPtr, int column,
  69                        WMList *list);
  70
  71 static void deleteFile();
  72
  73 static void createDir();
  74
  75 static void goHome();
  76
  77 static void goFloppy();
  78
  79 static void goUnmount();
  80
  81 static void buttonClick();
  82
  83 static char *getCurrentFileName(WMFilePanel *panel);
  84
  85 static void handleEvents(XEvent *event, void *data);
  86
  87
  88
  89 static WMBrowserDelegate browserDelegate = {
  90     NULL, /* data */
  91         fillColumn, /* createRowsForColumn */
  92         NULL, /* titleOfColumn */
  93         NULL, /* didScroll */
  94         NULL  /* willScroll */
  95 };
  96
  97
  98 static int
  99 closestListItem(WMList *list, char *text, Bool exact)
 100 {
 101     WMListItem *item;
 102     WMArray *items = WMGetListItems(list);
 103     int i, len = strlen(text);
 104
 105     if (len==0)
 106         return -1;
 107
 108     for(i=0; i<WMGetArrayItemCount(items); i++) {
 109         item = WMGetFromArray(items, i);
 110         if (strlen(item->text) >= len &&
 111             ((exact && strcmp(item->text, text)==0) ||
 112              (!exact && strncmp(item->text, text, len)==0))) {
 113             return i;
 114         }
 115     }
 116
 117     return -1;
 118 }
 119
 120
 121 static void
 122 textChangedObserver(void *observerData, WMNotification *notification)
 123 {
 124     W_FilePanel *panel = (W_FilePanel*)observerData;
 125     char *text;
 126     WMList *list;
 127     int col = WMGetBrowserNumberOfColumns(panel->browser) - 1;
 128     int i, textEvent;
 129
 130     if (!(list = WMGetBrowserListInColumn(panel->browser, col)))
 131         return;
 132
 133     text = WMGetTextFieldText(panel->fileField);
 134     textEvent = (int)WMGetNotificationClientData(notification);
 135
 136     if (panel->flags.autoCompletion && textEvent!=WMDeleteTextEvent)
 137         i = closestListItem(list, text, False);
 138     else
 139         i = closestListItem(list, text, True);
 140
 141     WMSelectListItem(list, i);
 142     if (i>=0 && panel->flags.autoCompletion) {
 143         WMListItem *item = WMGetListItem(list, i);
 144         int textLen = strlen(text), itemTextLen = strlen(item->text);
 145         int visibleItems = WMWidgetHeight(list)/WMGetListItemHeight(list);
 146
 147         WMSetListPosition(list, i - visibleItems/2);
 148
 149         if (textEvent!=WMDeleteTextEvent) {
 150             WMRange range;
 151
 152             WMInsertTextFieldText(panel->fileField, &item->text[textLen],
 153                                   textLen);
 154             range.position = textLen;
 155             range.count = itemTextLen - textLen;
 156             WMSelectTextFieldRange(panel->fileField, range);
 157             /*WMSetTextFieldCursorPosition(panel->fileField, itemTextLen);*/
 158         }
 159     }
 160
 161     wfree(text);
 162 }
 163
 164
 165 static void
 166 textEditedObserver(void *observerData, WMNotification *notification)
 167 {
 168     W_FilePanel *panel = (W_FilePanel*)observerData;
 169
 170     if ((int)WMGetNotificationClientData(notification)==WMReturnTextMovement) {
 171         WMPerformButtonClick(panel->okButton);
 172     }
 173 }
 174
 175
 176
 177 static WMFilePanel*
 178 makeFilePanel(WMScreen *scrPtr, char *name, char *title)
 179 {
 180     WMFilePanel *fPtr;
 181     WMFont *largeFont;
 182
 183     fPtr = wmalloc(sizeof(WMFilePanel));
 184     memset(fPtr, 0, sizeof(WMFilePanel));
 185
 186     fPtr->win = WMCreateWindowWithStyle(scrPtr, name, WMTitledWindowMask
 187                                         |WMResizableWindowMask);
 188     WMResizeWidget(fPtr->win, PWIDTH, PHEIGHT);
 189     WMSetWindowTitle(fPtr->win, "");
 190
 191     WMCreateEventHandler(WMWidgetView(fPtr->win), StructureNotifyMask,
 192                          handleEvents, fPtr);
 193     WMSetWindowMinSize(fPtr->win, PWIDTH, PHEIGHT);
 194
 195
 196     fPtr->iconLabel = WMCreateLabel(fPtr->win);
 197     WMResizeWidget(fPtr->iconLabel, 64, 64);
 198     WMMoveWidget(fPtr->iconLabel, 0, 0);
 199     WMSetLabelImagePosition(fPtr->iconLabel, WIPImageOnly);
 200     WMSetLabelImage(fPtr->iconLabel, scrPtr->applicationIcon);
 201
 202     fPtr->titleLabel = WMCreateLabel(fPtr->win);
 203     WMResizeWidget(fPtr->titleLabel, PWIDTH-64, 64);
 204     WMMoveWidget(fPtr->titleLabel, 64, 0);
 205     largeFont = WMBoldSystemFontOfSize(scrPtr, 24);
 206     WMSetLabelFont(fPtr->titleLabel, largeFont);
 207     WMReleaseFont(largeFont);
 208     WMSetLabelText(fPtr->titleLabel, title);
 209
 210     fPtr->line = WMCreateFrame(fPtr->win);
 211     WMMoveWidget(fPtr->line, 0, 64);
 212     WMResizeWidget(fPtr->line, PWIDTH, 2);
 213     WMSetFrameRelief(fPtr->line, WRGroove);
 214
 215     fPtr->browser = WMCreateBrowser(fPtr->win);
 216     WMSetBrowserAllowEmptySelection(fPtr->browser, True);
 217     WMSetBrowserDelegate(fPtr->browser, &browserDelegate);
 218     WMSetBrowserAction(fPtr->browser, browserClick, fPtr);
 219     WMSetBrowserDoubleAction(fPtr->browser, browserDClick, fPtr);
 220     WMMoveWidget(fPtr->browser, 7, 72);
 221     WMResizeWidget(fPtr->browser, PWIDTH-14,200);
 222     WMHangData(fPtr->browser, fPtr);
 223
 224     fPtr->nameLabel = WMCreateLabel(fPtr->win);
 225     WMMoveWidget(fPtr->nameLabel, 7, 282);
 226     WMResizeWidget(fPtr->nameLabel, 55, 14);
 227     WMSetLabelText(fPtr->nameLabel, "Name:");
 228
 229     fPtr->fileField = WMCreateTextField(fPtr->win);
 230     WMMoveWidget(fPtr->fileField, 60, 278);
 231     WMResizeWidget(fPtr->fileField, PWIDTH-60-10, 24);
 232     WMAddNotificationObserver(textEditedObserver, fPtr,
 233                               WMTextDidEndEditingNotification,
 234                               fPtr->fileField);
 235     WMAddNotificationObserver(textChangedObserver, fPtr,
 236                               WMTextDidChangeNotification,
 237                               fPtr->fileField);
 238
 239     fPtr->okButton = WMCreateCommandButton(fPtr->win);
 240     WMMoveWidget(fPtr->okButton, 245, 325);
 241     WMResizeWidget(fPtr->okButton, 75, 28);
 242     WMSetButtonText(fPtr->okButton, "OK");
 243     WMSetButtonImage(fPtr->okButton, scrPtr->buttonArrow);
 244     WMSetButtonAltImage(fPtr->okButton, scrPtr->pushedButtonArrow);
 245     WMSetButtonImagePosition(fPtr->okButton, WIPRight);
 246     WMSetButtonAction(fPtr->okButton, buttonClick, fPtr);
 247
 248     fPtr->cancelButton = WMCreateCommandButton(fPtr->win);
 249     WMMoveWidget(fPtr->cancelButton, 165, 325);
 250     WMResizeWidget(fPtr->cancelButton, 75, 28);
 251     WMSetButtonText(fPtr->cancelButton, "Cancel");
 252     WMSetButtonAction(fPtr->cancelButton, buttonClick, fPtr);
 253
 254     fPtr->trashcanButton = WMCreateCommandButton(fPtr->win);
 255     WMMoveWidget(fPtr->trashcanButton, 7, 325);
 256     WMResizeWidget(fPtr->trashcanButton, 28, 28);
 257     WMSetButtonImagePosition(fPtr->trashcanButton, WIPImageOnly);
 258     WMSetButtonImage(fPtr->trashcanButton, scrPtr->trashcanIcon);
 259     WMSetButtonAltImage(fPtr->trashcanButton, scrPtr->altTrashcanIcon);
 260     WMSetButtonAction(fPtr->trashcanButton, deleteFile, fPtr);
 261
 262     fPtr->createDirButton = WMCreateCommandButton(fPtr->win);
 263     WMMoveWidget(fPtr->createDirButton, 37, 325);
 264     WMResizeWidget(fPtr->createDirButton, 28, 28);
 265     WMSetButtonImagePosition(fPtr->createDirButton, WIPImageOnly);
 266     WMSetButtonImage(fPtr->createDirButton, scrPtr->createDirIcon);
 267     WMSetButtonAltImage(fPtr->createDirButton, scrPtr->altCreateDirIcon);
 268     WMSetButtonAction(fPtr->createDirButton, createDir, fPtr);
 269
 270     fPtr->homeButton = WMCreateCommandButton(fPtr->win);
 271     WMMoveWidget(fPtr->homeButton, 67, 325);
 272     WMResizeWidget(fPtr->homeButton, 28, 28);
 273     WMSetButtonImagePosition(fPtr->homeButton, WIPImageOnly);
 274     WMSetButtonImage(fPtr->homeButton, scrPtr->homeIcon);
 275     WMSetButtonAltImage(fPtr->homeButton, scrPtr->altHomeIcon);
 276     WMSetButtonAction(fPtr->homeButton, goHome, fPtr);
 277
 278     fPtr->disketteButton = WMCreateCommandButton(fPtr->win);
 279     WMMoveWidget(fPtr->disketteButton, 97, 325);
 280     WMResizeWidget(fPtr->disketteButton, 28, 28);
 281     WMSetButtonImagePosition(fPtr->disketteButton, WIPImageOnly);
 282     WMSetButtonImage(fPtr->disketteButton, scrPtr->disketteIcon);
 283     WMSetButtonAltImage(fPtr->disketteButton, scrPtr->altDisketteIcon);
 284     WMSetButtonAction(fPtr->disketteButton, goFloppy, fPtr);
 285
 286     fPtr->unmountButton = WMCreateCommandButton(fPtr->win);
 287     WMMoveWidget(fPtr->unmountButton, 127, 325);
 288     WMResizeWidget(fPtr->unmountButton, 28, 28);
 289     WMSetButtonImagePosition(fPtr->unmountButton, WIPImageOnly);
 290     WMSetButtonImage(fPtr->unmountButton, scrPtr->unmountIcon);
 291     WMSetButtonAltImage(fPtr->unmountButton, scrPtr->altUnmountIcon);
 292     WMSetButtonAction(fPtr->unmountButton, goUnmount, fPtr);
 293     WMSetButtonEnabled(fPtr->unmountButton, False);
 294
 295
 296     WMRealizeWidget(fPtr->win);
 297     WMMapSubwidgets(fPtr->win);
 298
 299     WMSetFocusToWidget(fPtr->fileField);
 300     WMSetTextFieldCursorPosition(fPtr->fileField, 0);
 301
 302     WMLoadBrowserColumnZero(fPtr->browser);
 303
 304     WMSetWindowInitialPosition(fPtr->win,
 305                (scrPtr->rootView->size.width - WMWidgetWidth(fPtr->win))/2,
 306                (scrPtr->rootView->size.height - WMWidgetHeight(fPtr->win))/2);
 307
 308     fPtr->flags.canChooseFiles = 1;
 309     fPtr->flags.canChooseDirectories = 1;
 310     fPtr->flags.autoCompletion = 1;
 311
 312     return fPtr;
 313 }
 314
 315
 316 WMOpenPanel*
 317 WMGetOpenPanel(WMScreen *scrPtr)
 318 {
 319     WMFilePanel *panel;
 320
 321     if (scrPtr->sharedOpenPanel)
 322         return scrPtr->sharedOpenPanel;
 323
 324     panel = makeFilePanel(scrPtr, "openFilePanel", "Open");
 325     panel->flags.fileMustExist = 1;
 326     panel->flags.panelType = WP_OPEN;
 327
 328     scrPtr->sharedOpenPanel = panel;
 329
 330     return panel;
 331 }
 332
 333
 334 WMSavePanel*
 335 WMGetSavePanel(WMScreen *scrPtr)
 336 {
 337     WMFilePanel *panel;
 338
 339     if (scrPtr->sharedSavePanel)
 340         return scrPtr->sharedSavePanel;
 341
 342     panel = makeFilePanel(scrPtr, "saveFilePanel", "Save");
 343     panel->flags.fileMustExist = 0;
 344     panel->flags.panelType = WP_SAVE;
 345
 346     scrPtr->sharedSavePanel = panel;
 347
 348     return panel;
 349 }
 350
 351
 352 void
 353 WMFreeFilePanel(WMFilePanel *panel)
 354 {
 355     if (panel == WMWidgetScreen(panel->win)->sharedSavePanel) {
 356         WMWidgetScreen(panel->win)->sharedSavePanel = NULL;
 357     }
 358     if (panel == WMWidgetScreen(panel->win)->sharedOpenPanel) {
 359         WMWidgetScreen(panel->win)->sharedOpenPanel = NULL;
 360     }
 361     WMRemoveNotificationObserver(panel);
 362     WMUnmapWidget(panel->win);
 363     WMDestroyWidget(panel->win);
 364     wfree(panel);
 365 }
 366
 367
 368 int
 369 WMRunModalFilePanelForDirectory(WMFilePanel *panel, WMWindow *owner,
 370                                 char *path, char *name, char **fileTypes)
 371 {
 372     WMScreen *scr = WMWidgetScreen(panel->win);
 373     XEvent event;
 374
 375     if (name && !owner) {
 376         WMSetWindowTitle(panel->win, name);
 377     }
 378
 379     WMChangePanelOwner(panel->win, owner);
 380
 381     WMSetFilePanelDirectory(panel, path);
 382
 383     switch(panel->flags.panelType) {
 384     case WP_OPEN:
 385         if (fileTypes)
 386             panel->flags.filtered = 1;
 387         panel->fileTypes = fileTypes;
 388         if (name == NULL)
 389             name = "Open";
 390         break;
 391     case WP_SAVE:
 392         panel->fileTypes = NULL;
 393         panel->flags.filtered = 0;
 394         if (name == NULL)
 395             name = "Save";
 396         break;
 397     default:
 398         break;
 399     }
 400
 401     WMSetLabelText(panel->titleLabel, name);
 402
 403     WMMapWidget(panel->win);
 404
 405     WMRunModalLoop(scr, W_VIEW(panel->win));
 406
 407     /* Must withdraw window because the next time we map
 408      * it, it might have a different transient owner.
 409      */
 410     WMCloseWindow(panel->win);
 411
 412     return (panel->flags.canceled ? False : True);
 413 }
 414
 415
 416
 417
 418 void
 419 WMSetFilePanelDirectory(WMFilePanel *panel, char *path)
 420 {
 421     WMList *list;
 422     WMListItem *item;
 423     int col;
 424     char *rest;
 425
 426     rest = WMSetBrowserPath(panel->browser, path);
 427     if (strcmp(path, "/")==0)
 428         rest = NULL;
 429
 430     col = WMGetBrowserSelectedColumn(panel->browser);
 431     list = WMGetBrowserListInColumn(panel->browser, col);
 432     if (list && (item = WMGetListSelectedItem(list))) {
 433         if (item->isBranch) {
 434             WMSetTextFieldText(panel->fileField, rest);
 435         } else {
 436             WMSetTextFieldText(panel->fileField, item->text);
 437         }
 438     } else {
 439         WMSetTextFieldText(panel->fileField, rest);
 440     }
 441 }
 442
 443
 444 void
 445 WMSetFilePanelCanChooseDirectories(WMFilePanel *panel, Bool flag)
 446 {
 447     panel->flags.canChooseDirectories = flag;
 448 }
 449
 450 void
 451 WMSetFilePanelCanChooseFiles(WMFilePanel *panel, Bool flag)
 452 {
 453     panel->flags.canChooseFiles = flag;
 454 }
 455
 456
 457 void
 458 WMSetFilePanelAutoCompletion(WMFilePanel *panel, Bool flag)
 459 {
 460     panel->flags.autoCompletion = flag;
 461 }
 462
 463
 464 char*
 465 WMGetFilePanelFileName(WMFilePanel *panel)
 466 {
 467     return getCurrentFileName(panel);
 468 }
 469
 470
 471 void
 472 WMSetFilePanelAccessoryView(WMFilePanel *panel, WMView *view)
 473 {
 474     WMView *v;
 475
 476     panel->accessoryView = view;
 477
 478     v = WMWidgetView(panel->win);
 479
 480     W_ReparentView(view, v, 0, 0);
 481
 482     W_MoveView(view, (v->size.width - v->size.width)/2, 300);
 483 }
 484
 485
 486 WMView*
 487 WMGetFilePanelAccessoryView(WMFilePanel *panel)
 488 {
 489     return panel->accessoryView;
 490 }
 491
 492
 493 static char*
 494 get_name_from_path(char *path)
 495 {
 496     int size;
 497
 498     assert(path!=NULL);
 499
 500     size = strlen(path);
 501
 502     /* remove trailing / */
 503     while (size > 0 && path[size-1]=='/')
 504         size--;
 505     /* directory was root */
 506     if (size == 0)
 507         return wstrdup("/");
 508
 509     while (size > 0 && path[size-1] != '/')
 510         size--;
 511
 512     return wstrdup(&(path[size]));
 513 }
 514
 515
 516 static int
 517 filterFileName(WMFilePanel *panel, char *file, Bool isDirectory)
 518 {
 519     return True;
 520 }
 521
 522
 523 #define CAST(item) (*((WMListItem**)item))
 524 static int
 525 comparer(const void *a, const void *b)
 526 {
 527     if (CAST(a)->isBranch == CAST(b)->isBranch)
 528       return (strcmp(CAST(a)->text, CAST(b)->text));
 529     if (CAST(a)->isBranch)
 530       return (-1);
 531     return (1);
 532 }
 533 #undef CAST
 534
 535
 536 static void
 537 listDirectoryOnColumn(WMFilePanel *panel, int column, char *path)
 538 {
 539     WMBrowser *bPtr = panel->browser;
 540     struct dirent *dentry;
 541     DIR *dir;
 542     struct stat stat_buf;
 543     char pbuf[PATH_MAX+16];
 544
 545     assert(column >= 0);
 546     assert(path != NULL);
 547
 548     /* put directory name in the title */
 549     WMSetBrowserColumnTitle(bPtr, column, get_name_from_path(path));
 550
 551     dir = opendir(path);
 552
 553     if (!dir) {
 554 #ifdef VERBOSE
 555         printf("WINGs: could not open directory %s\n", path);
 556 #endif
 557         return;
 558     }
 559
 560     /* list contents in the column */
 561     while ((dentry = readdir(dir))) {
 562         if (strcmp(dentry->d_name, ".")==0 ||
 563             strcmp(dentry->d_name, "..")==0)
 564             continue;
 565
 566         strcpy(pbuf, path);
 567         if (strcmp(path, "/")!=0)
 568             strcat(pbuf, "/");
 569         strcat(pbuf, dentry->d_name);
 570
 571         if (stat(pbuf, &stat_buf)!=0) {
 572 #ifdef VERBOSE
 573             printf("WINGs: could not stat %s\n", pbuf);
 574 #endif
 575             continue;
 576         } else {
 577             int isDirectory;
 578
 579             isDirectory = S_ISDIR(stat_buf.st_mode);
 580
 581             if (filterFileName(panel, dentry->d_name, isDirectory))
 582                 WMInsertBrowserItem(bPtr, column, -1, dentry->d_name, isDirectory);
 583         }
 584     }
 585     WMSortBrowserColumnWithComparer(bPtr, column, comparer);
 586
 587     closedir(dir);
 588 }
 589
 590
 591 static void
 592 fillColumn(WMBrowserDelegate *self, WMBrowser *bPtr, int column, WMList *list)
 593 {
 594     char *path;
 595     WMFilePanel *panel;
 596
 597     if (column > 0) {
 598         path = WMGetBrowserPathToColumn(bPtr, column-1);
 599     } else {
 600         path = wstrdup("/");
 601     }
 602
 603     panel = WMGetHangedData(bPtr);
 604     listDirectoryOnColumn(panel, column, path);
 605     wfree(path);
 606 }
 607
 608
 609 static void
 610 browserDClick(WMBrowser *bPtr, WMFilePanel *panel)
 611 {
 612     WMPerformButtonClick(panel->okButton);
 613 }
 614
 615 static void
 616 browserClick(WMBrowser *bPtr, WMFilePanel *panel)
 617 {
 618     int col = WMGetBrowserSelectedColumn(bPtr);
 619     WMListItem *item = WMGetBrowserSelectedItemInColumn(bPtr, col);
 620
 621     if (!item || item->isBranch)
 622         WMSetTextFieldText(panel->fileField, NULL);
 623     else {
 624         WMSetTextFieldText(panel->fileField, item->text);
 625     }
 626 }
 627
 628
 629 static void
 630 showError(WMScreen *scr, WMWindow *owner, char *s, char *file)
 631 {
 632     char *errStr;
 633
 634     if (file) {
 635         errStr = wmalloc(strlen(file)+strlen(s));
 636         sprintf(errStr, s, file);
 637     } else {
 638         errStr = wstrdup(s);
 639     }
 640     WMRunAlertPanel(scr, owner, "Error", errStr, "OK", NULL, NULL);
 641     wfree(errStr);
 642 }
 643
 644
 645 static void
 646 createDir(WMButton *bPre, WMFilePanel *panel)
 647 {
 648     char *dirName, *directory, *file, *s;
 649     WMScreen *scr = WMWidgetScreen(panel->win);
 650
 651     dirName = WMRunInputPanel(scr, panel->win, "Create Directory",
 652                               "Enter directory name", "", "OK", "Cancel");
 653     if (!dirName)
 654         return;
 655
 656     directory = getCurrentFileName(panel);
 657     s = strrchr(directory,'/');
 658     if (s) s[1] = 0;
 659
 660     if (dirName[0] == '/') {
 661         directory[0] = 0;
 662     } else {
 663         while ((s = strstr(directory,"//"))) {
 664             int i;
 665             for (i = 2;s[i] == '/';i++);
 666             strcpy(s, &s[i-1]);
 667         }
 668         if ((s = strrchr(directory, '/')) && !s[1]) s[0] = 0;
 669     }
 670     while ((s = strstr(dirName,"//"))) {
 671         int i;
 672         for (i = 2;s[i] == '/';i++);
 673         strcpy(s, &s[i-1]);
 674     }
 675     if ((s = strrchr(dirName, '/')) && !s[1]) s[0] = 0;
 676
 677     file = wmalloc(strlen(dirName)+strlen(directory)+1);
 678     sprintf(file, "%s/%s", directory, dirName);
 679     while ((s = strstr(file,"//"))) {
 680         int i;
 681         for (i = 2;s[i] == '/';i++);
 682         strcpy(s, &s[i-1]);
 683     }
 684
 685     if (mkdir(file,0xfff) != 0) {
 686         switch (errno) {
 687             case EACCES:
 688                 showError(scr, panel->win, "Permission denied.", NULL);
 689                 break;
 690             case EEXIST:
 691                 showError(scr, panel->win, "'%s' already existes.", file);
 692                 break;
 693             case ENOENT:
 694                 showError(scr, panel->win, "Path does not exist.", NULL);
 695         }
 696     }
 697     else WMSetFilePanelDirectory(panel, file);
 698
 699     wfree(dirName);
 700     wfree(directory);
 701     wfree(file);
 702 }
 703
 704 static void
 705 deleteFile(WMButton *bPre, WMFilePanel *panel)
 706 {
 707     char *file;
 708     char *buffer, *s;
 709     struct stat filestat;
 710     WMScreen *scr = WMWidgetScreen(panel->win);
 711
 712     file = getCurrentFileName(panel);
 713
 714     while ((s = strstr(file,"//"))) {
 715         int i;
 716         for (i = 2;s[i] == '/';i++);
 717         strcpy(s, &s[i-1]);
 718     }
 719     if (strlen(file) > 1 && (s = strrchr(file, '/')) && !s[1]) s[0] = 0;
 720
 721     if (stat(file,&filestat)) {
 722         switch (errno) {
 723             case ENOENT:
 724                 showError(scr, panel->win, "'%s' does not exist.", file);
 725                 break;
 726             case EACCES:
 727                 showError(scr, panel->win, "Permission denied.", NULL);
 728                 break;
 729             case ENOMEM:
 730                 showError(scr, panel->win,
 731                         "Insufficient memory available.", NULL);
 732                 break;
 733             case EROFS:
 734                 showError(scr, panel->win,
 735                         "'%s' is on a read-only filesystem.", file);
 736                 break;
 737             default:
 738                 showError(scr, panel->win, "Can not delete '%s'.", file);
 739         }
 740         wfree(file);
 741         return;
 742     } else if (S_ISDIR(filestat.st_mode)) {
 743         buffer = wmalloc(strlen(file)+20);
 744         sprintf(buffer,"Delete directory %s ?",file);
 745     } else {
 746         buffer = wmalloc(strlen(file)+15);
 747         sprintf(buffer,"Delete file %s ?",file);
 748     }
 749
 750     if (!WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
 751                 "Warning", buffer, "OK", "Cancel", NULL)) {
 752         if (S_ISDIR(filestat.st_mode)) {
 753             if (rmdir(file) != 0) {
 754                 switch (errno) {
 755                     case EACCES:
 756                         showError(scr, panel->win, "Permission denied.", NULL);
 757                         break;
 758                     case ENOENT:
 759                         showError(scr, panel->win, "Directory '%s' does not exist.", file);
 760                         break;
 761                     case ENOTEMPTY:
 762                         showError(scr, panel->win, "Directory '%s' is not empty.", file);
 763                         break;
 764                     case EBUSY:
 765                         showError(scr, panel->win, "Directory '%s' is busy.", file);
 766                         break;
 767                     default:
 768                         showError(scr, panel->win, "Can not delete '%s'.", file);
 769                 }
 770             } else {
 771                 char *s = strrchr(file,'/');
 772                 if (s) s[0] = 0;
 773                 WMSetFilePanelDirectory(panel, file);
 774             }
 775         } else if (remove(file) != 0) {
 776             switch (errno) {
 777                 case EISDIR:
 778                     showError(scr, panel->win, "'%s' is a directory.", file);
 779                     break;
 780                 case ENOENT:
 781                     showError(scr, panel->win, "'%s' does not exist.", file);
 782                     break;
 783                 case EACCES:
 784                     showError(scr, panel->win, "Permission denied.", NULL);
 785                     break;
 786                 case ENOMEM:
 787                     showError(scr, panel->win,
 788                             "Insufficient memory available.", NULL);
 789                     break;
 790                 case EROFS:
 791                     showError(scr, panel->win,
 792                             "'%s' is on a read-only filesystem.", file);
 793                     break;
 794                 default:
 795                     showError(scr, panel->win, "Can not delete '%s'.", file);
 796             }
 797         } else {
 798             char *s = strrchr(file,'/');
 799             if (s) s[1] = 0;
 800             WMSetFilePanelDirectory(panel, file);
 801         }
 802     }
 803     wfree(buffer);
 804     wfree(file);
 805 }
 806
 807 static void
 808 goUnmount(WMButton *bPtr, WMFilePanel *panel)
 809 {
 810 }
 811
 812
 813 static void
 814 goFloppy(WMButton *bPtr, WMFilePanel *panel)
 815 {
 816     struct stat filestat;
 817     WMScreen *scr = WMWidgetScreen(panel->win);
 818
 819     if (stat(WINGsConfiguration.floppyPath, &filestat)) {
 820         showError(scr, panel->win, "An error occured browsing '%s'.",
 821                   WINGsConfiguration.floppyPath);
 822         return;
 823     } else if (!S_ISDIR(filestat.st_mode)) {
 824         showError(scr, panel->win, "'%s' is not a directory.",
 825                   WINGsConfiguration.floppyPath);
 826         return;
 827     }
 828
 829     WMSetFilePanelDirectory(panel, WINGsConfiguration.floppyPath);
 830 }
 831
 832
 833 static void
 834 goHome(WMButton *bPtr, WMFilePanel *panel)
 835 {
 836     char *home;
 837
 838     /* home is statically allocated. Don't free it! */
 839     home = wgethomedir();
 840     if (!home)
 841         return;
 842
 843     WMSetFilePanelDirectory(panel, home);
 844 }
 845
 846
 847 static void
 848 handleEvents(XEvent *event, void *data)
 849 {
 850     W_FilePanel *pPtr = (W_FilePanel*)data;
 851     W_View *view = WMWidgetView(pPtr->win);
 852
 853     if (event->type == ConfigureNotify) {
 854         if (event->xconfigure.width != view->size.width
 855             || event->xconfigure.height != view->size.height) {
 856             unsigned int newWidth = event->xconfigure.width;
 857             unsigned int newHeight = event->xconfigure.height;
 858             int newColumnCount;
 859
 860             W_ResizeView(view, newWidth, newHeight);
 861             WMResizeWidget(pPtr->line, newWidth, 2);
 862             WMResizeWidget(pPtr->browser, newWidth-14,
 863                            newHeight-(PHEIGHT-200));
 864             WMResizeWidget(pPtr->fileField, newWidth-60-10, 24);
 865             WMMoveWidget(pPtr->nameLabel, 7, newHeight-(PHEIGHT-282));
 866             WMMoveWidget(pPtr->fileField, 60, newHeight-(PHEIGHT-278));
 867             WMMoveWidget(pPtr->okButton, newWidth-(PWIDTH-245),
 868                     newHeight-(PHEIGHT-325));
 869             WMMoveWidget(pPtr->cancelButton, newWidth-(PWIDTH-165),
 870                     newHeight-(PHEIGHT-325));
 871
 872             WMMoveWidget(pPtr->trashcanButton, 7, newHeight-(PHEIGHT-325));
 873             WMMoveWidget(pPtr->createDirButton, 37, newHeight-(PHEIGHT-325));
 874             WMMoveWidget(pPtr->homeButton, 67, newHeight-(PHEIGHT-325));
 875             WMMoveWidget(pPtr->disketteButton, 97, newHeight-(PHEIGHT-325));
 876             WMMoveWidget(pPtr->unmountButton, 127, newHeight-(PHEIGHT-325));
 877
 878             newColumnCount = (newWidth - 14) / 140;
 879             WMSetBrowserMaxVisibleColumns(pPtr->browser, newColumnCount);
 880         }
 881     }
 882 }
 883
 884
 885 static char*
 886 getCurrentFileName(WMFilePanel *panel)
 887 {
 888     char *path;
 889     char *file;
 890     char *tmp;
 891     int len;
 892
 893     path = WMGetBrowserPath(panel->browser);
 894
 895     len = strlen(path);
 896     if (path[len-1]=='/') {
 897         file = WMGetTextFieldText(panel->fileField);
 898         tmp = wmalloc(strlen(path)+strlen(file)+8);
 899         if (file[0]!='/') {
 900            strcpy(tmp, path);
 901            strcat(tmp, file);
 902         } else
 903            strcpy(tmp, file);
 904
 905         wfree(file);
 906         wfree(path);
 907         return tmp;
 908     } else {
 909         return path;
 910     }
 911 }
 912
 913
 914
 915 static Bool
 916 validOpenFile(WMFilePanel *panel)
 917 {
 918     WMListItem *item;
 919     int col, haveFile = 0;
 920     char *file = WMGetTextFieldText(panel->fileField);
 921
 922     if (file[0] != '\0')
 923         haveFile = 1;
 924     wfree(file);
 925
 926     col = WMGetBrowserSelectedColumn(panel->browser);
 927     item = WMGetBrowserSelectedItemInColumn(panel->browser, col);
 928     if (item) {
 929         if (item->isBranch && !panel->flags.canChooseDirectories && !haveFile)
 930             return False;
 931         else if (!item->isBranch && !panel->flags.canChooseFiles)
 932             return False;
 933         else
 934             return True;
 935     } else {
 936         /* we compute for / here */
 937         if (!panel->flags.canChooseDirectories && !haveFile)
 938             return False;
 939         else
 940             return True;
 941     }
 942     return True;
 943 }
 944
 945
 946
 947 static void
 948 buttonClick(WMButton *bPtr, WMFilePanel *panel)
 949 {
 950     WMRange range;
 951
 952     if (bPtr == panel->okButton) {
 953         if (!validOpenFile(panel))
 954             return;
 955         if (panel->flags.fileMustExist) {
 956             char *file;
 957
 958             file = getCurrentFileName(panel);
 959             if (access(file, F_OK)!=0) {
 960                 WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
 961                                 "Error", "File does not exist.",
 962                                 "Ok", NULL, NULL);
 963                 wfree(file);
 964                 return;
 965             }
 966             wfree(file);
 967         }
 968         panel->flags.canceled = 0;
 969     } else
 970         panel->flags.canceled = 1;
 971
 972     range.count = range.position = 0;
 973     WMSelectTextFieldRange(panel->fileField, range);
 974     WMBreakModalLoop(WMWidgetScreen(bPtr));
 975 }
 976
 977