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