WINGs/wbrowser.c

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