src/FSFileBrowser.c

   1 #include <WMaker.h>
   2 #include <WINGs/WINGs.h>
   3 #include <WINGs/WINGsP.h>
   4 #include <sys/stat.h>
   5 #include <unistd.h>
   6
   7 #include "files.h"
   8 /* #include "FSFileButton.h" */
   9 #include "FSPathView.h"
  10 #include "filebrowser.h"
  11 #include "FSViewer.h"
  12 #include "FSBrowser.h"
  13 #include "FSUtils.h"
  14 #include "FSMCList.h"
  15 #include "DnD.h"
  16
  17 #define LIST_WIDTH              170
  18 #define COLUMN_SPACING          4
  19 #define TITLE_SPACING           2
  20
  21 #define DEFAULT_WIDTH           510
  22 #define DEFAULT_HEIGHT          390
  23
  24 #define PV_HEIGHT               110
  25 #define PVICON_WIDTH            169
  26 #define PADY                    9
  27
  28 #define DEFAULT_SEPARATOR       "/"
  29
  30 #define BROWSE                  0
  31 #define ICON                    1
  32 #define LIST                    2
  33
  34 typedef struct W_FileBrowser {
  35     W_Class       widgetClass;
  36     WMView       *view;
  37
  38     WMView       *viewport;
  39
  40     WMFrame      *displayFrame;
  41
  42     int           columnCount;
  43     int           selectedCol;
  44
  45     int           maxVisibleColumns;
  46     int           firstVisibleColumn;
  47
  48     short         lineScroll;
  49     short         pageScroll;
  50
  51     int           columnWidth;
  52
  53     void         *clientData;
  54     WMAction     *action;
  55     void         *doubleClientData;
  56     WMAction     *doubleAction;
  57
  58     FSPathView   *pathView;
  59     WMFrame      *pathViewF;
  60
  61     char         *filter;
  62     FSBrowser    *browser;
  63     WMView       *icon;
  64     WMFrame      *listF;
  65     FSMCList     *list;
  66
  67     char         *text;
  68
  69     int           currentMode;
  70
  71     struct {
  72         unsigned int isTitled:1;
  73         unsigned int allowMultipleSelection:1;
  74
  75         unsigned int loaded:1;
  76         unsigned int loadingColumn:1;
  77     } flags;
  78 } _FileBrowser;
  79
  80 static void handleEvents(XEvent *event, void *data);
  81 static void destroyFileBrowser(FileBrowser *bPtr);
  82 static void setupPathView(FileBrowser *bPtr, int x, int y,
  83                              int width, int height);
  84 static void setupBrowserMode(FileBrowser *bPtr, int x, int y,
  85                              int width, int height);
  86 static void setupListMode(FileBrowser *bPtr, int x, int y,
  87                              int width, int height);
  88 static void setupIconMode(FileBrowser *bPtr);
  89 /* static void resizeFileBrowser(WMWidget*, unsigned int, unsigned int); */
  90 static void resizePathView(FileBrowser *bPtr, unsigned int, unsigned int);
  91 static void scrollPathView(FileBrowser *bPtr, int col);
  92 static void scrolledBrowser(void *observerData, WMNotification *notification);
  93 static void scrolledPathView(void *observerData, WMNotification *notification);
  94 static void scrollCallback(WMWidget *self, void *clientData);
  95 /* static void fillPathView(FileBrowser *bPtr, int column); */
  96 static void handleDoubleActions(WMWidget *self, void *data);
  97 static void handleItemSelection(WMWidget *self, void *clientData);
  98 static int  FSGetFileBrowserFirstVisibleColumn(FileBrowser *bPtr);
  99 static int  FSGetFileBrowserColumnCount(FileBrowser *bPtr);
 100 static FileInfo *FSGetFileBrowserFileInfoAt(FileBrowser *bPtr, int col);
 101 static void insertIntoColumn(FileBrowser *bPtr, char *pathname);
 102 static void removeFromColumn(FileBrowser *bPtr, char *path, char *name);
 103 static int  findColumnFromPath(char *path);
 104 static void notificationObserver(void *self, WMNotification *notif);
 105 static void removeFromView(FileBrowser *bPtr, char *path, char *name);
 106 static void insertIntoView(FileBrowser *bPtr, char *pathname);
 107
 108 static void willResizeFileBrowser(W_ViewDelegate*, WMView*,
 109                                   unsigned int*, unsigned int*);
 110
 111 /* W_ViewProcedureTable _FileBrowserViewProcedures = { */
 112 /*     NULL, */
 113 /*      resizeFileBrowser, */
 114 /*      NULL */
 115 /* }; */
 116
 117 W_ViewDelegate _FileBrowserViewDelegate = {
 118     NULL,
 119         NULL,
 120         NULL,
 121         NULL,
 122         willResizeFileBrowser
 123 };
 124
 125 // Widget class ID.
 126 static  W_Class fileBrowserWidgetClass = 0;
 127
 128 W_Class InitFileBrowser(WMScreen *scr)
 129 {
 130     // Register the widget with WINGs and get the widget class ID.
 131     if (!(fileBrowserWidgetClass))
 132     {
 133         fileBrowserWidgetClass =
 134 /*          W_RegisterUserWidget(&_FileBrowserViewProcedures); */
 135             W_RegisterUserWidget();
 136     }
 137
 138     return fileBrowserWidgetClass;
 139 }
 140
 141
 142 FileBrowser*
 143 FSCreateFileBrowser(WMWidget *parent)
 144 {
 145     FileBrowser *bPtr;
 146     int i;
 147
 148     bPtr = wmalloc(sizeof(FileBrowser));
 149     memset(bPtr, 0, sizeof(FileBrowser));
 150
 151     bPtr->widgetClass = fileBrowserWidgetClass;
 152
 153     bPtr->view = W_CreateView(W_VIEW(parent));
 154     if (!bPtr->view) {
 155         free(bPtr);
 156         return NULL;
 157     }
 158     bPtr->view->self = bPtr;
 159     bPtr->view->delegate = &_FileBrowserViewDelegate;
 160
 161     WMCreateEventHandler(bPtr->view, ExposureMask|StructureNotifyMask
 162                          |ClientMessageMask, handleEvents, bPtr);
 163
 164    /* default configuration */
 165     bPtr->lineScroll = bPtr->columnWidth;
 166     bPtr->pageScroll = 0;
 167
 168     bPtr->firstVisibleColumn = 0;
 169     bPtr->maxVisibleColumns = 3;
 170     bPtr->selectedCol = -1;
 171     bPtr->columnCount = 0;
 172     bPtr->columnWidth = PVICON_WIDTH;
 173
 174     bPtr->displayFrame = WMCreateFrame(bPtr);
 175     WMSetFrameRelief(bPtr->displayFrame, WRFlat);
 176     WMMoveWidget(bPtr->displayFrame, 0, 119);
 177     WMResizeWidget(bPtr->displayFrame, 510, 275);
 178     setupBrowserMode(bPtr, 0, 0, 510, 275);
 179     setupListMode(bPtr, 0, 0, 510, 275);
 180
 181     setupPathView(bPtr, 0, 0, DEFAULT_WIDTH, PV_HEIGHT);
 182
 183 /*     resizeFileBrowser(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT); */
 184     WMResizeWidget(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 185     WMMapWidget(bPtr->pathView);
 186     WMMapWidget(bPtr->browser);
 187 /*     WMMapWidget(bPtr->listF); */
 188     WMMapWidget(bPtr->displayFrame);
 189     bPtr->icon = NULL;
 190 /*     bPtr->currentMode = LIST; */
 191     bPtr->currentMode = BROWSE;
 192     bPtr->filter = NULL;
 193     bPtr->doubleAction = NULL;
 194     bPtr->doubleClientData = NULL;
 195
 196     return bPtr;
 197 }
 198
 199 static void
 200 willResizeFileBrowser(W_ViewDelegate *self, WMView *view,
 201                       unsigned int *width, unsigned int *height)
 202 {
 203     FileBrowser *bPtr = (FileBrowser *) view->self;
 204
 205     bPtr->maxVisibleColumns = *width/bPtr->columnWidth;
 206
 207     WMResizeWidget(bPtr->displayFrame,
 208                    *width, *height-PV_HEIGHT-PADY);
 209
 210 /*     W_ResizeView(bPtr->view, *width, *height); */
 211
 212     if(bPtr->browser)
 213     {
 214         FSSetBrowserMaxVisibleColumns(bPtr->browser, bPtr->maxVisibleColumns);
 215         WMResizeWidget(bPtr->browser,
 216                        *width, *height-PV_HEIGHT-PADY);
 217     }
 218     if(bPtr->list)
 219     {
 220         WMResizeWidget(bPtr->listF, *width, *height-PV_HEIGHT-PADY);
 221         FSResizeMCList(bPtr->list,  *width, *height-PV_HEIGHT-PADY);
 222     }
 223     FSSetPathViewMaxVisibleColumns(bPtr->pathView,
 224                                    bPtr->maxVisibleColumns);
 225     WMResizeWidget(bPtr->pathViewF, *width,   PV_HEIGHT);
 226     WMResizeWidget(bPtr->pathView,  *width-3, PV_HEIGHT-3);
 227 }
 228
 229 /* static void  */
 230 /* resizeFileBrowser(WMWidget *w, unsigned int width, unsigned int height) */
 231 /* { */
 232 /*     FileBrowser *bPtr = (FileBrowser*)w; */
 233
 234 /*     bPtr->maxVisibleColumns = width/bPtr->columnWidth; */
 235
 236 /*     WMResizeWidget(bPtr->displayFrame,  */
 237 /*                 width, height-PV_HEIGHT-PADY); */
 238
 239 /*     W_ResizeView(bPtr->view, width, height); */
 240
 241 /*     if(bPtr->browser) */
 242 /*     { */
 243 /*      FSSetBrowserMaxVisibleColumns(bPtr->browser, bPtr->maxVisibleColumns); */
 244 /*      WMResizeWidget(bPtr->browser, width, height-PV_HEIGHT-PADY); */
 245 /*     } */
 246 /*     if(bPtr->list) */
 247 /*     { */
 248 /*      WMResizeWidget(bPtr->listF, width, height-PV_HEIGHT-PADY); */
 249 /*      FSResizeMCList(bPtr->list,  width, height-PV_HEIGHT-PADY); */
 250 /*     } */
 251
 252 /*     FSSetPathViewMaxVisibleColumns(bPtr->pathView,  */
 253 /*                                 bPtr->maxVisibleColumns); */
 254 /*     WMResizeWidget(bPtr->pathViewF, width,   PV_HEIGHT); */
 255 /*     WMResizeWidget(bPtr->pathView,  width-3, PV_HEIGHT-3); */
 256 /* } */
 257
 258 static void
 259 fillBrowserColumn(FSBrowser *bPtr, int column)
 260 {
 261     char *path;
 262     FileInfo *fileList;
 263     FileInfo *start;
 264     WMListItem *listItem;
 265     FileBrowser *fB = (FileBrowser *)(WMGetHangedData(bPtr));
 266
 267     FSSetBusyCursor(bPtr, True);
 268
 269     path = FSGetBrowserPathToColumn(bPtr, column);
 270     if(path)
 271     {
 272         start = GetDirList(path);
 273         fileList = start;
 274
 275         while(fileList != NULL)
 276         {
 277             if( DisplayFile(fileList->name, fB->filter, fileList->fileType) )
 278             {
 279                 listItem = FSInsertBrowserItem(bPtr, column, -1,
 280                                                fileList->name,
 281                                                isDirectory(fileList->fileType));
 282 /*              listItem->clientData = fileList; */
 283             }
 284
 285             fileList = fileList->next;
 286         }
 287     }
 288
 289     if (path)
 290     {
 291         free(path);
 292     }
 293
 294     if(start)
 295         FSFreeFileInfo(start);
 296
 297     FSSetBusyCursor(bPtr, False);
 298 }
 299
 300 static void
 301 handleItemSelection(WMWidget *self, void *clientData)
 302 {
 303     int col;
 304     char *path;
 305     FileBrowser *bPtr = (FileBrowser *) clientData;
 306     static int lastCol = 0;
 307     WMListItem *item = NULL;
 308     FileInfo *fileInfo = NULL;
 309
 310     col = FSGetFileBrowserColumnCount(bPtr);
 311     fileInfo = FSGetFileBrowserSelectedFileInfo(bPtr);
 312     switch(bPtr->currentMode)
 313     {
 314     case BROWSE :
 315         FSSetPathViewToColumn(bPtr->pathView, col-1);
 316         /* Update Inspector if open */
 317         FSUpdateInspectorWindow(fileInfo);
 318         break;
 319     case ICON   :
 320         break;
 321     case LIST   :
 322         if(lastCol >= col && !isDirectory(fileInfo->fileType))
 323             FSSetPathViewToColumn(bPtr->pathView, col);
 324         else
 325             FSSetPathViewToColumn(bPtr->pathView, col-1);
 326         lastCol = col;
 327         /* Update Inspector if open */
 328         FSUpdateInspectorWindow(fileInfo);
 329         break;
 330     default     :
 331         break;
 332     }
 333
 334     if(bPtr->text)
 335     {
 336         wwarning("%s %d: %s", __FILE__, __LINE__, bPtr->text);
 337         free(bPtr->text);
 338         bPtr->text = NULL;
 339     }
 340 }
 341
 342 static void
 343 handlePathViewAction(WMWidget *self, void *clientData)
 344 {
 345     int col, i;
 346     FileBrowser *bPtr = (FileBrowser *) clientData;
 347     /*
 348        Will be used to help in the scolling when
 349        the icon and list views have been implemented
 350     */
 351     col = FSGetPathViewLastClicked(self);
 352     i = FSGetPathViewNumberOfColumns(self) - 1;
 353
 354 /*     if(bPtr->currentMode == BROWSE) */
 355 /*      FSScrollBrowserToColumn(bPtr->browser, col-1, False); */
 356 /*     else  */
 357     if(bPtr->currentMode == LIST && col < i)
 358         FSScrollMCListToColumn(bPtr->list, col, False);
 359 }
 360
 361 static void
 362 handleDoubleAction(WMWidget *self, void *clientData)
 363 {
 364     FileBrowser *bPtr = (FileBrowser *) clientData;
 365
 366     if (bPtr->doubleAction)
 367         (*bPtr->doubleAction)(bPtr, bPtr->doubleClientData);
 368 }
 369
 370 static void
 371 fillPV(FSPathView *pvPtr, int column)
 372 {
 373     char *path;
 374     FileBrowser *bPtr = (FileBrowser *)(WMGetHangedData(pvPtr));
 375
 376     path = FSGetFileBrowserPathToColumn(bPtr, column-1);
 377     if(path)
 378     {
 379         int backlight = FSGetIntegerForName("DisplaySVBG");
 380
 381         FSSetPathViewColumnContents(pvPtr, column, path, 1, backlight);
 382         free(path);
 383     }
 384     FSUpdateCurrentFileViewTitles();
 385 }
 386
 387 static void
 388 setupPathView(FileBrowser *bPtr, int x, int y, int width, int height)
 389 {
 390     InitFSPathView(WMWidgetScreen(bPtr));
 391
 392     bPtr->pathViewF = WMCreateFrame(bPtr);
 393     WMResizeWidget(bPtr->pathViewF, width, height);
 394     WMMoveWidget(bPtr->pathViewF, x, y);
 395     WMSetFrameRelief(bPtr->pathViewF, WRSunken);
 396     WMMapWidget(bPtr->pathViewF);
 397
 398     bPtr->pathView = FSCreatePathView(bPtr->pathViewF);
 399     WMMoveWidget(bPtr->pathView, x+2, y+2);
 400     WMResizeWidget(bPtr->pathView, width-3, height-3);
 401     FSSetPathViewFillColumnProc(bPtr->pathView, fillPV);
 402     FSSetPathViewAction(bPtr->pathView, handlePathViewAction, bPtr);
 403     FSSetPathViewDoubleAction(bPtr->pathView, handleDoubleAction, bPtr);
 404     WMAddNotificationObserver(scrolledPathView, bPtr,
 405                               FSPathViewDidScrollNotification,
 406                               bPtr->pathView);
 407     WMHangData(bPtr->pathView, bPtr);
 408 }
 409
 410 static void
 411 setupBrowserMode(FileBrowser *bPtr, int x, int y, int width, int height)
 412 {
 413     InitFSBrowser(WMWidgetScreen(bPtr->displayFrame));
 414     bPtr->browser = FSCreateBrowser(bPtr->displayFrame);
 415
 416     FSSetBrowserHasScroller(bPtr->browser, False);
 417     FSSetBrowserTitled(bPtr->browser, False);
 418     WMMoveWidget(bPtr->browser, x, y);
 419     WMResizeWidget(bPtr->browser, width, height);
 420     FSSetBrowserFillColumnProc(bPtr->browser, fillBrowserColumn);
 421     FSSetBrowserPathSeparator(bPtr->browser, DEFAULT_SEPARATOR);
 422     FSSetBrowserAction(bPtr->browser, handleItemSelection, bPtr);
 423     FSSetBrowserDoubleAction(bPtr->browser, handleDoubleAction, bPtr);
 424
 425     WMHangData(bPtr->browser, bPtr);
 426
 427 }
 428
 429 static void
 430 scrolledPathView(void *observerData, WMNotification *notification)
 431 {
 432     int col            = 0;
 433     FileBrowser *bPtr  = (FileBrowser *)observerData;
 434
 435     /* Get the col number we're at */
 436     col = *(int *)(WMGetNotificationClientData(notification));
 437     /* Scroll to this col */
 438     if(bPtr->currentMode == BROWSE)
 439         FSScrollBrowserToColumn(bPtr->browser, col, False);
 440 /*     else if(bPtr->currentMode == LIST) */
 441 /*      FSScrollMCListToColumn(bPtr->list, col+2, False); */
 442
 443 }
 444
 445 static void
 446 setupIconMode(FileBrowser *bPtr)
 447 {
 448 }
 449
 450 static void
 451 setupListMode(FileBrowser *bPtr, int x, int y, int width, int height)
 452 {
 453     bPtr->listF = WMCreateFrame(bPtr->displayFrame);
 454     WMSetFrameRelief(bPtr->listF, WRFlat);
 455     WMResizeWidget(bPtr->listF, width, height);
 456     WMMoveWidget(bPtr->listF, 0, 0);
 457
 458     bPtr->list = FSCreateMCList(bPtr->listF);
 459     FSSetMCListAction(bPtr->list, handleItemSelection, bPtr);
 460     FSSetMCListDoubleAction(bPtr->list, handleDoubleAction, bPtr);
 461 }
 462
 463 Bool
 464 FSSetFileBrowserPath(FileBrowser *bPtr, char *path)
 465 {
 466     Bool ok= True;
 467     int i, col;
 468
 469     switch(bPtr->currentMode)
 470     {
 471     case BROWSE : WMUnmapWidget(bPtr);
 472                   FSLoadBrowserColumnZero(bPtr->browser);
 473                   FSLoadPathViewColumnZero(bPtr->pathView);
 474                   FSSetBrowserPath(bPtr->browser, path);
 475                   col = FSGetFileBrowserColumnCount(bPtr);
 476                   FSSetPathViewToColumn(bPtr->pathView, col);
 477                   WMMapWidget(bPtr);
 478                   break;
 479     case ICON   : ok = False;
 480                   break;
 481     case LIST   : WMUnmapWidget(bPtr);
 482                   FSLoadMCListColumnZero(bPtr->list);
 483                   FSLoadPathViewColumnZero(bPtr->pathView);
 484                   FSSetMCListPath(bPtr->list, path);
 485                   col = FSGetFileBrowserColumnCount(bPtr);
 486                   FSSetPathViewToColumn(bPtr->pathView, col);
 487                   WMMapWidget(bPtr);
 488                   break;
 489     default     : ok = False;
 490                   break;
 491     }
 492
 493     return ok;
 494 }
 495
 496
 497 char*
 498 FSGetFileBrowserPath(FileBrowser *bPtr)
 499 {
 500     int   len;
 501     char *path  = NULL;
 502     char *npath = NULL;
 503
 504     switch(bPtr->currentMode)
 505     {
 506     case BROWSE : path  = FSGetBrowserPath(bPtr->browser);
 507                   len = strlen(path);
 508                   npath = (char *)wmalloc(len);
 509                   if(len > 1)
 510                   {
 511                       strncpy(npath, path, len-1);
 512                       npath[len-1] = '\0';
 513                   }
 514                   else
 515                       strcpy(npath, path);
 516                   if(path)
 517                       free(path);
 518                   break;
 519     case ICON   : npath = NULL;
 520                   break;
 521     case LIST   : npath  = FSGetMCListPath(bPtr->list);
 522                   break;
 523     default     : npath = NULL;
 524                   break;
 525     }
 526
 527     return npath;
 528
 529 }
 530
 531
 532 static void
 533 handleEvents(XEvent *event, void *data)
 534 {
 535     FileBrowser *bPtr = (FileBrowser*)data;
 536
 537 /*     CHECK_CLASS(data, W_FileBrowser); */
 538
 539     switch (event->type) {
 540     case Expose:
 541 /*      paintFileBrowser(bPtr); */
 542         break;
 543
 544     case DestroyNotify:
 545         destroyFileBrowser(bPtr);
 546         break;
 547     case ClientMessage:
 548         break;
 549     }
 550 }
 551
 552 static void
 553 destroyFileBrowser(FileBrowser *bPtr)
 554 {
 555     if(bPtr->text)
 556         free(bPtr->text);
 557
 558     free(bPtr);
 559 }
 560
 561 char*
 562 FSGetFileBrowserPathToColumn(FileBrowser *bPtr, int column)
 563 {
 564     int   len;
 565     char *path = NULL;
 566
 567     switch(bPtr->currentMode)
 568     {
 569     case BROWSE : path = FSGetBrowserPathToColumn(bPtr->browser, column);
 570                   break;
 571     case ICON   : path = NULL;
 572                   break;
 573     case LIST   : path = FSGetMCListPathToColumn(bPtr->list, column);
 574                   break;
 575     default     : path = NULL;
 576                   break;
 577     }
 578
 579     return path;
 580 }
 581
 582 static int
 583 FSGetFileBrowserColumnCount(FileBrowser *bPtr)
 584 {
 585     int num = -1;
 586
 587     switch(bPtr->currentMode)
 588     {
 589     case BROWSE : num = FSGetBrowserNumberOfColumns(bPtr->browser);
 590                   break;
 591     case ICON   : num = -1;
 592                   break;
 593     case LIST   : num = FSGetMCListNumberOfColumns(bPtr->list);
 594                   break;
 595     default     : num = -1;
 596                   break;
 597     }
 598
 599     return num;
 600 }
 601
 602 static int
 603 FSGetFileBrowserFirstVisibleColumn(FileBrowser *bPtr)
 604 {
 605     int first = -1;
 606
 607     switch(bPtr->currentMode)
 608     {
 609     case BROWSE : first = FSGetBrowserFirstVisibleColumn(bPtr->browser);
 610                   break;
 611     case ICON   : first = -1;
 612                   break;
 613     case LIST   : first = -1;
 614                   break;
 615     default     : first = -1;
 616                   break;
 617     }
 618
 619     return first;
 620 }
 621
 622 static FileInfo *
 623 FSGetFileBrowserFileInfoAt(FileBrowser *bPtr, int col)
 624 {
 625     char *pathname;
 626     FileInfo *fileInfo = NULL;
 627
 628     switch(bPtr->currentMode)
 629     {
 630     case BROWSE : pathname = FSGetFileBrowserPathToColumn(bPtr, col);
 631                   fileInfo = FSGetFileInfo(pathname);
 632                   break;
 633     case ICON   : fileInfo = NULL;
 634                   break;
 635     case LIST   : pathname = FSGetFileBrowserPathToColumn(bPtr, col+1);
 636                   fileInfo = FSGetFileInfo(pathname);
 637                   break;
 638     default     : fileInfo = NULL;
 639                   break;
 640     }
 641
 642     return fileInfo;
 643 }
 644
 645 FileInfo *
 646 FSGetFileBrowserSelectedFileInfo(FileBrowser *bPtr)
 647 {
 648     int col;
 649
 650     col = FSGetFileBrowserColumnCount(bPtr);
 651
 652     if(col > 1)
 653         return FSGetFileBrowserFileInfoAt(bPtr, col-2);
 654     else
 655         return NULL;
 656 }
 657
 658 void
 659 FSSetFileBrowserFilter(FileBrowser *bPtr, char *filter)
 660 {
 661     if(bPtr->filter)
 662         free(bPtr->filter);
 663
 664     if(filter)
 665         bPtr->filter = wstrdup(filter);
 666     else
 667         bPtr->filter = NULL;
 668
 669     if(bPtr->list)
 670         FSSetMCListFilter(bPtr->list, bPtr->filter);
 671 }
 672
 673 char *
 674 FSGetFileBrowserFilter(FileBrowser *bPtr)
 675 {
 676     return bPtr->filter;
 677 }
 678
 679 void
 680 FSSetFileBrowserDoubleAction(FileBrowser *bPtr,
 681                              WMAction *doubleAction,
 682                              void *doubleClientData)
 683 {
 684     bPtr->doubleAction = doubleAction;
 685     bPtr->doubleClientData = doubleClientData;
 686 }
 687
 688 static void
 689 insertIntoColumn(FileBrowser *bPtr, char *pathname)
 690 {
 691     int col;
 692     WMList   *list;
 693     FileInfo *new;
 694
 695     col = findColumnFromPath(GetPathFromPathname(pathname));
 696     new = FSGetFileInfo(pathname);
 697
 698     list = FSGetBrowserListInColumn(bPtr->browser, col);
 699
 700     if( DisplayFile(new->name, bPtr->filter, new->fileType) && list)
 701     {
 702         WMListItem *item;
 703         item = WMInsertListItem(list, -1, new->name);
 704         item->isBranch = isDirectory(new->fileType);
 705
 706 /*         listItem =  FSInsertBrowserItem(bPtr->browser, col, -1, new->name, */
 707 /*                                      isDirectory(new->fileType)); */
 708 /*      listItem->clientData = new; */
 709     }
 710     if(new)
 711         FSFreeFileInfo(new);
 712 }
 713
 714 static void
 715 removeFromColumn(FileBrowser *bPtr, char *path, char *name)
 716 {
 717     int col, row;
 718     WMList *list;
 719
 720     col  = findColumnFromPath(path);
 721     list = FSGetBrowserListInColumn(bPtr->browser, col);
 722     row  = WMFindRowOfListItemWithTitle(list, name);
 723     WMRemoveListItem(list, row);
 724 }
 725
 726 static int
 727 findColumnFromPath(char *path)
 728 {
 729     int i = 0;
 730     char *str = wstrdup(path);
 731     char *tmp = NULL;
 732
 733     tmp = strtok(str, "/");
 734     while (tmp)
 735     {
 736         tmp = strtok(NULL, "/");
 737         i++;
 738     }
 739     free(str);
 740
 741     return i;
 742 }
 743
 744 void
 745 FSSetFileBrowserColumnWidth(FileBrowser *bPtr, int width)
 746 {
 747     WMSize size;
 748
 749     assert(width >= PVICON_WIDTH);
 750
 751     size = WMGetViewSize(bPtr->view);
 752     bPtr->columnWidth = width;
 753     WMResizeWidget(bPtr, size.width, size.height);
 754 /*     resizeFileBrowser(bPtr, size.width, size.height); */
 755 }
 756
 757 void
 758 FSFileBrowserKeyPress(FileBrowser *bPtr, XEvent *event)
 759 {
 760     int    count;
 761     KeySym ksym;
 762     char   buffer[64];
 763
 764     count = XLookupString(&event->xkey, buffer, 63, &ksym, NULL);
 765     buffer[count] = '\0';
 766
 767 /*     navigateViews(bPtr, buffer); */
 768 /*     switch (ksym) */
 769 /*     { */
 770
 771 }
 772
 773 void
 774 FSUpdateFileBrowser(FileBrowser *bPtr, FileAction action,
 775                     FileInfo *src, FileInfo *dest)
 776 {
 777     int   col;
 778     char *tmp  = NULL;
 779     char *tmp2 = NULL;
 780
 781     switch(action)
 782         {
 783         case FileCopy   :
 784             if(isDirectory(dest->fileType))
 785             {
 786                 tmp = GetPathnameFromPathName(dest->path, dest->name);
 787                 tmp2 = GetPathnameFromPathName(tmp, src->name);
 788             }
 789             else
 790                 tmp2 = GetPathnameFromPathName(dest->path, dest->name);
 791             insertIntoView(bPtr, tmp2);
 792             break;
 793         case FileMove   :
 794             /* Move It */
 795             tmp = GetPathnameFromPathName(dest->path, dest->name);
 796             tmp2 = GetPathnameFromPathName(tmp, src->name);
 797             insertIntoView(bPtr, tmp2);
 798             /* Remove it */
 799             tmp = GetPathnameFromPathName(src->path, src->name);
 800             col = findColumnFromPath(tmp);
 801             removeFromView(bPtr, src->path, src->name);
 802             /* Update the display */
 803             col = findColumnFromPath(FSGetFileBrowserPath(bPtr));
 804             FSSetPathViewToColumn(bPtr->pathView, col);
 805             break;
 806         case FileRename   :
 807             tmp2 = GetPathnameFromPathName(dest->path, dest->name);
 808             insertIntoView(bPtr, tmp2);
 809             tmp = GetPathnameFromPathName(src->path, src->name);
 810             col = findColumnFromPath(tmp);
 811             removeFromView(bPtr, src->path, src->name);
 812             break;
 813         case FileLink   :
 814             tmp2 = GetPathnameFromPathName(dest->path, dest->name);
 815             insertIntoView(bPtr, tmp2);
 816             break;
 817         case FileDelete :
 818             /* Remove it */
 819             tmp = GetPathnameFromPathName(src->path, src->name);
 820             removeFromView(bPtr, src->path, src->name);
 821             /* Update the PathView */
 822             col = findColumnFromPath(FSGetFileBrowserPath(bPtr));
 823             FSSetPathViewToColumn(bPtr->pathView, col);
 824             break;
 825         case FileSync :
 826             /* redisplay current Path and update shelf */
 827             break;
 828         }
 829
 830     if(tmp)
 831         free(tmp);
 832     if(tmp2)
 833         free(tmp2);
 834 }
 835
 836 /*
 837  * Need to pass fileinfo instead of pathname to
 838  * facilitate multiple file insertions
 839  */
 840 static void
 841 insertIntoView(FileBrowser *bPtr, char *pathname)
 842 {
 843     int col;
 844     WMList   *list;
 845     FileInfo *new;
 846
 847     col = findColumnFromPath(GetPathFromPathname(pathname));
 848     new = FSGetFileInfo(pathname);
 849
 850     list = FSGetBrowserListInColumn(bPtr->browser, col);
 851     switch(bPtr->currentMode)
 852         {
 853         case BROWSE : list = FSGetBrowserListInColumn(bPtr->browser, col);
 854             break;
 855         case ICON   : list = NULL;
 856             break;
 857         case LIST   : list = FSGetMCListListInColumn(bPtr->list, col);
 858             break;
 859         default     :
 860             break;
 861     }
 862
 863
 864     if( DisplayFile(new->name, bPtr->filter, new->fileType) && list)
 865     {
 866         WMListItem *item;
 867         item = WMInsertListItem(list, -1, new->name);
 868         if(bPtr->currentMode == LIST)
 869             item->clientData = FSMCListFormatFileInfo(bPtr->list, new);
 870         item->isBranch = isDirectory(new->fileType);
 871     }
 872
 873     if(new)
 874         FSFreeFileInfo(new);
 875 }
 876
 877 static void
 878 removeFromView(FileBrowser *bPtr, char *path, char *name)
 879 {
 880     int col, row;
 881     WMList *list;
 882
 883     col  = findColumnFromPath(path);
 884     switch(bPtr->currentMode)
 885         {
 886         case BROWSE : list = FSGetBrowserListInColumn(bPtr->browser, col);
 887             break;
 888         case ICON   : list = NULL;
 889             break;
 890         case LIST   : list = FSGetMCListListInColumn(bPtr->list, col);
 891             break;
 892         default     : list = NULL;
 893             break;
 894     }
 895
 896     if(list)
 897     {
 898         row  = WMFindRowOfListItemWithTitle(list, name);
 899         WMRemoveListItem(list, row);
 900         }
 901 }
 902
 903 void
 904 FSSetFileBrowserMode(FileBrowser *bPtr, int mode)
 905 {
 906     char *path;
 907
 908     /* ICON ain't implemented yet */
 909     if(bPtr->currentMode == mode || mode == ICON)
 910         return;
 911
 912     path = FSGetFileBrowserPath(bPtr);
 913
 914     switch(bPtr->currentMode)
 915     {
 916     case BROWSE :
 917             WMUnmapWidget(bPtr->browser);
 918         break;
 919     case ICON   :
 920 /*          WMUnmapWidget(bPtr->icon); */
 921         break;
 922     case LIST   :
 923             WMUnmapWidget(bPtr->listF);
 924         break;
 925     }
 926
 927     bPtr->currentMode = mode;
 928
 929     switch(bPtr->currentMode)
 930     {
 931     case BROWSE : WMMapWidget(bPtr->browser);
 932                   break;
 933     case ICON   : break;
 934     case LIST   : WMMapWidget(bPtr->listF);
 935                   break;
 936     }
 937
 938     FSSetFileBrowserPath(bPtr, path);
 939 }