src/FSBrowser.c

   1 #include <WMaker.h>
   2 #include <WINGs/WINGsP.h>
   3 #include <math.h> /* for : double rint (double) */
   4
   5 #include "FSBrowser.h"
   6
   7 char *FSBrowserDidScrollNotification = "FSBrowserDidScrollNotification";
   8
   9
  10 typedef struct W_FSBrowser {
  11     W_Class widgetClass;
  12     W_View *view;
  13
  14     char **titles;
  15     WMList **columns;
  16
  17     short columnCount;
  18     short usedColumnCount;             /* columns actually being used */
  19     short minColumnWidth;
  20
  21     short maxVisibleColumns;
  22     short firstVisibleColumn;
  23
  24     short titleHeight;
  25
  26     short selectedColumn;
  27
  28     WMSize columnSize;
  29
  30
  31     void *clientData;
  32     WMAction *action;
  33     void *doubleClientData;
  34     WMAction *doubleAction;
  35
  36     FSBrowserFillColumnProc  *fillColumn;
  37     FSBrowserGetItemNameProc *parseItem;
  38
  39     WMScroller *scroller;
  40
  41     char *pathSeparator;
  42
  43     struct {
  44         WMReliefType relief:3;
  45         unsigned int isTitled:1;
  46         unsigned int allowMultipleSelection:1;
  47         unsigned int hasScroller:1;
  48         unsigned int emptyCol:1;
  49
  50         /* */
  51         unsigned int loaded:1;
  52         unsigned int loadingColumn:1;
  53     } flags;
  54 } _FSBrowser;
  55
  56
  57 #define COLUMN_SPACING  4
  58 #define TITLE_SPACING 2
  59
  60 #define DEFAULT_WIDTH                 305
  61 #define DEFAULT_HEIGHT                200
  62 #define DEFAULT_HAS_SCROLLER          True
  63 #define DEFAULT_TITLE_HEIGHT          20
  64 #define DEFAULT_IS_TITLED             True
  65 #define DEFAULT_MAX_VISIBLE_COLUMNS   2
  66 #define DEFAULT_SEPARATOR             "/"
  67 #define DEFAULT_RELIEF                WRSunken
  68
  69 #define MIN_VISIBLE_COLUMNS           1
  70 #define MAX_VISIBLE_COLUMNS           32
  71
  72
  73 #define COLUMN_IS_VISIBLE(b, c) ((c) >= (b)->firstVisibleColumn \
  74                                 && (c) < (b)->firstVisibleColumn + (b)->maxVisibleColumns)
  75
  76
  77 static void handleEvents(XEvent *event, void *data);
  78 static void destroyBrowser(FSBrowser *bPtr);
  79
  80 static void setupScroller(FSBrowser *bPtr);
  81
  82 static void scrollToColumn(FSBrowser *bPtr, int column, Bool updateScroller);
  83
  84 static void paintItem(WMList *lPtr, int index, Drawable d, char *text,
  85                       int state, WMRect *rect);
  86
  87 static void loadColumn(FSBrowser *bPtr, int column);
  88
  89 static void removeColumn(FSBrowser *bPtr, int column);
  90 static void paintBrowser(FSBrowser *bPtr);
  91
  92 static char*
  93 createTruncatedString(WMFont *font, char *text, int *textLen, int width);
  94
  95 static void willResizeFSBrowser(W_ViewDelegate *self, WMView *view,
  96                                 unsigned int *width, unsigned int *height);
  97 /* static void resizeFSBrowser(WMWidget*, unsigned int, unsigned int); */
  98
  99 /* W_ViewProcedureTable _FSBrowserViewProcedures = { */
 100 /*     NULL, */
 101 /*      resizeFSBrowser, */
 102 /*      NULL */
 103 /* }; */
 104
 105 static W_ViewDelegate _FSBrowserViewDelegate = {
 106         NULL,
 107         NULL,
 108         NULL,
 109         NULL,
 110         willResizeFSBrowser
 111 };
 112
 113
 114
 115 // Widget class ID.
 116 static  W_Class fsBrowserWidgetClass = 0;
 117
 118 W_Class InitFSBrowser(WMScreen *scr)
 119 {
 120     // Register the widget with WINGs and get the widget class ID.
 121     if (!(fsBrowserWidgetClass))
 122     {
 123         fsBrowserWidgetClass =
 124 /*          W_RegisterUserWidget(&_FSBrowserViewProcedures); */
 125             W_RegisterUserWidget();
 126     }
 127
 128     return fsBrowserWidgetClass;
 129 }
 130
 131 FSBrowser*
 132 FSCreateBrowser(WMWidget *parent)
 133 {
 134     FSBrowser *bPtr;
 135     int i;
 136
 137     wassertrv(parent, NULL);
 138
 139     bPtr = wmalloc(sizeof(FSBrowser));
 140     memset(bPtr, 0, sizeof(FSBrowser));
 141
 142     bPtr->widgetClass = fsBrowserWidgetClass/* WC_Browser */;
 143
 144     bPtr->view = W_CreateView(W_VIEW(parent));
 145     if (!bPtr->view) {
 146         free(bPtr);
 147         return NULL;
 148     }
 149     bPtr->view->self = bPtr;
 150     bPtr->view->delegate = &_FSBrowserViewDelegate;
 151
 152     WMCreateEventHandler(bPtr->view, ExposureMask|StructureNotifyMask
 153                          |ClientMessageMask, handleEvents, bPtr);
 154
 155     /* default configuration */
 156     bPtr->flags.hasScroller = DEFAULT_HAS_SCROLLER;
 157
 158     bPtr->titleHeight = DEFAULT_TITLE_HEIGHT;
 159     bPtr->flags.isTitled = DEFAULT_IS_TITLED;
 160     bPtr->flags.emptyCol = 1;
 161     bPtr->maxVisibleColumns = DEFAULT_MAX_VISIBLE_COLUMNS;
 162
 163     WMResizeWidget(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 164 /*     resizeFSBrowser(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT); */
 165
 166     bPtr->pathSeparator = wstrdup(DEFAULT_SEPARATOR);
 167
 168     if (bPtr->flags.hasScroller)
 169         setupScroller(bPtr);
 170
 171     for (i=0; i<bPtr->maxVisibleColumns; i++) {
 172         FSAddBrowserColumn(bPtr);
 173     }
 174     bPtr->usedColumnCount = 0;
 175
 176     bPtr->selectedColumn = -1;
 177
 178     return bPtr;
 179 }
 180
 181
 182 void
 183 FSSetBrowserMaxVisibleColumns(FSBrowser *bPtr, int columns)
 184 {
 185     int curMaxVisibleColumns;
 186     int newFirstVisibleColumn = 0;
 187
 188     assert ((int) bPtr);
 189
 190     columns = (columns < MIN_VISIBLE_COLUMNS) ? MIN_VISIBLE_COLUMNS : columns;
 191     columns = (columns > MAX_VISIBLE_COLUMNS) ? MAX_VISIBLE_COLUMNS : columns;
 192     if (columns == bPtr->maxVisibleColumns) {
 193         return;
 194     }
 195     curMaxVisibleColumns = bPtr->maxVisibleColumns;
 196     bPtr->maxVisibleColumns = columns;
 197     /* browser not loaded */
 198     if (!bPtr->flags.loaded) {
 199         if ((columns > curMaxVisibleColumns) && (columns > bPtr->columnCount)) {
 200             int i = columns - bPtr->columnCount;
 201             bPtr->usedColumnCount = bPtr->columnCount;
 202             while (i--) {
 203                 FSAddBrowserColumn(bPtr);
 204             }
 205             bPtr->usedColumnCount = 0;
 206         }
 207     /* browser loaded and columns > curMaxVisibleColumns */
 208     } else if (columns > curMaxVisibleColumns) {
 209         if (bPtr->usedColumnCount > columns) {
 210             newFirstVisibleColumn = bPtr->usedColumnCount - columns;
 211         }
 212         if (newFirstVisibleColumn > bPtr->firstVisibleColumn) {
 213             newFirstVisibleColumn = bPtr->firstVisibleColumn;
 214         }
 215         if (columns > bPtr->columnCount) {
 216             int i = columns - bPtr->columnCount;
 217             int curUsedColumnCount = bPtr->usedColumnCount;
 218             bPtr->usedColumnCount = bPtr->columnCount;
 219             while (i--) {
 220                 FSAddBrowserColumn(bPtr);
 221             }
 222             bPtr->usedColumnCount = curUsedColumnCount;
 223         }
 224     /* browser loaded and columns < curMaxVisibleColumns */
 225     } else {
 226         newFirstVisibleColumn = bPtr->firstVisibleColumn;
 227         if (newFirstVisibleColumn + columns >= bPtr->usedColumnCount) {
 228             removeColumn(bPtr, newFirstVisibleColumn + columns);
 229         }
 230     }
 231     WMResizeWidget(bPtr, bPtr->view->size.width, bPtr->view->size.height);
 232 /*     resizeFSBrowser(bPtr, bPtr->view->size.width, bPtr->view->size.height); */
 233     if (bPtr->flags.loaded) {
 234         XClearArea(bPtr->view->screen->display, bPtr->view->window, 0, 0,
 235                    bPtr->view->size.width, bPtr->titleHeight, False);
 236         scrollToColumn (bPtr, newFirstVisibleColumn, True);
 237     }
 238 }
 239
 240
 241 int
 242 FSGetBrowserNumberOfColumns(FSBrowser *bPtr)
 243 {
 244     return bPtr->usedColumnCount;
 245 }
 246
 247 void
 248 FSSetBrowserPathSeparator(FSBrowser *bPtr, char *separator)
 249 {
 250     if (bPtr->pathSeparator)
 251         free(bPtr->pathSeparator);
 252     bPtr->pathSeparator = wstrdup(separator);
 253 }
 254
 255
 256
 257 static void
 258 drawTitleOfColumn(FSBrowser *bPtr, int column)
 259 {
 260     WMScreen *scr = bPtr->view->screen;
 261     int x;
 262
 263     x=(column-bPtr->firstVisibleColumn)*(bPtr->columnSize.width+COLUMN_SPACING);
 264
 265     XFillRectangle(scr->display, bPtr->view->window, WMColorGC(scr->darkGray), x, 0,
 266                    bPtr->columnSize.width, bPtr->titleHeight);
 267     W_DrawRelief(scr, bPtr->view->window, x, 0,
 268                  bPtr->columnSize.width, bPtr->titleHeight, WRSunken);
 269
 270     if (column < bPtr->usedColumnCount && bPtr->titles[column]) {
 271         int titleLen = strlen(bPtr->titles[column]);
 272         int widthC = bPtr->columnSize.width-8;
 273
 274         if (WMWidthOfString(scr->boldFont, bPtr->titles[column], titleLen)
 275             > widthC) {
 276             char *titleBuf = createTruncatedString(scr->boldFont,
 277                                                    bPtr->titles[column],
 278                                                    &titleLen, widthC);
 279             W_PaintText(bPtr->view, bPtr->view->window, scr->boldFont, x,
 280                         (bPtr->titleHeight-WMFontHeight(scr->boldFont))/2,
 281                         bPtr->columnSize.width, WACenter, WMWhiteColor(scr),
 282                         False, titleBuf, titleLen);
 283             free (titleBuf);
 284         } else {
 285             W_PaintText(bPtr->view, bPtr->view->window, scr->boldFont, x,
 286                         (bPtr->titleHeight-WMFontHeight(scr->boldFont))/2,
 287                         bPtr->columnSize.width, WACenter, WMWhiteColor(scr),
 288                         False, bPtr->titles[column], titleLen);
 289         }
 290     }
 291 }
 292
 293
 294 void
 295 FSSetBrowserColumnTitle(FSBrowser *bPtr, int column, char *title)
 296 {
 297     assert(column >= 0);
 298     assert(column < bPtr->usedColumnCount);
 299
 300     if (bPtr->titles[column])
 301         free(bPtr->titles[column]);
 302
 303     bPtr->titles[column] = wstrdup(title);
 304
 305     if (COLUMN_IS_VISIBLE(bPtr, column) && bPtr->flags.isTitled) {
 306         drawTitleOfColumn(bPtr, column);
 307     }
 308 }
 309
 310
 311 WMList*
 312 FSGetBrowserListInColumn(FSBrowser *bPtr, int column)
 313 {
 314     if (column < 0 || column >= bPtr->usedColumnCount)
 315         return NULL;
 316
 317     return bPtr->columns[column];
 318 }
 319
 320
 321 void
 322 FSSetBrowserFillColumnProc(FSBrowser *bPtr, FSBrowserFillColumnProc *proc)
 323 {
 324     bPtr->fillColumn = proc;
 325 }
 326
 327
 328 void
 329 FSSetBrowserGetItemNameProc(FSBrowser *bPtr, FSBrowserGetItemNameProc *proc)
 330 {
 331     bPtr->parseItem = proc;
 332 }
 333
 334
 335 int
 336 FSGetBrowserFirstVisibleColumn(FSBrowser *bPtr)
 337 {
 338     return bPtr->firstVisibleColumn;
 339 }
 340
 341
 342 static void
 343 removeColumn(FSBrowser *bPtr, int column)
 344 {
 345     int i, clearEnd, destroyEnd;
 346     WMList **clist;
 347     char **tlist;
 348
 349     assert ((int) bPtr);
 350
 351     column = (column < 0) ? 0 : column;
 352     if (column >= bPtr->columnCount) {
 353         return;
 354     }
 355     if (column < bPtr->maxVisibleColumns) {
 356         clearEnd = bPtr->maxVisibleColumns;
 357         destroyEnd = bPtr->columnCount;
 358         bPtr->columnCount = bPtr->maxVisibleColumns;
 359     } else {
 360         clearEnd = column;
 361         destroyEnd = bPtr->columnCount;
 362         bPtr->columnCount = column;
 363     }
 364     if (column < bPtr->usedColumnCount) {
 365         bPtr->usedColumnCount = column;
 366     }
 367     for (i=column; i < clearEnd; i++) {
 368         if (bPtr->titles[i]) {
 369             free(bPtr->titles[i]);
 370             bPtr->titles[i] = NULL;
 371         }
 372         WMClearList(bPtr->columns[i]);
 373     }
 374     for (;i < destroyEnd; i++)
 375     {
 376         int j = 0;
 377         int numRows = 0;
 378         WMListItem *item = NULL;
 379
 380         if (bPtr->titles[i]) {
 381             free(bPtr->titles[i]);
 382             bPtr->titles[i] = NULL;
 383         }
 384         WMRemoveNotificationObserverWithName(bPtr,
 385                                              WMListSelectionDidChangeNotification,
 386                                              bPtr->columns[i]);
 387
 388         /*
 389          * Free the client data.
 390          * This assumes is it a string or the like.
 391          * Hopefully it won't slow things down too much.
 392          * Should use a callback to allow for more complicated
 393          * clientData structures.
 394          */
 395 /*      numRows = WMGetListNumberOfRows(bPtr->columns[i]); */
 396 /*      for(j = 0; j < numRows; j++) */
 397 /*      { */
 398
 399 /*          item = WMGetListItem(bPtr->columns[i], j); */
 400 /*          if(item->clientData) */
 401 /*          { */
 402 /*              free(item->clientData); */
 403 /*              item->clientData = NULL; */
 404 /*          } */
 405 /*      } */
 406         WMDestroyWidget(bPtr->columns[i]);
 407         bPtr->columns[i] = NULL;
 408     }
 409     clist = wmalloc(sizeof(WMList*) * (bPtr->columnCount));
 410     tlist = wmalloc(sizeof(char*) * (bPtr->columnCount));
 411     memcpy(clist, bPtr->columns, sizeof(WMList*) * (bPtr->columnCount));
 412     memcpy(tlist, bPtr->titles, sizeof(char*) * (bPtr->columnCount));
 413     free(bPtr->titles);
 414     free(bPtr->columns);
 415     bPtr->titles = tlist;
 416     bPtr->columns = clist;
 417 }
 418
 419
 420 WMListItem*
 421 FSGetBrowserSelectedItemInColumn(FSBrowser *bPtr, int column)
 422 {
 423     if ((column < 0) || (column >= bPtr->usedColumnCount))
 424         return NULL;
 425
 426     return WMGetListSelectedItem(bPtr->columns[column]);
 427 }
 428
 429
 430
 431 int
 432 FSGetBrowserSelectedColumn(FSBrowser *bPtr)
 433 {
 434     return bPtr->selectedColumn;
 435 }
 436
 437
 438 int
 439 FSGetBrowserSelectedRowInColumn(FSBrowser *bPtr, int column)
 440 {
 441     if (column >= 0 && column < bPtr->columnCount) {
 442         return WMGetListSelectedItemRow(bPtr->columns[column]);
 443     } else {
 444         return -1;
 445     }
 446 }
 447
 448
 449 void
 450 FSSetBrowserTitled(FSBrowser *bPtr, Bool flag)
 451 {
 452     int i;
 453     int columnX, columnY;
 454
 455     if (bPtr->flags.isTitled == flag)
 456         return;
 457
 458     columnX = 0;
 459
 460     if (!bPtr->flags.isTitled) {
 461         columnY = TITLE_SPACING + bPtr->titleHeight;
 462
 463         bPtr->columnSize.height -= columnY;
 464
 465         for (i=0; i<bPtr->columnCount; i++) {
 466             WMResizeWidget(bPtr->columns[i], bPtr->columnSize.width,
 467                            bPtr->columnSize.height);
 468
 469             columnX = WMWidgetView(bPtr->columns[i])->pos.x;
 470
 471             WMMoveWidget(bPtr->columns[i], columnX, columnY);
 472         }
 473     } else {
 474         bPtr->columnSize.height += TITLE_SPACING + bPtr->titleHeight;
 475
 476         for (i=0; i<bPtr->columnCount; i++) {
 477             WMResizeWidget(bPtr->columns[i], bPtr->columnSize.width,
 478                            bPtr->columnSize.height);
 479
 480             columnX = WMWidgetView(bPtr->columns[i])->pos.x;
 481
 482             WMMoveWidget(bPtr->columns[i], columnX, 0);
 483         }
 484     }
 485
 486     bPtr->flags.isTitled = flag;
 487 }
 488
 489
 490 /* WMListItem* */
 491 /* FSAddSortedBrowserItem(FSBrowser *bPtr, int column, char *text, Bool isBranch) */
 492 /* { */
 493 /*     WMListItem *item; */
 494
 495 /*     if (column < 0 || column >= bPtr->columnCount) */
 496 /*      return NULL; */
 497
 498 /*     item = WMAddSortedListItem(bPtr->columns[column], text); */
 499 /*     item->isBranch = isBranch; */
 500
 501 /*     return item; */
 502 /* } */
 503
 504
 505
 506 WMListItem*
 507 FSInsertBrowserItem(FSBrowser *bPtr, int column, int row, char *text,
 508                     Bool isBranch)
 509 {
 510     WMListItem *item;
 511
 512     if (column < 0 || column >= bPtr->columnCount)
 513         return NULL;
 514
 515     item = WMInsertListItem(bPtr->columns[column], row, text);
 516     item->isBranch = isBranch;
 517
 518     return item;
 519 }
 520
 521
 522 void
 523 FSSetBrowserRelief(FSBrowser *bPtr, WMReliefType relief)
 524 {
 525     bPtr->flags.relief = relief;
 526     if (bPtr->view->flags.realized) {
 527         paintBrowser(bPtr);
 528     }
 529 }
 530
 531
 532 static void
 533 willResizeFSBrowser(W_ViewDelegate *self, WMView *view,
 534                     unsigned int *width, unsigned int *height)
 535 {
 536     FSBrowser *bPtr = (FSBrowser*)view->self;
 537     int cols = bPtr->maxVisibleColumns;
 538     int colX, colY;
 539     int i;
 540
 541     assert(*width > 0);
 542     assert(*height > 0);
 543
 544     bPtr->columnSize.width = (*width-(cols-1)*COLUMN_SPACING) / cols;
 545     bPtr->columnSize.height = *height;
 546
 547     if (bPtr->flags.isTitled) {
 548         colY = TITLE_SPACING + bPtr->titleHeight;
 549         bPtr->columnSize.height -= colY;
 550     } else {
 551         colY = 0;
 552     }
 553
 554     if (bPtr->flags.hasScroller) {
 555         bPtr->columnSize.height -= SCROLLER_WIDTH + 4;
 556
 557         if (bPtr->scroller) {
 558             WMResizeWidget(bPtr->scroller, *width-2, 1);
 559             WMMoveWidget(bPtr->scroller, 1, *height-SCROLLER_WIDTH-1);
 560         }
 561     }
 562
 563     colX = 0;
 564     for (i = 0; i < bPtr->columnCount; i++) {
 565         WMResizeWidget(bPtr->columns[i], bPtr->columnSize.width,
 566                        bPtr->columnSize.height);
 567
 568         WMMoveWidget(bPtr->columns[i], colX, colY);
 569
 570         if (COLUMN_IS_VISIBLE(bPtr, i)) {
 571             colX += bPtr->columnSize.width+COLUMN_SPACING;
 572         }
 573     }
 574
 575 /*     W_ResizeView(bPtr->view, *width, *height); */
 576 }
 577 /* static void  */
 578 /* resizeFSBrowser(WMWidget *w, unsigned int width, unsigned int height) */
 579 /* { */
 580 /*     FSBrowser *bPtr = (FSBrowser*)w; */
 581 /*     int cols = bPtr->maxVisibleColumns; */
 582 /*     int colX, colY; */
 583 /*     int i; */
 584
 585 /*     assert(width > 0); */
 586 /*     assert(height > 0); */
 587
 588 /*     bPtr->columnSize.width = (width-(cols-1)*COLUMN_SPACING) / cols; */
 589 /*     bPtr->columnSize.height = height; */
 590
 591 /*     if (bPtr->flags.isTitled) { */
 592 /*      colY = TITLE_SPACING + bPtr->titleHeight; */
 593 /*      bPtr->columnSize.height -= colY; */
 594 /*     } else { */
 595 /*      colY = 0; */
 596 /*     } */
 597
 598 /*     if (bPtr->flags.hasScroller) { */
 599 /*      bPtr->columnSize.height -= SCROLLER_WIDTH + 4; */
 600
 601 /*      if (bPtr->scroller) { */
 602 /*          WMResizeWidget(bPtr->scroller, width-2, 1); */
 603 /*          WMMoveWidget(bPtr->scroller, 1, height-SCROLLER_WIDTH-1); */
 604 /*      } */
 605 /*     } */
 606
 607 /*     colX = 0; */
 608 /*     for (i = 0; i < bPtr->columnCount; i++) { */
 609 /*      WMResizeWidget(bPtr->columns[i], bPtr->columnSize.width, */
 610 /*                     bPtr->columnSize.height); */
 611
 612 /*      WMMoveWidget(bPtr->columns[i], colX, colY); */
 613
 614 /*      if (COLUMN_IS_VISIBLE(bPtr, i)) { */
 615 /*          colX += bPtr->columnSize.width+COLUMN_SPACING; */
 616 /*      } */
 617 /*     } */
 618
 619 /*     W_ResizeView(bPtr->view, width, height); */
 620 /* } */
 621
 622
 623 static void
 624 paintItem(WMList *lPtr, int index, Drawable d, char *text, int state,
 625           WMRect *rect)
 626 {
 627     WMView *view = W_VIEW(lPtr);
 628     W_Screen *scr = view->screen;
 629     int width, height, x, y;
 630 /*     WMListItem *item; */
 631
 632 /*     item = WMGetListItem(lPtr, index); */
 633
 634     width = rect->size.width;
 635     height = rect->size.height;
 636     x = rect->pos.x;
 637     y = rect->pos.y;
 638
 639     if (state & WLDSSelected)
 640         WMPaintColorSwatch(WMWhiteColor(scr), d, x, y,
 641                        width, height);
 642     else
 643         WMPaintColorSwatch(WMGetWidgetBackgroundColor(lPtr), d, x, y,
 644                        width, height);
 645
 646     if (text) {
 647         /* Avoid overlaping... */
 648         int textLen = strlen(text);
 649         int widthC = (state & WLDSIsBranch) ? width-20 : width-8;
 650         if (WMWidthOfString(scr->normalFont, text, textLen) > widthC) {
 651             char *textBuf = createTruncatedString(scr->normalFont,
 652                                                   text, &textLen, widthC);
 653             W_PaintText(view, d, scr->normalFont,  x+4, y, widthC,
 654                         WALeft, WMBlackColor(scr), False, textBuf, textLen);
 655             free(textBuf);
 656         } else {
 657             W_PaintText(view, d, scr->normalFont,  x+4, y, widthC,
 658                         WALeft, WMBlackColor(scr), False, text, textLen);
 659         }
 660     }
 661
 662     if (state & WLDSIsBranch) {
 663         XDrawLine(scr->display, d, WMColorGC(scr->darkGray), x+width-11, y+3,
 664                   x+width-6, y+height/2);
 665         if (state & WLDSSelected)
 666             XDrawLine(scr->display, d,WMColorGC(scr->gray), x+width-11, y+height-5,
 667                       x+width-6, y+height/2);
 668         else
 669             XDrawLine(scr->display, d,WMColorGC(scr->white), x+width-11, y+height-5,
 670                       x+width-6, y+height/2);
 671         XDrawLine(scr->display, d, WMColorGC(scr->black), x+width-12, y+3,
 672                   x+width-12, y+height-5);
 673     }
 674 }
 675
 676
 677 static void
 678 scrollCallback(WMWidget *scroller, void *self)
 679 {
 680     FSBrowser *bPtr = (FSBrowser*)self;
 681     WMScroller *sPtr = (WMScroller*)scroller;
 682     int newFirst;
 683 #define LAST_VISIBLE_COLUMN  bPtr->firstVisibleColumn+bPtr->maxVisibleColumns
 684
 685     switch (WMGetScrollerHitPart(sPtr)) {
 686      case WSDecrementLine:
 687         if (bPtr->firstVisibleColumn > 0) {
 688             scrollToColumn(bPtr, bPtr->firstVisibleColumn-1, True);
 689         }
 690         break;
 691
 692      case WSDecrementPage:
 693         if (bPtr->firstVisibleColumn > 0) {
 694             newFirst = bPtr->firstVisibleColumn - bPtr->maxVisibleColumns;
 695
 696             scrollToColumn(bPtr, newFirst, True);
 697         }
 698         break;
 699
 700
 701      case WSIncrementLine:
 702         if (LAST_VISIBLE_COLUMN < bPtr->usedColumnCount) {
 703             scrollToColumn(bPtr, bPtr->firstVisibleColumn+1, True);
 704         }
 705         break;
 706
 707      case WSIncrementPage:
 708         if (LAST_VISIBLE_COLUMN < bPtr->usedColumnCount) {
 709             newFirst = bPtr->firstVisibleColumn + bPtr->maxVisibleColumns;
 710
 711             if (newFirst+bPtr->maxVisibleColumns >= bPtr->columnCount)
 712                 newFirst = bPtr->columnCount - bPtr->maxVisibleColumns;
 713
 714             scrollToColumn(bPtr, newFirst, True);
 715         }
 716         break;
 717
 718      case WSKnob:
 719         {
 720             double floatValue;
 721             double value = bPtr->columnCount - bPtr->maxVisibleColumns;
 722
 723             floatValue = WMGetScrollerValue(bPtr->scroller);
 724
 725             floatValue = (floatValue*value)/value;
 726
 727             newFirst = rint(floatValue*(float)(bPtr->columnCount - bPtr->maxVisibleColumns));
 728
 729             if (bPtr->firstVisibleColumn != newFirst)
 730                 scrollToColumn(bPtr, newFirst, False);
 731 /*          else
 732                 WMSetScrollerParameters(bPtr->scroller, floatValue,
 733                                         bPtr->maxVisibleColumns/(float)bPtr->columnCount);
 734  */
 735
 736         }
 737         break;
 738
 739      case WSKnobSlot:
 740      case WSNoPart:
 741         /* do nothing */
 742         break;
 743     }
 744 #undef LAST_VISIBLE_COLUMN
 745 }
 746
 747
 748 static void
 749 setupScroller(FSBrowser *bPtr)
 750 {
 751     WMScroller *sPtr;
 752     int y;
 753
 754     y = bPtr->view->size.height - SCROLLER_WIDTH - 1;
 755
 756     sPtr = WMCreateScroller(bPtr);
 757     WMSetScrollerAction(sPtr, scrollCallback, bPtr);
 758     WMMoveWidget(sPtr, 1, y);
 759     WMResizeWidget(sPtr, bPtr->view->size.width-2, SCROLLER_WIDTH);
 760
 761     bPtr->scroller = sPtr;
 762
 763     WMMapWidget(sPtr);
 764 }
 765
 766
 767 void
 768 FSSetBrowserAction(FSBrowser *bPtr, WMAction *action, void *clientData)
 769 {
 770     bPtr->action = action;
 771     bPtr->clientData = clientData;
 772 }
 773
 774
 775 void
 776 FSSetBrowserDoubleAction(FSBrowser *bPtr, WMAction *action, void *clientData)
 777 {
 778     bPtr->doubleAction = action;
 779     bPtr->doubleClientData = clientData;
 780 }
 781
 782
 783 void
 784 FSSetBrowserHasScroller(FSBrowser *bPtr, int hasScroller)
 785 {
 786     bPtr->flags.hasScroller = hasScroller;
 787
 788     if(bPtr->flags.hasScroller)
 789         WMMapWidget(bPtr->scroller);
 790     else
 791         WMUnmapWidget(bPtr->scroller);
 792 }
 793
 794
 795
 796 char*
 797 FSSetBrowserPath(FSBrowser *bPtr, char *path)
 798 {
 799     int i;
 800     char *str = wstrdup(path);
 801     char *tmp, *retPtr = NULL;
 802     int item;
 803     WMListItem *listItem;
 804
 805     /* WMLoadBrowserColumnZero must be call first */
 806     if (!bPtr->flags.loaded) {
 807         return False;
 808     }
 809
 810     removeColumn(bPtr, 1);
 811
 812     i = 0;
 813     tmp = strtok(str, bPtr->pathSeparator);
 814     while (tmp) {
 815         /* select it in the column */
 816         item = WMFindRowOfListItemWithTitle(bPtr->columns[i], tmp);
 817         if (item<0) {
 818             retPtr = &path[(int)(tmp - str)];
 819             break;
 820         }
 821         WMSelectListItem(bPtr->columns[i], item);
 822         WMSetListPosition(bPtr->columns[i], item);
 823
 824         listItem = WMGetListItem(bPtr->columns[i], item);
 825         if (!listItem  || (!listItem->isBranch && !bPtr->flags.emptyCol) ) {
 826             break;
 827         }
 828
 829         /* load next column */
 830         FSAddBrowserColumn(bPtr);
 831
 832         loadColumn(bPtr, i+1);
 833
 834         tmp = strtok(NULL, bPtr->pathSeparator);
 835         i++;
 836     }
 837     free(str);
 838
 839     for (i = bPtr->usedColumnCount - 1;
 840          (i > -1) && !WMGetListSelectedItem(bPtr->columns[i]);
 841          i--);
 842
 843     bPtr->selectedColumn = i;
 844
 845     if (bPtr->columnCount < bPtr->maxVisibleColumns) {
 846         int i = bPtr->maxVisibleColumns - bPtr->columnCount;
 847         int curUsedColumnCount = bPtr->usedColumnCount;
 848         bPtr->usedColumnCount = bPtr->columnCount;
 849         while (i--) {
 850             FSAddBrowserColumn(bPtr);
 851         }
 852         bPtr->usedColumnCount = curUsedColumnCount;
 853     }
 854
 855     scrollToColumn(bPtr, bPtr->columnCount - bPtr->maxVisibleColumns, True);
 856
 857     return retPtr;
 858 }
 859
 860
 861 char*
 862 FSGetBrowserPath(FSBrowser *bPtr)
 863 {
 864     return FSGetBrowserPathToColumn(bPtr, bPtr->columnCount);
 865 }
 866
 867
 868 char*
 869 FSGetBrowserPathToColumn(FSBrowser *bPtr, int column)
 870 {
 871     int i, size;
 872     char *path;
 873     WMListItem *item;
 874
 875     if (column >= bPtr->usedColumnCount)
 876         column = bPtr->usedColumnCount-1;
 877
 878     if (column < 0) {
 879         return wstrdup(bPtr->pathSeparator);
 880     }
 881
 882     /* calculate size of buffer */
 883     size = 0;
 884     for (i = 0; i <= column; i++) {
 885         item = WMGetListSelectedItem(bPtr->columns[i]);
 886         if (!item)
 887             break;
 888 /*      if(bPtr->parseItem) */
 889 /*          size += strlen((*bPtr->parseItem)(item)); */
 890 /*      else */
 891             size += strlen(item->text);
 892     }
 893
 894     /* get the path */
 895     path = wmalloc(size+(column+1)*strlen(bPtr->pathSeparator)+1);
 896     /* ignore first / */
 897     *path = 0;
 898     for (i = 0; i <= column; i++) {
 899         strcat(path, bPtr->pathSeparator);
 900         item = WMGetListSelectedItem(bPtr->columns[i]);
 901         if (!item)
 902             break;
 903 /*      if(bPtr->parseItem) */
 904 /*          strcat(path, (*bPtr->parseItem)(item)); */
 905 /*      else */
 906             strcat(path, item->text);
 907     }
 908
 909     return path;
 910 }
 911
 912
 913 static void
 914 loadColumn(FSBrowser *bPtr, int column)
 915 {
 916     assert(bPtr->fillColumn);
 917     bPtr->flags.loadingColumn = 1;
 918     (*bPtr->fillColumn)(bPtr, column);
 919     bPtr->flags.loadingColumn = 0;
 920 }
 921
 922
 923 static void
 924 paintBrowser(FSBrowser *bPtr)
 925 {
 926     int i;
 927
 928     if (!bPtr->view->flags.mapped)
 929         return;
 930
 931     if(bPtr->flags.hasScroller)
 932         W_DrawRelief(bPtr->view->screen, bPtr->view->window, 0,
 933                      bPtr->view->size.height-SCROLLER_WIDTH-2,
 934                      bPtr->view->size.width, 22, bPtr->flags.relief);
 935
 936     if (bPtr->flags.isTitled) {
 937         for (i=0; i<bPtr->maxVisibleColumns; i++) {
 938             drawTitleOfColumn(bPtr, i+bPtr->firstVisibleColumn);
 939         }
 940     }
 941 }
 942
 943
 944 static void
 945 handleEvents(XEvent *event, void *data)
 946 {
 947     FSBrowser *bPtr = (FSBrowser*)data;
 948
 949 /*     CHECK_CLASS(data, fsBrowserWidgetClass); */
 950
 951
 952     switch (event->type) {
 953      case Expose:
 954         paintBrowser(bPtr);
 955         break;
 956
 957      case DestroyNotify:
 958         destroyBrowser(bPtr);
 959         break;
 960
 961     }
 962 }
 963
 964
 965
 966 static void
 967 scrollToColumn(FSBrowser *bPtr, int column, Bool updateScroller)
 968 {
 969     int i;
 970     int x;
 971     int notify = 0;
 972
 973
 974     if (column != bPtr->firstVisibleColumn)
 975         notify = 1;
 976
 977     if (column < 0)
 978         column = 0;
 979
 980     x = 0;
 981     bPtr->firstVisibleColumn = column;
 982     for (i = 0; i < bPtr->columnCount; i++) {
 983         if (COLUMN_IS_VISIBLE(bPtr, i)) {
 984             WMMoveWidget(bPtr->columns[i], x,
 985                          WMWidgetView(bPtr->columns[i])->pos.y);
 986             if (!WMWidgetView(bPtr->columns[i])->flags.realized)
 987                 WMRealizeWidget(bPtr->columns[i]);
 988             WMMapWidget(bPtr->columns[i]);
 989             x += bPtr->columnSize.width + COLUMN_SPACING;
 990         } else {
 991             WMUnmapWidget(bPtr->columns[i]);
 992         }
 993     }
 994
 995     /* update the scroller */
 996     if (updateScroller) {
 997         if (bPtr->columnCount > bPtr->maxVisibleColumns) {
 998             float value, proportion;
 999
1000             value = bPtr->firstVisibleColumn
1001                 /(float)(bPtr->columnCount-bPtr->maxVisibleColumns);
1002             proportion = bPtr->maxVisibleColumns/(float)bPtr->columnCount;
1003             WMSetScrollerParameters(bPtr->scroller, value, proportion);
1004         } else {
1005             WMSetScrollerParameters(bPtr->scroller, 0, 1);
1006         }
1007     }
1008
1009     if (bPtr->view->flags.mapped)
1010         paintBrowser(bPtr);
1011
1012     if (notify)
1013     {
1014         WMPostNotificationName(FSBrowserDidScrollNotification, bPtr, NULL);
1015     }
1016 }
1017
1018
1019 static void
1020 listCallback(void *self, void *clientData)
1021 {
1022     FSBrowser *bPtr = (FSBrowser*)clientData;
1023     WMList *lPtr = (WMList*)self;
1024     WMListItem *item;
1025     static WMListItem *oldItem = NULL;
1026     int i;
1027
1028     item = WMGetListSelectedItem(lPtr);
1029     if (!item) {
1030         oldItem = item;
1031         return;
1032     }
1033
1034     if (oldItem != item) {
1035         for (i=0; i<bPtr->columnCount; i++) {
1036             if (lPtr == bPtr->columns[i])
1037                 break;
1038         }
1039         assert(i<bPtr->columnCount);
1040
1041         bPtr->selectedColumn = i;
1042
1043         /* columns at right must be cleared */
1044         removeColumn(bPtr, i+1);
1045         /* open directory */
1046         if (item->isBranch || bPtr->flags.emptyCol) {
1047             FSAddBrowserColumn(bPtr);
1048         }
1049         if(bPtr->flags.emptyCol)
1050         {
1051             if (bPtr->usedColumnCount < bPtr->maxVisibleColumns)
1052                 i = 0;
1053
1054             if(!COLUMN_IS_VISIBLE(bPtr, i+1))
1055             {
1056                 scrollToColumn(bPtr, bPtr->firstVisibleColumn+1, True);
1057             }
1058             else
1059             {
1060                 scrollToColumn(bPtr, bPtr->firstVisibleColumn, True);
1061             }
1062
1063             loadColumn(bPtr, bPtr->usedColumnCount-1);
1064         }
1065         else
1066         {
1067             if (bPtr->usedColumnCount < bPtr->maxVisibleColumns)
1068                 i = 0;
1069             else
1070                 i = bPtr->usedColumnCount-bPtr->maxVisibleColumns;
1071
1072             scrollToColumn(bPtr, i, True);
1073             if (item->isBranch)
1074             {
1075                 loadColumn(bPtr, bPtr->usedColumnCount-1);
1076             }
1077         }
1078
1079         /* call callback for click */
1080         if (bPtr->action)
1081             (*bPtr->action)(bPtr, bPtr->clientData);
1082     }
1083
1084
1085
1086     oldItem = item;
1087 }
1088
1089
1090 static void
1091 listDoubleCallback(void *self, void *clientData)
1092 {
1093     FSBrowser *bPtr = (FSBrowser*)clientData;
1094     WMList *lPtr = (WMList*)self;
1095     WMListItem *item;
1096
1097     item = WMGetListSelectedItem(lPtr);
1098     if (!item)
1099         return;
1100
1101     /* call callback for double click */
1102     if (bPtr->doubleAction)
1103         (*bPtr->doubleAction)(bPtr, bPtr->doubleClientData);
1104 }
1105
1106
1107 void
1108 FSLoadBrowserColumnZero(FSBrowser *bPtr)
1109 {
1110     if (!bPtr->flags.loaded) {
1111         /* create column 0 */
1112         FSAddBrowserColumn(bPtr);
1113
1114         loadColumn(bPtr, 0);
1115
1116         /* make column 0 visible */
1117         scrollToColumn(bPtr, 0, True);
1118
1119         bPtr->flags.loaded = 1;
1120     }
1121     else
1122     {
1123         removeColumn(bPtr, 0);
1124         FSAddBrowserColumn(bPtr);
1125
1126         loadColumn(bPtr, 0);
1127         /* make column 0 visible */
1128         scrollToColumn(bPtr, 0, True);
1129     }
1130 }
1131
1132
1133 void
1134 FSRemoveBrowserItem(FSBrowser *bPtr, int column, int row)
1135 {
1136     WMList *list;
1137
1138     if (column < 0 || column >= bPtr->usedColumnCount)
1139         return;
1140
1141     list = FSGetBrowserListInColumn(bPtr, column);
1142
1143     if (row < 0 || row >= WMGetListNumberOfRows(list))
1144         return;
1145
1146     removeColumn(bPtr, column+1);
1147     if (bPtr->usedColumnCount < bPtr->maxVisibleColumns)
1148         scrollToColumn(bPtr, 0, True);
1149     else
1150         scrollToColumn(bPtr, bPtr->usedColumnCount-bPtr->maxVisibleColumns,
1151                        True);
1152
1153     WMRemoveListItem(list, row);
1154 }
1155
1156
1157 static void
1158 listSelectionObserver(void *observerData, WMNotification *notification)
1159 {
1160     FSBrowser *bPtr = (FSBrowser*)observerData;
1161     int column, item = (int)WMGetNotificationClientData(notification);
1162     WMList *lPtr = (WMList*)WMGetNotificationObject(notification);
1163
1164     for (column=0; column<bPtr->usedColumnCount; column++)
1165         if (bPtr->columns[column] == lPtr)
1166             break;
1167
1168     /* this can happen when a list is being cleared with WMClearList
1169      * after the column was removed */
1170     if (column >= bPtr->usedColumnCount) {
1171         return;
1172     }
1173
1174     if (item < 0)
1175         column--;
1176
1177     bPtr->selectedColumn = column;
1178 }
1179
1180
1181 int
1182 FSAddBrowserColumn(FSBrowser *bPtr)
1183 {
1184     WMList *list;
1185     WMList **clist;
1186     char **tlist;
1187     int colY;
1188     int index;
1189
1190     if (bPtr->usedColumnCount < bPtr->columnCount) {
1191         return bPtr->usedColumnCount++;
1192     }
1193
1194     bPtr->usedColumnCount++;
1195
1196     if (bPtr->flags.isTitled) {
1197         colY = TITLE_SPACING + bPtr->titleHeight;
1198     } else {
1199         colY = 0;
1200     }
1201
1202     index = bPtr->columnCount;
1203     bPtr->columnCount++;
1204     clist = wmalloc(sizeof(WMList*)*bPtr->columnCount);
1205     tlist = wmalloc(sizeof(char*)*bPtr->columnCount);
1206     memcpy(clist, bPtr->columns, sizeof(WMList*)*(bPtr->columnCount-1));
1207     memcpy(tlist, bPtr->titles, sizeof(char*)*(bPtr->columnCount-1));
1208     if (bPtr->columns)
1209         free(bPtr->columns);
1210     if (bPtr->titles)
1211         free(bPtr->titles);
1212     bPtr->columns = clist;
1213     bPtr->titles = tlist;
1214
1215     bPtr->titles[index] = NULL;
1216
1217     list = WMCreateList(bPtr);
1218     WMSetListAction(list, listCallback, bPtr);
1219     WMSetListDoubleAction(list, listDoubleCallback, bPtr);
1220     WMSetListUserDrawProc(list, paintItem);
1221     WMAddNotificationObserver(listSelectionObserver, bPtr,
1222                               WMListSelectionDidChangeNotification, list);
1223
1224     bPtr->columns[index] = list;
1225
1226     WMResizeWidget(list, bPtr->columnSize.width, bPtr->columnSize.height);
1227     WMMoveWidget(list, (bPtr->columnSize.width+COLUMN_SPACING)*index, colY);
1228     if (COLUMN_IS_VISIBLE(bPtr, index))
1229         WMMapWidget(list);
1230
1231     /* update the scroller */
1232     if (bPtr->columnCount > bPtr->maxVisibleColumns)
1233     {
1234         float value, proportion;
1235
1236         value = bPtr->firstVisibleColumn
1237             /(float)(bPtr->columnCount-bPtr->maxVisibleColumns);
1238         proportion = bPtr->maxVisibleColumns/(float)bPtr->columnCount;
1239         WMSetScrollerParameters(bPtr->scroller, value, proportion);
1240     }
1241
1242     return index;
1243 }
1244
1245
1246
1247 static void
1248 destroyBrowser(FSBrowser *bPtr)
1249 {
1250     int i;
1251
1252     for (i=0; i<bPtr->columnCount; i++) {
1253         if (bPtr->titles[i])
1254             free(bPtr->titles[i]);
1255     }
1256     free(bPtr->titles);
1257
1258     free(bPtr->pathSeparator);
1259
1260     WMRemoveNotificationObserver(bPtr);
1261
1262     free(bPtr);
1263 }
1264
1265
1266 static char*
1267 createTruncatedString(WMFont *font, char *text, int *textLen, int width)
1268 {
1269     int dLen = WMWidthOfString(font, ".", 1);
1270     char *textBuf = (char*)wmalloc((*textLen)+4);
1271
1272     if (width >= 3*dLen) {
1273         int dddLen = 3*dLen;
1274         int tmpTextLen = *textLen;
1275
1276         strcpy(textBuf, text);
1277         while (tmpTextLen
1278                && (WMWidthOfString(font, textBuf, tmpTextLen)+dddLen > width))
1279             tmpTextLen--;
1280         strcpy(textBuf+tmpTextLen, "...");
1281         *textLen = tmpTextLen+3;
1282     } else if (width >= 2*dLen) {
1283         strcpy(textBuf, "..");
1284         *textLen = 2;
1285     } else if (width >= dLen) {
1286         strcpy(textBuf, ".");
1287         *textLen = 1;
1288     } else {
1289         *textBuf = '\0';
1290         *textLen = 0;
1291     }
1292     return textBuf;
1293 }
1294
1295 void
1296 FSScrollBrowserToColumn(FSBrowser *bPtr, int column, Bool updateScroller)
1297 {
1298     scrollToColumn(bPtr, column, updateScroller);
1299 }
1300
1301 void FSSetBrowserDisplayFileCol(FSBrowser *bPtr, unsigned int display)
1302 {
1303     bPtr->flags.emptyCol = display;
1304 }