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