WINGs/wbrowser.c

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