WINGs/wfilepanel.c

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