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