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