WINGs/wfilepanel.c

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