WINGs/wfilepanel.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <unistd.h>
  10 #include <dirent.h>
  11 #include <limits.h>
  12
  13 #ifndef PATH_MAX
  14 #define PATH_MAX 1024
  15 #endif
  16
  17 typedef struct W_FilePanel {
  18     WMWindow *win;
  19
  20     WMLabel *iconLabel;
  21     WMLabel *titleLabel;
  22
  23     WMFrame *line;
  24
  25     WMLabel *nameLabel;
  26     WMBrowser *browser;
  27
  28     WMButton *okButton;
  29     WMButton *cancelButton;
  30
  31     WMButton *homeButton;
  32
  33     WMView *accessoryView;
  34
  35     WMTextField *fileField;
  36
  37     char **fileTypes;
  38
  39     struct {
  40         unsigned int canExit:1;
  41         unsigned int canceled:1;       /* clicked on cancel */
  42         unsigned int done:1;
  43         unsigned int filtered:1;
  44         unsigned int canChooseFiles:1;
  45         unsigned int canChooseDirectories:1;
  46         unsigned int autoCompletion:1;
  47         unsigned int showAllFiles:1;
  48         unsigned int canFreeFileTypes:1;
  49         unsigned int fileMustExist:1;
  50     } flags;
  51 } W_FilePanel;
  52
  53
  54 #define PWIDTH          320
  55 #define PHEIGHT         360
  56
  57 static void listDirectoryOnColumn(WMFilePanel *panel, int column, char *path);
  58 static void browserClick();
  59
  60 static void fillColumn(WMBrowser *bPtr, int column);
  61
  62 static void goHome();
  63
  64 static void buttonClick();
  65
  66 static char *getCurrentFileName(WMFilePanel *panel);
  67
  68
  69
  70 static int
  71 closestListItem(WMList *list, char *text, Bool exact)
  72 {
  73     WMListItem *item = WMGetListItem(list, 0);
  74     int i = 0;
  75     int len = strlen(text);
  76
  77     if (len==0)
  78         return -1;
  79
  80     while (item) {
  81         if (strlen(item->text) >= len &&
  82             ((exact && strcmp(item->text, text)==0) ||
  83              (!exact && strncmp(item->text, text, len)==0))) {
  84             return i;
  85         }
  86         item = item->nextPtr;
  87         i++;
  88     }
  89     return -1;
  90 }
  91
  92
  93 static void
  94 textChangedObserver(void *observerData, WMNotification *notification)
  95 {
  96     W_FilePanel *panel = (W_FilePanel*)observerData;
  97     char *text, *text1;
  98     WMList *list;
  99     int col = WMGetBrowserNumberOfColumns(panel->browser) - 1;
 100     int i, j, textEvent = (int)WMGetNotificationClientData(notification);
 101
 102     list = WMGetBrowserListInColumn(panel->browser, col);
 103     if (!list)
 104         return;
 105     text = WMGetTextFieldText(panel->fileField);
 106
 107     if (panel->flags.autoCompletion && textEvent!=WMDeleteTextEvent)
 108         i = closestListItem(list, text, False);
 109     else
 110         i = closestListItem(list, text, True);
 111
 112     WMSelectListItem(list, i);
 113     if (i>=0) {
 114         WMListItem *item = WMGetListItem(list, i);
 115         int textLen = strlen(text), itemTextLen = strlen(item->text);
 116
 117         WMSetListPosition(list, i);
 118
 119         if (panel->flags.autoCompletion) {
 120             /* Be careful with the '<' condition below. Changing it can drop
 121              * you into an endless loop. We call here, inside a function
 122              * called from a notification observer, to a function that
 123              * generates notification events. So make sure we do not call it
 124              * recursively for ever.
 125              * '<' means we only update text field if it is really not yet
 126              * complete. -Dan
 127              */
 128             if (textLen < itemTextLen && textEvent!=WMDeleteTextEvent) {
 129                 WMRange range;
 130
 131                 WMInsertTextFieldText(panel->fileField, &item->text[textLen],
 132                                       textLen);
 133                 WMSetTextFieldCursorPosition(panel->fileField, itemTextLen);
 134                 range.position = textLen;
 135                 range.count = itemTextLen - textLen;
 136                 WMSelectTextFieldRange(panel->fileField, range);
 137             }
 138
 139             text1 = WMGetTextFieldText(panel->fileField);
 140             j = closestListItem(list, text1, True);
 141             if (i != j) {
 142                 WMSelectListItem(list, j);
 143                 if (j>=0) {
 144                     WMSetListPosition(list, j);
 145                 }
 146             }
 147             free(text1);
 148         }
 149     }
 150
 151     free(text);
 152 }
 153
 154
 155 static void
 156 textEditedObserver(void *observerData, WMNotification *notification)
 157 {
 158     W_FilePanel *panel = (W_FilePanel*)observerData;
 159
 160     if ((int)WMGetNotificationClientData(notification)==WMReturnTextMovement) {
 161         WMPerformButtonClick(panel->okButton);
 162     }
 163 }
 164
 165
 166
 167 static WMFilePanel*
 168 makeFilePanel(WMScreen *scrPtr, char *name, char *title)
 169 {
 170     WMFilePanel *fPtr;
 171     WMFont *largeFont;
 172
 173     fPtr = wmalloc(sizeof(WMFilePanel));
 174     memset(fPtr, 0, sizeof(WMFilePanel));
 175
 176     fPtr->win = WMCreateWindowWithStyle(scrPtr, name, WMTitledWindowMask
 177                                         |WMResizableWindowMask);
 178     WMResizeWidget(fPtr->win, PWIDTH, PHEIGHT);
 179     WMSetWindowTitle(fPtr->win, "");
 180
 181     fPtr->iconLabel = WMCreateLabel(fPtr->win);
 182     WMResizeWidget(fPtr->iconLabel, 64, 64);
 183     WMMoveWidget(fPtr->iconLabel, 0, 0);
 184     WMSetLabelImagePosition(fPtr->iconLabel, WIPImageOnly);
 185     WMSetLabelImage(fPtr->iconLabel, scrPtr->applicationIcon);
 186
 187     fPtr->titleLabel = WMCreateLabel(fPtr->win);
 188     WMResizeWidget(fPtr->titleLabel, PWIDTH-64, 64);
 189     WMMoveWidget(fPtr->titleLabel, 64, 0);
 190     largeFont = WMBoldSystemFontOfSize(scrPtr, 24);
 191     WMSetLabelFont(fPtr->titleLabel, largeFont);
 192     WMReleaseFont(largeFont);
 193     WMSetLabelText(fPtr->titleLabel, title);
 194
 195     fPtr->line = WMCreateFrame(fPtr->win);
 196     WMMoveWidget(fPtr->line, 0, 64);
 197     WMResizeWidget(fPtr->line, PWIDTH, 2);
 198     WMSetFrameRelief(fPtr->line, WRGroove);
 199
 200     fPtr->browser = WMCreateBrowser(fPtr->win);
 201     WMSetBrowserFillColumnProc(fPtr->browser, fillColumn);
 202     WMSetBrowserAction(fPtr->browser, browserClick, fPtr);
 203     WMMoveWidget(fPtr->browser, 7, 72);
 204     WMHangData(fPtr->browser, fPtr);
 205
 206     fPtr->nameLabel = WMCreateLabel(fPtr->win);
 207     WMMoveWidget(fPtr->nameLabel, 7, 282);
 208     WMResizeWidget(fPtr->nameLabel, 55, 14);
 209     WMSetLabelText(fPtr->nameLabel, "Name:");
 210
 211     fPtr->fileField = WMCreateTextField(fPtr->win);
 212     WMMoveWidget(fPtr->fileField, 60, 278);
 213     WMResizeWidget(fPtr->fileField, PWIDTH-60-10, 24);
 214     WMAddNotificationObserver(textEditedObserver, fPtr,
 215                               WMTextDidEndEditingNotification,
 216                               fPtr->fileField);
 217     WMAddNotificationObserver(textChangedObserver, fPtr,
 218                               WMTextDidChangeNotification,
 219                               fPtr->fileField);
 220
 221     fPtr->okButton = WMCreateCommandButton(fPtr->win);
 222     WMMoveWidget(fPtr->okButton, 230, 325);
 223     WMResizeWidget(fPtr->okButton, 80, 28);
 224     WMSetButtonText(fPtr->okButton, "OK");
 225     WMSetButtonImage(fPtr->okButton, scrPtr->buttonArrow);
 226     WMSetButtonAltImage(fPtr->okButton, scrPtr->pushedButtonArrow);
 227     WMSetButtonImagePosition(fPtr->okButton, WIPRight);
 228     WMSetButtonAction(fPtr->okButton, buttonClick, fPtr);
 229
 230     fPtr->cancelButton = WMCreateCommandButton(fPtr->win);
 231     WMMoveWidget(fPtr->cancelButton, 140, 325);
 232     WMResizeWidget(fPtr->cancelButton, 80, 28);
 233     WMSetButtonText(fPtr->cancelButton, "Cancel");
 234     WMSetButtonAction(fPtr->cancelButton, buttonClick, fPtr);
 235
 236     fPtr->homeButton = WMCreateCommandButton(fPtr->win);
 237     WMMoveWidget(fPtr->homeButton, 55, 325);
 238     WMResizeWidget(fPtr->homeButton, 28, 28);
 239     WMSetButtonImagePosition(fPtr->homeButton, WIPImageOnly);
 240     WMSetButtonImage(fPtr->homeButton, scrPtr->homeIcon);
 241         WMSetButtonAltImage(fPtr->homeButton, scrPtr->homeAltIcon);
 242     WMSetButtonAction(fPtr->homeButton, goHome, fPtr);
 243
 244     WMRealizeWidget(fPtr->win);
 245     WMMapSubwidgets(fPtr->win);
 246
 247     WMLoadBrowserColumnZero(fPtr->browser);
 248
 249     fPtr->flags.canChooseFiles = 1;
 250     fPtr->flags.canChooseDirectories = 1;
 251     fPtr->flags.autoCompletion = 1;
 252
 253     return fPtr;
 254 }
 255
 256
 257 WMOpenPanel*
 258 WMGetOpenPanel(WMScreen *scrPtr)
 259 {
 260     WMFilePanel *panel;
 261
 262     if (scrPtr->sharedOpenPanel)
 263         return scrPtr->sharedOpenPanel;
 264
 265     panel = makeFilePanel(scrPtr, "openFilePanel", "Open");
 266     panel->flags.fileMustExist = 1;
 267
 268     scrPtr->sharedOpenPanel = panel;
 269
 270     return panel;
 271 }
 272
 273
 274 WMSavePanel*
 275 WMGetSavePanel(WMScreen *scrPtr)
 276 {
 277     WMFilePanel *panel;
 278
 279     if (scrPtr->sharedSavePanel)
 280         return scrPtr->sharedSavePanel;
 281
 282     panel = makeFilePanel(scrPtr, "saveFilePanel", "Save");
 283     panel->flags.fileMustExist = 0;
 284
 285     scrPtr->sharedSavePanel = panel;
 286
 287     return panel;
 288 }
 289
 290
 291 void
 292 WMFreeFilePanel(WMFilePanel *panel)
 293 {
 294     if (panel == WMWidgetScreen(panel->win)->sharedSavePanel) {
 295         WMWidgetScreen(panel->win)->sharedSavePanel = NULL;
 296     }
 297     if (panel == WMWidgetScreen(panel->win)->sharedOpenPanel) {
 298         WMWidgetScreen(panel->win)->sharedOpenPanel = NULL;
 299     }
 300     WMRemoveNotificationObserver(panel);
 301     WMUnmapWidget(panel->win);
 302     WMDestroyWidget(panel->win);
 303     free(panel);
 304 }
 305
 306
 307 int
 308 WMRunModalSavePanelForDirectory(WMFilePanel *panel, WMWindow *owner,
 309                                 char *path, char *name)
 310 {
 311     WMScreen *scr = WMWidgetScreen(panel->win);
 312     XEvent event;
 313
 314     WMChangePanelOwner(panel->win, owner);
 315
 316     WMSetFilePanelDirectory(panel, path);
 317
 318     panel->flags.done = 0;
 319     panel->fileTypes = NULL;
 320
 321     panel->flags.filtered = 0;
 322
 323     WMMapWidget(panel->win);
 324
 325     while (!panel->flags.done) {
 326         WMNextEvent(scr->display, &event);
 327         WMHandleEvent(&event);
 328     }
 329
 330     /* Must withdraw window because the next time we map
 331      * it, it might have a different transient owner.
 332      */
 333     WMCloseWindow(panel->win);
 334
 335     return (panel->flags.canceled ? False : True);
 336 }
 337
 338
 339
 340 int
 341 WMRunModalOpenPanelForDirectory(WMFilePanel *panel, WMWindow *owner,
 342                                 char *path, char *name, char **fileTypes)
 343 {
 344     WMScreen *scr = WMWidgetScreen(panel->win);
 345     XEvent event;
 346
 347     WMChangePanelOwner(panel->win, owner);
 348
 349     WMSetFilePanelDirectory(panel, path);
 350
 351     panel->flags.done = 0;
 352
 353     if (fileTypes)
 354         panel->flags.filtered = 1;
 355     panel->fileTypes = fileTypes;
 356
 357     WMMapWidget(panel->win);
 358
 359     while (!panel->flags.done) {
 360         WMNextEvent(scr->display, &event);
 361         WMHandleEvent(&event);
 362     }
 363
 364     WMCloseWindow(panel->win);
 365
 366     return (panel->flags.canceled ? False : True);
 367 }
 368
 369
 370 void
 371 WMSetFilePanelDirectory(WMFilePanel *panel, char *path)
 372 {
 373     WMList *list;
 374     WMListItem *item;
 375     int col;
 376
 377     WMSetBrowserPath(panel->browser, path);
 378     col = WMGetBrowserNumberOfColumns(panel->browser) - 1;
 379     list = WMGetBrowserListInColumn(panel->browser, col);
 380     if (list && (item = WMGetListSelectedItem(list))) {
 381         if (item->isBranch) {
 382             WMSetTextFieldText(panel->fileField, NULL);
 383         } else {
 384             WMSetTextFieldText(panel->fileField, item->text);
 385         }
 386     } else {
 387         WMSetTextFieldText(panel->fileField, path);
 388     }
 389 }
 390
 391
 392 void
 393 WMSetFilePanelCanChooseDirectories(WMFilePanel *panel, Bool flag)
 394 {
 395     panel->flags.canChooseDirectories = flag;
 396 }
 397
 398 void
 399 WMSetFilePanelCanChooseFiles(WMFilePanel *panel, Bool flag)
 400 {
 401     panel->flags.canChooseFiles = flag;
 402 }
 403
 404
 405 void
 406 WMSetFilePanelAutoCompletion(WMFilePanel *panel, Bool flag)
 407 {
 408     panel->flags.autoCompletion = flag;
 409 }
 410
 411
 412 char*
 413 WMGetFilePanelFileName(WMFilePanel *panel)
 414 {
 415     return getCurrentFileName(panel);
 416 }
 417
 418
 419 void
 420 WMSetFilePanelAccessoryView(WMFilePanel *panel, WMView *view)
 421 {
 422     WMView *v;
 423
 424     panel->accessoryView = view;
 425
 426     v = WMWidgetView(panel->win);
 427
 428     W_ReparentView(view, v);
 429
 430     W_MoveView(view, (v->size.width - v->size.width)/2, 300);
 431 }
 432
 433
 434 WMView*
 435 WMGetFilePanelAccessoryView(WMFilePanel *panel)
 436 {
 437     return panel->accessoryView;
 438 }
 439
 440
 441 static char*
 442 get_name_from_path(char *path)
 443 {
 444     int size;
 445
 446     assert(path!=NULL);
 447
 448     size = strlen(path);
 449
 450     /* remove trailing / */
 451     while (size > 0 && path[size-1]=='/')
 452         size--;
 453     /* directory was root */
 454     if (size == 0)
 455         return wstrdup("/");
 456
 457     while (size > 0 && path[size-1] != '/')
 458         size--;
 459
 460     return wstrdup(&(path[size]));
 461 }
 462
 463
 464 static int
 465 filterFileName(WMFilePanel *panel, char *file, Bool isDirectory)
 466 {
 467     return True;
 468 }
 469
 470
 471 static void
 472 listDirectoryOnColumn(WMFilePanel *panel, int column, char *path)
 473 {
 474     WMBrowser *bPtr = panel->browser;
 475     struct dirent *dentry;
 476     DIR *dir;
 477     struct stat stat_buf;
 478     char pbuf[PATH_MAX+16];
 479
 480     assert(column >= 0);
 481     assert(path != NULL);
 482
 483     /* put directory name in the title */
 484     WMSetBrowserColumnTitle(bPtr, column, get_name_from_path(path));
 485
 486     dir = opendir(path);
 487
 488     if (!dir) {
 489 #ifdef VERBOSE
 490         printf("WINGs: could not open directory %s\n", path);
 491 #endif
 492         return;
 493     }
 494
 495     /* list contents in the column */
 496     while ((dentry = readdir(dir))) {
 497         if (strcmp(dentry->d_name, ".")==0 ||
 498             strcmp(dentry->d_name, "..")==0)
 499             continue;
 500
 501         strcpy(pbuf, path);
 502         if (strcmp(path, "/")!=0)
 503             strcat(pbuf, "/");
 504         strcat(pbuf, dentry->d_name);
 505
 506         if (stat(pbuf, &stat_buf)!=0) {
 507 #ifdef VERBOSE
 508             printf("WINGs: could not stat %s\n", pbuf);
 509 #endif
 510             continue;
 511         } else {
 512             int isDirectory;
 513
 514             isDirectory = S_ISDIR(stat_buf.st_mode);
 515
 516             if (filterFileName(panel, dentry->d_name, isDirectory))
 517                 WMAddSortedBrowserItem(bPtr, column, dentry->d_name,
 518                                           isDirectory);
 519         }
 520     }
 521
 522     closedir(dir);
 523 }
 524
 525
 526 static void
 527 fillColumn(WMBrowser *bPtr, int column)
 528 {
 529     char *path;
 530     WMFilePanel *panel;
 531
 532     if (column > 0) {
 533         path = WMGetBrowserPathToColumn(bPtr, column-1);
 534     } else {
 535         path = wstrdup("/");
 536     }
 537
 538     panel = WMGetHangedData(bPtr);
 539     listDirectoryOnColumn(panel, column, path);
 540     free(path);
 541 }
 542
 543
 544
 545 static void
 546 browserClick(WMBrowser *bPtr, WMFilePanel *panel)
 547 {
 548     int col = WMGetBrowserSelectedColumn(bPtr);
 549     WMListItem *item = WMGetBrowserSelectedItemInColumn(bPtr, col);
 550
 551     if (!item || item->isBranch)
 552         WMSetTextFieldText(panel->fileField, NULL);
 553     else {
 554         WMSetTextFieldText(panel->fileField, item->text);
 555     }
 556 }
 557
 558
 559 static void
 560 goHome(WMButton *bPtr, WMFilePanel *panel)
 561 {
 562     char *home;
 563
 564     /* home is statically allocated. Don't free it! */
 565     home = wgethomedir();
 566     if (!home)
 567         return;
 568
 569     WMSetFilePanelDirectory(panel, home);
 570 }
 571
 572
 573 static char*
 574 getCurrentFileName(WMFilePanel *panel)
 575 {
 576     char *path;
 577     char *file;
 578     char *tmp;
 579     int len;
 580
 581     path = WMGetBrowserPath(panel->browser);
 582
 583     len = strlen(path);
 584     if (path[len-1]=='/') {
 585         file = WMGetTextFieldText(panel->fileField);
 586         tmp = wmalloc(strlen(path)+strlen(file)+8);
 587         if (file[0]!='/') {
 588            strcpy(tmp, path);
 589            strcat(tmp, file);
 590         } else
 591            strcpy(tmp, file);
 592
 593         free(file);
 594         free(path);
 595         return tmp;
 596     } else {
 597         return path;
 598     }
 599 }
 600
 601
 602
 603 static Bool
 604 validOpenFile(WMFilePanel *panel)
 605 {
 606     WMListItem *item;
 607     int col;
 608
 609     /*col = WMGetBrowserSelectedColumn(panel->browser);*/
 610     col = WMGetBrowserNumberOfColumns(panel->browser) - 1;
 611     item = WMGetBrowserSelectedItemInColumn(panel->browser, col);
 612     if (item) {
 613         if (item->isBranch && !panel->flags.canChooseDirectories)
 614             return False;
 615         else if (!item->isBranch && !panel->flags.canChooseFiles)
 616             return False;
 617         else
 618             return True;
 619     }
 620     if (!panel->flags.canChooseDirectories)
 621         return False;
 622     else
 623         return True;
 624 }
 625
 626
 627
 628 static void
 629 buttonClick(WMButton *bPtr, WMFilePanel *panel)
 630 {
 631     if (bPtr == panel->okButton) {
 632         if (panel->flags.fileMustExist) {
 633             char *file;
 634             if (!validOpenFile(panel))
 635                 return;
 636
 637             file = getCurrentFileName(panel);
 638             if (access(file, F_OK)!=0) {
 639                 WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
 640                                 "Error", "File does not exist.",
 641                                 "Ok", NULL, NULL);
 642                 free(file);
 643                 return;
 644             }
 645             free(file);
 646         }
 647         panel->flags.canceled = 0;
 648     } else
 649         panel->flags.canceled = 1;
 650
 651     panel->flags.done = 1;
 652 }
 653
 654