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* createTruncatedString(WMFont *font, char *text, int *textLen,
  88                                    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 void
 444 WMSortBrowserColumnWithComparer(WMBrowser *bPtr, int column,
 445                                 WMCompareDataProc *func)
 446 {
 447     WMSortListItemsWithComparer(bPtr->columns[column], func);
 448 }
 449
 450
 451
 452 WMListItem*
 453 WMInsertBrowserItem(WMBrowser *bPtr, int column, int row, char *text,
 454                     Bool isBranch)
 455 {
 456     WMListItem *item;
 457
 458     if (column < 0 || column >= bPtr->columnCount)
 459         return NULL;
 460
 461     item = WMInsertListItem(bPtr->columns[column], row, text);
 462     item->isBranch = isBranch;
 463
 464     return item;
 465 }
 466
 467
 468
 469
 470 static void
 471 willResizeBrowser(W_ViewDelegate *self, WMView *view,
 472                   unsigned int *width, unsigned int *height)
 473 {
 474     WMBrowser *bPtr = (WMBrowser*)view->self;
 475     int cols = bPtr->maxVisibleColumns;
 476     int colX, colY;
 477     int i;
 478
 479     assert(*width > 0);
 480     assert(*height > 0);
 481
 482     bPtr->columnSize.width = (*width-(cols-1)*COLUMN_SPACING) / cols;
 483     bPtr->columnSize.height = *height;
 484
 485     if (bPtr->flags.isTitled) {
 486         colY = TITLE_SPACING + bPtr->titleHeight;
 487         bPtr->columnSize.height -= colY;
 488     } else {
 489         colY = 0;
 490     }
 491
 492     if (bPtr->flags.hasScroller) {
 493         bPtr->columnSize.height -= SCROLLER_WIDTH + 4;
 494
 495         if (bPtr->scroller) {
 496             WMResizeWidget(bPtr->scroller, *width-2, 1);
 497             WMMoveWidget(bPtr->scroller, 1, *height-SCROLLER_WIDTH-1);
 498         }
 499     }
 500
 501     colX = 0;
 502     for (i = 0; i < bPtr->columnCount; i++) {
 503         WMResizeWidget(bPtr->columns[i], bPtr->columnSize.width,
 504                        bPtr->columnSize.height);
 505
 506         WMMoveWidget(bPtr->columns[i], colX, colY);
 507
 508         if (COLUMN_IS_VISIBLE(bPtr, i)) {
 509             colX += bPtr->columnSize.width+COLUMN_SPACING;
 510         }
 511     }
 512 }
 513
 514
 515 static void
 516 paintItem(WMList *lPtr, int index, Drawable d, char *text, int state,
 517           WMRect *rect)
 518 {
 519     WMView *view = W_VIEW(lPtr);
 520     W_Screen *scr = view->screen;
 521     int width, height, x, y;
 522
 523     width = rect->size.width;
 524     height = rect->size.height;
 525     x = rect->pos.x;
 526     y = rect->pos.y;
 527
 528     if (state & WLDSSelected)
 529         XFillRectangle(scr->display, d, WMColorGC(scr->white), x, y,
 530                        width, height);
 531     else
 532         XClearArea(scr->display, d, x, y, width, height, False);
 533
 534     if (text) {
 535         /* Avoid overlaping... */
 536         WMFont *font = (state & WLDSIsBranch) ? scr->boldFont : scr->normalFont;
 537         int textLen = strlen(text);
 538         int widthC = (state & WLDSIsBranch) ? width-20 : width-8;
 539         if (WMWidthOfString(font, text, textLen) > widthC) {
 540             char *textBuf = createTruncatedString(font, text, &textLen, widthC);
 541             W_PaintText(view, d, font,  x+4, y, widthC,
 542                         WALeft, WMColorGC(scr->black), False, textBuf, textLen);
 543             wfree(textBuf);
 544         } else {
 545             W_PaintText(view, d, font,  x+4, y, widthC,
 546                         WALeft, WMColorGC(scr->black), False, text, textLen);
 547         }
 548     }
 549
 550     if (state & WLDSIsBranch) {
 551         XDrawLine(scr->display, d, WMColorGC(scr->darkGray), x+width-11, y+3,
 552                   x+width-6, y+height/2);
 553         if (state & WLDSSelected)
 554             XDrawLine(scr->display, d,WMColorGC(scr->gray), x+width-11, y+height-5,
 555                       x+width-6, y+height/2);
 556         else
 557             XDrawLine(scr->display, d,WMColorGC(scr->white), x+width-11, y+height-5,
 558                       x+width-6, y+height/2);
 559         XDrawLine(scr->display, d, WMColorGC(scr->black), x+width-12, y+3,
 560                   x+width-12, y+height-5);
 561     }
 562 }
 563
 564
 565 static void
 566 scrollCallback(WMWidget *scroller, void *self)
 567 {
 568     WMBrowser *bPtr = (WMBrowser*)self;
 569     WMScroller *sPtr = (WMScroller*)scroller;
 570     int newFirst;
 571 #define LAST_VISIBLE_COLUMN  bPtr->firstVisibleColumn+bPtr->maxVisibleColumns
 572
 573     switch (WMGetScrollerHitPart(sPtr)) {
 574      case WSDecrementLine:
 575         if (bPtr->firstVisibleColumn > 0) {
 576             scrollToColumn(bPtr, bPtr->firstVisibleColumn-1, True);
 577         }
 578         break;
 579
 580      case WSDecrementPage:
 581         if (bPtr->firstVisibleColumn > 0) {
 582             newFirst = bPtr->firstVisibleColumn - bPtr->maxVisibleColumns;
 583
 584             scrollToColumn(bPtr, newFirst, True);
 585         }
 586         break;
 587
 588
 589      case WSIncrementLine:
 590         if (LAST_VISIBLE_COLUMN < bPtr->usedColumnCount) {
 591             scrollToColumn(bPtr, bPtr->firstVisibleColumn+1, True);
 592         }
 593         break;
 594
 595      case WSIncrementPage:
 596         if (LAST_VISIBLE_COLUMN < bPtr->usedColumnCount) {
 597             newFirst = bPtr->firstVisibleColumn + bPtr->maxVisibleColumns;
 598
 599             if (newFirst+bPtr->maxVisibleColumns >= bPtr->columnCount)
 600                 newFirst = bPtr->columnCount - bPtr->maxVisibleColumns;
 601
 602             scrollToColumn(bPtr, newFirst, True);
 603         }
 604         break;
 605
 606      case WSKnob:
 607         {
 608             double floatValue;
 609             double value = bPtr->columnCount - bPtr->maxVisibleColumns;
 610
 611             floatValue = WMGetScrollerValue(bPtr->scroller);
 612
 613             floatValue = (floatValue*value)/value;
 614
 615             newFirst = rint(floatValue*(float)(bPtr->columnCount - bPtr->maxVisibleColumns));
 616
 617             if (bPtr->firstVisibleColumn != newFirst)
 618                 scrollToColumn(bPtr, newFirst, False);
 619 /*          else
 620                 WMSetScrollerParameters(bPtr->scroller, floatValue,
 621                                         bPtr->maxVisibleColumns/(float)bPtr->columnCount);
 622  */
 623
 624         }
 625         break;
 626
 627      case WSKnobSlot:
 628      case WSNoPart:
 629         /* do nothing */
 630         break;
 631     }
 632 #undef LAST_VISIBLE_COLUMN
 633 }
 634
 635
 636 static void
 637 setupScroller(WMBrowser *bPtr)
 638 {
 639     WMScroller *sPtr;
 640     int y;
 641
 642     y = bPtr->view->size.height - SCROLLER_WIDTH - 1;
 643
 644     sPtr = WMCreateScroller(bPtr);
 645     WMSetScrollerAction(sPtr, scrollCallback, bPtr);
 646     WMMoveWidget(sPtr, 1, y);
 647     WMResizeWidget(sPtr, bPtr->view->size.width-2, SCROLLER_WIDTH);
 648
 649     bPtr->scroller = sPtr;
 650
 651     WMMapWidget(sPtr);
 652 }
 653
 654
 655 void
 656 WMSetBrowserAction(WMBrowser *bPtr, WMAction *action, void *clientData)
 657 {
 658     bPtr->action = action;
 659     bPtr->clientData = clientData;
 660 }
 661
 662
 663 void
 664 WMSetBrowserDoubleAction(WMBrowser *bPtr, WMAction *action, void *clientData)
 665 {
 666     bPtr->doubleAction = action;
 667     bPtr->doubleClientData = clientData;
 668 }
 669
 670
 671 void
 672 WMSetBrowserHasScroller(WMBrowser *bPtr, int hasScroller)
 673 {
 674     bPtr->flags.hasScroller = hasScroller;
 675 }
 676
 677
 678
 679 char*
 680 WMSetBrowserPath(WMBrowser *bPtr, char *path)
 681 {
 682     int i;
 683     char *str = wstrdup(path);
 684     char *tmp, *retPtr = NULL;
 685     int item;
 686     WMListItem *listItem;
 687
 688     /* WMLoadBrowserColumnZero must be call first */
 689     if (!bPtr->flags.loaded) {
 690         return False;
 691     }
 692
 693     removeColumn(bPtr, 1);
 694
 695     WMSelectListItem(bPtr->columns[0], -1);
 696     WMSetListPosition(bPtr->columns[0], 0);
 697
 698     i = 0;
 699     tmp = strtok(str, bPtr->pathSeparator);
 700     while (tmp) {
 701         /* select it in the column */
 702         item = WMFindRowOfListItemWithTitle(bPtr->columns[i], tmp);
 703         if (item<0) {
 704             retPtr = &path[(int)(tmp - str)];
 705             break;
 706         }
 707         WMSelectListItem(bPtr->columns[i], item);
 708         WMSetListPosition(bPtr->columns[i], item);
 709
 710         listItem = WMGetListItem(bPtr->columns[i], item);
 711         if (!listItem || !listItem->isBranch) {
 712             break;
 713         }
 714
 715         /* load next column */
 716         WMAddBrowserColumn(bPtr);
 717
 718         loadColumn(bPtr, i+1);
 719
 720         tmp = strtok(NULL, bPtr->pathSeparator);
 721
 722         i++;
 723     }
 724     wfree(str);
 725
 726     for (i = bPtr->usedColumnCount - 1;
 727          (i > -1) && !WMGetListSelectedItem(bPtr->columns[i]);
 728          i--);
 729
 730     bPtr->selectedColumn = i;
 731
 732     if (bPtr->columnCount < bPtr->maxVisibleColumns) {
 733         int i = bPtr->maxVisibleColumns - bPtr->columnCount;
 734         int curUsedColumnCount = bPtr->usedColumnCount;
 735         bPtr->usedColumnCount = bPtr->columnCount;
 736         while (i--) {
 737             WMAddBrowserColumn(bPtr);
 738         }
 739         bPtr->usedColumnCount = curUsedColumnCount;
 740     }
 741
 742     scrollToColumn(bPtr, bPtr->columnCount - bPtr->maxVisibleColumns, True);
 743
 744     return retPtr;
 745 }
 746
 747
 748 char*
 749 WMGetBrowserPath(WMBrowser *bPtr)
 750 {
 751     return WMGetBrowserPathToColumn(bPtr, bPtr->columnCount);
 752 }
 753
 754
 755
 756 char*
 757 WMGetBrowserPathToColumn(WMBrowser *bPtr, int column)
 758 {
 759     int i, size;
 760     char *path;
 761     WMListItem *item;
 762
 763     if (column >= bPtr->usedColumnCount)
 764         column = bPtr->usedColumnCount-1;
 765
 766     if (column < 0) {
 767         return wstrdup(bPtr->pathSeparator);
 768     }
 769
 770     /* calculate size of buffer */
 771     size = 0;
 772     for (i = 0; i <= column; i++) {
 773         item = WMGetListSelectedItem(bPtr->columns[i]);
 774         if (!item)
 775             break;
 776         size += strlen(item->text);
 777     }
 778
 779     /* get the path */
 780     path = wmalloc(size+(column+1)*strlen(bPtr->pathSeparator)+1);
 781     /* ignore first / */
 782     *path = 0;
 783     for (i = 0; i <= column; i++) {
 784         strcat(path, bPtr->pathSeparator);
 785         item = WMGetListSelectedItem(bPtr->columns[i]);
 786         if (!item)
 787             break;
 788         strcat(path, item->text);
 789     }
 790
 791     return path;
 792 }
 793
 794
 795 static void
 796 loadColumn(WMBrowser *bPtr, int column)
 797 {
 798     assert(bPtr->delegate);
 799     assert(bPtr->delegate->createRowsForColumn);
 800
 801     bPtr->flags.loadingColumn = 1;
 802     (*bPtr->delegate->createRowsForColumn)(bPtr->delegate, bPtr, column,
 803                                            bPtr->columns[column]);
 804     bPtr->flags.loadingColumn = 0;
 805
 806     if (bPtr->delegate->titleOfColumn) {
 807         char *title;
 808
 809         title = (*bPtr->delegate->titleOfColumn)(bPtr->delegate, bPtr, column);
 810
 811         if (bPtr->titles[column])
 812             wfree(bPtr->titles[column]);
 813
 814         bPtr->titles[column] = wstrdup(title);
 815
 816         if (COLUMN_IS_VISIBLE(bPtr, column) && bPtr->flags.isTitled) {
 817             drawTitleOfColumn(bPtr, column);
 818         }
 819     }
 820 }
 821
 822
 823 static void
 824 paintBrowser(WMBrowser *bPtr)
 825 {
 826     int i;
 827
 828     if (!bPtr->view->flags.mapped)
 829         return;
 830
 831     W_DrawRelief(bPtr->view->screen, bPtr->view->window, 0,
 832                  bPtr->view->size.height-SCROLLER_WIDTH-2,
 833                  bPtr->view->size.width, 22, WRSunken);
 834
 835     if (bPtr->flags.isTitled) {
 836         for (i=0; i<bPtr->maxVisibleColumns; i++) {
 837             drawTitleOfColumn(bPtr, i+bPtr->firstVisibleColumn);
 838         }
 839     }
 840 }
 841
 842
 843 static void
 844 handleEvents(XEvent *event, void *data)
 845 {
 846     WMBrowser *bPtr = (WMBrowser*)data;
 847
 848     CHECK_CLASS(data, WC_Browser);
 849
 850
 851     switch (event->type) {
 852      case Expose:
 853         paintBrowser(bPtr);
 854         break;
 855
 856      case DestroyNotify:
 857         destroyBrowser(bPtr);
 858         break;
 859
 860     }
 861 }
 862
 863
 864
 865 static void
 866 scrollToColumn(WMBrowser *bPtr, int column, Bool updateScroller)
 867 {
 868     int i;
 869     int x;
 870     int notify = 0;
 871
 872
 873     if (column != bPtr->firstVisibleColumn) {
 874         notify = 1;
 875     }
 876
 877     if (column < 0)
 878         column = 0;
 879
 880     if (notify && bPtr->delegate && bPtr->delegate->willScroll) {
 881         (*bPtr->delegate->willScroll)(bPtr->delegate, bPtr);
 882     }
 883
 884     x = 0;
 885     bPtr->firstVisibleColumn = column;
 886     for (i = 0; i < bPtr->columnCount; i++) {
 887         if (COLUMN_IS_VISIBLE(bPtr, i)) {
 888             WMMoveWidget(bPtr->columns[i], x,
 889                          WMWidgetView(bPtr->columns[i])->pos.y);
 890             if (!WMWidgetView(bPtr->columns[i])->flags.realized)
 891                 WMRealizeWidget(bPtr->columns[i]);
 892             WMMapWidget(bPtr->columns[i]);
 893             x += bPtr->columnSize.width + COLUMN_SPACING;
 894         } else {
 895             WMUnmapWidget(bPtr->columns[i]);
 896         }
 897     }
 898
 899     /* update the scroller */
 900     if (updateScroller) {
 901         if (bPtr->columnCount > bPtr->maxVisibleColumns) {
 902             float value, proportion;
 903
 904             value = bPtr->firstVisibleColumn
 905                 /(float)(bPtr->columnCount-bPtr->maxVisibleColumns);
 906             proportion = bPtr->maxVisibleColumns/(float)bPtr->columnCount;
 907             WMSetScrollerParameters(bPtr->scroller, value, proportion);
 908         } else {
 909             WMSetScrollerParameters(bPtr->scroller, 0, 1);
 910         }
 911     }
 912
 913     if (bPtr->view->flags.mapped)
 914         paintBrowser(bPtr);
 915
 916     if (notify && bPtr->delegate && bPtr->delegate->didScroll) {
 917         (*bPtr->delegate->didScroll)(bPtr->delegate, bPtr);
 918     }
 919 }
 920
 921
 922 static void
 923 listCallback(void *self, void *clientData)
 924 {
 925     WMBrowser *bPtr = (WMBrowser*)clientData;
 926     WMList *lPtr = (WMList*)self;
 927     WMListItem *item;
 928     static WMListItem *oldItem = NULL;
 929     int i;
 930
 931     item = WMGetListSelectedItem(lPtr);
 932     if (!item) {
 933         oldItem = item;
 934         return;
 935     }
 936
 937     if (oldItem != item) {
 938         for (i=0; i<bPtr->columnCount; i++) {
 939             if (lPtr == bPtr->columns[i])
 940                 break;
 941         }
 942         assert(i<bPtr->columnCount);
 943
 944         bPtr->selectedColumn = i;
 945
 946         /* columns at right must be cleared */
 947         removeColumn(bPtr, i+1);
 948         /* open directory */
 949         if (item->isBranch) {
 950             WMAddBrowserColumn(bPtr);
 951         }
 952         if (bPtr->usedColumnCount < bPtr->maxVisibleColumns)
 953             i = 0;
 954         else
 955             i = bPtr->usedColumnCount-bPtr->maxVisibleColumns;
 956         scrollToColumn(bPtr, i, True);
 957         if (item->isBranch) {
 958             loadColumn(bPtr, bPtr->usedColumnCount-1);
 959         }
 960     }
 961
 962
 963     /* call callback for click */
 964     if (bPtr->action)
 965         (*bPtr->action)(bPtr, bPtr->clientData);
 966
 967     oldItem = item;
 968 }
 969
 970
 971 static void
 972 listDoubleCallback(void *self, void *clientData)
 973 {
 974     WMBrowser *bPtr = (WMBrowser*)clientData;
 975     WMList *lPtr = (WMList*)self;
 976     WMListItem *item;
 977
 978     item = WMGetListSelectedItem(lPtr);
 979     if (!item)
 980         return;
 981
 982     /* call callback for double click */
 983     if (bPtr->doubleAction)
 984         (*bPtr->doubleAction)(bPtr, bPtr->doubleClientData);
 985 }
 986
 987
 988 void
 989 WMLoadBrowserColumnZero(WMBrowser *bPtr)
 990 {
 991     if (!bPtr->flags.loaded) {
 992         /* create column 0 */
 993         WMAddBrowserColumn(bPtr);
 994
 995         loadColumn(bPtr, 0);
 996
 997         /* make column 0 visible */
 998         scrollToColumn(bPtr, 0, True);
 999
1000         bPtr->flags.loaded = 1;
1001     }
1002 }
1003
1004
1005 void
1006 WMRemoveBrowserItem(WMBrowser *bPtr, int column, int row)
1007 {
1008     WMList *list;
1009
1010     if (column < 0 || column >= bPtr->usedColumnCount)
1011         return;
1012
1013     list = WMGetBrowserListInColumn(bPtr, column);
1014
1015     if (row < 0 || row >= WMGetListNumberOfRows(list))
1016         return;
1017
1018     removeColumn(bPtr, column+1);
1019     if (bPtr->usedColumnCount < bPtr->maxVisibleColumns)
1020         scrollToColumn(bPtr, 0, True);
1021     else
1022         scrollToColumn(bPtr, bPtr->usedColumnCount-bPtr->maxVisibleColumns,
1023                        True);
1024
1025     WMRemoveListItem(list, row);
1026 }
1027
1028
1029 static void
1030 listSelectionObserver(void *observerData, WMNotification *notification)
1031 {
1032     WMBrowser *bPtr = (WMBrowser*)observerData;
1033     int column;
1034     WMList *lPtr = (WMList*)WMGetNotificationObject(notification);
1035
1036     for (column = 0; column < bPtr->usedColumnCount; column++)
1037         if (bPtr->columns[column] == lPtr)
1038             break;
1039
1040     /* this can happen when a list is being cleared with WMClearList
1041      * after the column was removed */
1042     if (column >= bPtr->usedColumnCount) {
1043         return;
1044     }
1045
1046     if (WMGetArrayItemCount(WMGetListSelectedItems(lPtr)) == 0)
1047         column--;
1048
1049     bPtr->selectedColumn = column;
1050 }
1051
1052
1053 int
1054 WMAddBrowserColumn(WMBrowser *bPtr)
1055 {
1056     WMList *list;
1057     WMList **clist;
1058     char **tlist;
1059     int colY;
1060     int index;
1061
1062
1063     if (bPtr->usedColumnCount < bPtr->columnCount) {
1064         return bPtr->usedColumnCount++;
1065     }
1066
1067     bPtr->usedColumnCount++;
1068
1069     if (bPtr->flags.isTitled) {
1070         colY = TITLE_SPACING + bPtr->titleHeight;
1071     } else {
1072         colY = 0;
1073     }
1074
1075     index = bPtr->columnCount;
1076     bPtr->columnCount++;
1077     clist = wmalloc(sizeof(WMList*)*bPtr->columnCount);
1078     tlist = wmalloc(sizeof(char*)*bPtr->columnCount);
1079     memcpy(clist, bPtr->columns, sizeof(WMList*)*(bPtr->columnCount-1));
1080     memcpy(tlist, bPtr->titles, sizeof(char*)*(bPtr->columnCount-1));
1081     if (bPtr->columns)
1082         wfree(bPtr->columns);
1083     if (bPtr->titles)
1084         wfree(bPtr->titles);
1085     bPtr->columns = clist;
1086     bPtr->titles = tlist;
1087
1088     bPtr->titles[index] = NULL;
1089
1090     list = WMCreateList(bPtr);
1091     WMSetListAction(list, listCallback, bPtr);
1092     WMSetListDoubleAction(list, listDoubleCallback, bPtr);
1093     WMSetListUserDrawProc(list, paintItem);
1094     WMAddNotificationObserver(listSelectionObserver, bPtr,
1095                               WMListSelectionDidChangeNotification, list);
1096
1097     bPtr->columns[index] = list;
1098
1099     WMResizeWidget(list, bPtr->columnSize.width, bPtr->columnSize.height);
1100     WMMoveWidget(list, (bPtr->columnSize.width+COLUMN_SPACING)*index, colY);
1101     if (COLUMN_IS_VISIBLE(bPtr, index))
1102         WMMapWidget(list);
1103
1104     /* update the scroller */
1105     if (bPtr->columnCount > bPtr->maxVisibleColumns) {
1106         float value, proportion;
1107
1108         value = bPtr->firstVisibleColumn
1109             /(float)(bPtr->columnCount-bPtr->maxVisibleColumns);
1110         proportion = bPtr->maxVisibleColumns/(float)bPtr->columnCount;
1111         WMSetScrollerParameters(bPtr->scroller, value, proportion);
1112     }
1113
1114     return index;
1115 }
1116
1117
1118
1119 static void
1120 destroyBrowser(WMBrowser *bPtr)
1121 {
1122     int i;
1123
1124     for (i = 0; i < bPtr->columnCount; i++) {
1125         if (bPtr->titles[i])
1126             wfree(bPtr->titles[i]);
1127     }
1128     wfree(bPtr->titles);
1129
1130     wfree(bPtr->pathSeparator);
1131
1132     WMRemoveNotificationObserver(bPtr);
1133
1134     wfree(bPtr);
1135 }
1136
1137
1138 static char*
1139 createTruncatedString(WMFont *font, char *text, int *textLen, int width)
1140 {
1141     int dLen = WMWidthOfString(font, ".", 1);
1142     char *textBuf = (char*)wmalloc((*textLen)+4);
1143
1144     if (width >= 3*dLen) {
1145         int dddLen = 3*dLen;
1146         int tmpTextLen = *textLen;
1147
1148         strcpy(textBuf, text);
1149         while (tmpTextLen
1150                && (WMWidthOfString(font, textBuf, tmpTextLen)+dddLen > width))
1151             tmpTextLen--;
1152         strcpy(textBuf+tmpTextLen, "...");
1153         *textLen = tmpTextLen+3;
1154     } else if (width >= 2*dLen) {
1155         strcpy(textBuf, "..");
1156         *textLen = 2;
1157     } else if (width >= dLen) {
1158         strcpy(textBuf, ".");
1159         *textLen = 1;
1160     } else {
1161         *textBuf = '\0';
1162         *textLen = 0;
1163     }
1164     return textBuf;
1165 }