WINGs/wlist.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 char *WMListDidScrollNotification = "WMListDidScrollNotification";
   8 char *WMListSelectionDidChangeNotification = "WMListSelectionDidChangeNotification";
   9
  10 typedef struct W_List {
  11     W_Class widgetClass;
  12     W_View *view;
  13
  14     WMArray *items;         /* list of WMListItem */
  15     WMArray *selectedItems; /* list of selected WMListItems */
  16
  17     //short selectedItem;
  18
  19     short itemHeight;
  20
  21     short topItem;          /* index of first visible item */
  22
  23     short fullFitLines;     /* no of lines that fit entirely */
  24
  25     void *clientData;
  26     WMAction *action;
  27     void *doubleClientData;
  28     WMAction *doubleAction;
  29
  30     WMListDrawProc *draw;
  31
  32     WMHandlerID *idleID;    /* for updating the scroller after adding elements */
  33
  34     WMScroller *vScroller;
  35
  36     struct {
  37         unsigned int allowMultipleSelection:1;
  38         unsigned int allowEmptySelection:1;
  39         unsigned int userDrawn:1;
  40         unsigned int userItemHeight:1;
  41         unsigned int dontFitAll:1;     /* 1 = last item won't be fully visible */
  42         unsigned int redrawPending:1;
  43         unsigned int buttonPressed:1;
  44         unsigned int buttonWasPressed:1;
  45     } flags;
  46 } List;
  47
  48
  49
  50 #define DEFAULT_WIDTH   150
  51 #define DEFAULT_HEIGHT  150
  52
  53
  54 static void destroyList(List *lPtr);
  55 static void paintList(List *lPtr);
  56
  57
  58 static void handleEvents(XEvent *event, void *data);
  59 static void handleActionEvents(XEvent *event, void *data);
  60 static void updateScroller(List *lPtr);
  61
  62 static void vScrollCallBack(WMWidget *scroller, void *self);
  63
  64 static void updateGeometry(WMList *lPtr);
  65 static void didResizeList();
  66
  67
  68 W_ViewDelegate _ListViewDelegate = {
  69     NULL,
  70     NULL,
  71     didResizeList,
  72     NULL,
  73     NULL
  74 };
  75
  76
  77 static void
  78 releaseItem(void *data)
  79 {
  80     WMListItem *item = (WMListItem*)data;
  81
  82     if (item->text)
  83         wfree(item->text);
  84     wfree(item);
  85 }
  86
  87
  88 WMList*
  89 WMCreateList(WMWidget *parent)
  90 {
  91     List *lPtr;
  92     W_Screen *scrPtr = W_VIEW(parent)->screen;
  93
  94     lPtr = wmalloc(sizeof(List));
  95     memset(lPtr, 0, sizeof(List));
  96
  97     lPtr->widgetClass = WC_List;
  98
  99     lPtr->view = W_CreateView(W_VIEW(parent));
 100     if (!lPtr->view) {
 101         wfree(lPtr);
 102         return NULL;
 103     }
 104     lPtr->view->self = lPtr;
 105
 106     lPtr->view->delegate = &_ListViewDelegate;
 107
 108     WMCreateEventHandler(lPtr->view, ExposureMask|StructureNotifyMask
 109                          |ClientMessageMask, handleEvents, lPtr);
 110
 111     WMCreateEventHandler(lPtr->view, ButtonPressMask|ButtonReleaseMask
 112                          |EnterWindowMask|LeaveWindowMask|ButtonMotionMask,
 113                          handleActionEvents, lPtr);
 114
 115     lPtr->itemHeight = WMFontHeight(scrPtr->normalFont) + 1;
 116
 117     lPtr->items = WMCreateArrayWithDestructor(4, releaseItem);
 118     lPtr->selectedItems = WMCreateArray(4);
 119
 120     /* create the vertical scroller */
 121     lPtr->vScroller = WMCreateScroller(lPtr);
 122     WMMoveWidget(lPtr->vScroller, 1, 1);
 123     WMSetScrollerArrowsPosition(lPtr->vScroller, WSAMaxEnd);
 124
 125     WMSetScrollerAction(lPtr->vScroller, vScrollCallBack, lPtr);
 126
 127     /* make the scroller map itself when it's realized */
 128     WMMapWidget(lPtr->vScroller);
 129
 130     W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 131
 132     //lPtr->selectedItem = -1;
 133
 134     return lPtr;
 135 }
 136
 137
 138 void
 139 WMSetListAllowMultipleSelection(WMList *lPtr, Bool flag)
 140 {
 141     lPtr->flags.allowMultipleSelection = flag ? 1 : 0;
 142
 143 }
 144
 145
 146 void
 147 WMSetListAllowEmptySelection(WMList *lPtr, Bool flag)
 148 {
 149     lPtr->flags.allowEmptySelection = flag ? 1 : 0;
 150 }
 151
 152
 153 static int
 154 comparator(const void *a, const void *b)
 155 {
 156     return (strcmp((*(WMListItem**)a)->text, (*(WMListItem**)b)->text));
 157 }
 158
 159
 160 void
 161 WMSortListItems(WMList *lPtr)
 162 {
 163     WMSortArray(lPtr->items, comparator);
 164
 165     paintList(lPtr);
 166 }
 167
 168
 169
 170 void
 171 WMSortListItemsWithComparer(WMList *lPtr, WMCompareDataProc *func)
 172 {
 173     WMSortArray(lPtr->items, func);
 174
 175     paintList(lPtr);
 176 }
 177
 178
 179
 180 WMListItem*
 181 WMInsertListItem(WMList *lPtr, int row, char *text)
 182 {
 183     WMListItem *item;
 184
 185     CHECK_CLASS(lPtr, WC_List);
 186
 187     item = wmalloc(sizeof(WMListItem));
 188     memset(item, 0, sizeof(WMListItem));
 189     item->text = wstrdup(text);
 190
 191
 192     //if (lPtr->selectedItem >= row && lPtr->selectedItem >= 0
 193     //    && row >= 0)
 194     //    lPtr->selectedItem++;
 195
 196     row = WMIN(row, WMGetArrayItemCount(lPtr->items));
 197
 198     if (row < 0)
 199         WMAddToArray(lPtr->items, item);
 200     else
 201         WMInsertInArray(lPtr->items, row, item);
 202
 203     /* update the scroller when idle, so that we don't waste time
 204      * updating it when another item is going to be added later */
 205     if (!lPtr->idleID) {
 206         lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
 207     }
 208
 209     return item;
 210 }
 211
 212
 213 int
 214 WMRemoveListItem(WMList *lPtr, int row)
 215 {
 216     WMListItem *item;
 217     int topItem = lPtr->topItem;
 218     int selNotify = 0;
 219
 220     CHECK_CLASS(lPtr, WC_List);
 221
 222     if (row < 0 || row >= WMGetArrayItemCount(lPtr->items))
 223         return 0;
 224
 225     item = WMGetFromArray(lPtr->items, row);
 226     if (item->selected) {
 227         WMRemoveFromArray(lPtr->selectedItems, item);
 228         //WMUnselectListItem(lPtr, row);
 229         selNotify = 1;
 230     }
 231
 232     //if (lPtr->selectedItem == row) {
 233     //    lPtr->selectedItem = -1;
 234     //    selNotify = 1;
 235     //} else if (lPtr->selectedItem > row) {
 236     //    lPtr->selectedItem--;
 237     //}
 238
 239     if (row <= lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll)
 240         lPtr->topItem--;
 241     if (lPtr->topItem < 0)
 242         lPtr->topItem = 0;
 243
 244     WMDeleteFromArray(lPtr->items, row);
 245
 246     if (!lPtr->idleID) {
 247         lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
 248     }
 249     if (lPtr->topItem != topItem) {
 250         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 251     }
 252     if (selNotify) {
 253         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 254     }
 255
 256     return 1;
 257 }
 258
 259
 260 WMListItem*
 261 WMGetListItem(WMList *lPtr, int row)
 262 {
 263     return WMGetFromArray(lPtr->items, row);
 264 }
 265
 266
 267 WMArray*
 268 WMGetListItems(WMList *lPtr)
 269 {
 270     return lPtr->items;
 271 }
 272
 273
 274 void
 275 WMSetListUserDrawProc(WMList *lPtr, WMListDrawProc *proc)
 276 {
 277     lPtr->flags.userDrawn = 1;
 278     lPtr->draw = proc;
 279 }
 280
 281
 282 void
 283 WMSetListUserDrawItemHeight(WMList *lPtr, unsigned short height)
 284 {
 285     assert(height > 0);
 286
 287     lPtr->flags.userItemHeight = 1;
 288     lPtr->itemHeight = height;
 289
 290     updateGeometry(lPtr);
 291 }
 292
 293
 294 void
 295 WMClearList(WMList *lPtr)
 296 {
 297     int selNo = WMGetArrayItemCount(lPtr->selectedItems);
 298
 299     WMEmptyArray(lPtr->selectedItems);
 300     WMEmptyArray(lPtr->items);
 301
 302     lPtr->topItem = 0;
 303     //lPtr->selectedItem = -1;
 304
 305     if (!lPtr->idleID) {
 306         WMDeleteIdleHandler(lPtr->idleID);
 307         lPtr->idleID = NULL;
 308     }
 309     if (lPtr->view->flags.realized) {
 310         updateScroller(lPtr);
 311     }
 312     if (selNo > 0) {
 313         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 314     }
 315 }
 316
 317
 318 void
 319 WMSetListAction(WMList *lPtr, WMAction *action, void *clientData)
 320 {
 321     lPtr->action = action;
 322     lPtr->clientData = clientData;
 323 }
 324
 325
 326 void
 327 WMSetListDoubleAction(WMList *lPtr, WMAction *action, void *clientData)
 328 {
 329     lPtr->doubleAction = action;
 330     lPtr->doubleClientData = clientData;
 331 }
 332
 333
 334 WMArray*
 335 WMGetListSelectedItems(WMList *lPtr)
 336 {
 337     return lPtr->selectedItems;
 338 }
 339
 340
 341 WMListItem*
 342 WMGetListSelectedItem(WMList *lPtr)
 343 {
 344     return WMGetFromArray(lPtr->selectedItems, 0);
 345 }
 346
 347
 348 int
 349 WMGetListSelectedItemRow(WMList *lPtr)
 350 {
 351     WMListItem *item = WMGetFromArray(lPtr->selectedItems, 0);
 352
 353     return (item!=NULL ? WMGetFirstInArray(lPtr->items, item) : WLNotFound);
 354 }
 355
 356
 357 int
 358 WMGetListItemHeight(WMList *lPtr)
 359 {
 360     return lPtr->itemHeight;
 361 }
 362
 363
 364 void
 365 WMSetListPosition(WMList *lPtr, int row)
 366 {
 367     lPtr->topItem = row;
 368     if (lPtr->topItem + lPtr->fullFitLines > WMGetArrayItemCount(lPtr->items))
 369         lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
 370
 371     if (lPtr->topItem < 0)
 372         lPtr->topItem = 0;
 373
 374     if (lPtr->view->flags.realized)
 375         updateScroller(lPtr);
 376 }
 377
 378
 379 void
 380 WMSetListBottomPosition(WMList *lPtr, int row)
 381 {
 382     if (WMGetArrayItemCount(lPtr->items) > lPtr->fullFitLines) {
 383         lPtr->topItem = row - lPtr->fullFitLines;
 384         if (lPtr->topItem < 0)
 385             lPtr->topItem = 0;
 386         if (lPtr->view->flags.realized)
 387             updateScroller(lPtr);
 388     }
 389 }
 390
 391
 392 int
 393 WMGetListNumberOfRows(WMList *lPtr)
 394 {
 395     return WMGetArrayItemCount(lPtr->items);
 396 }
 397
 398
 399 int
 400 WMGetListPosition(WMList *lPtr)
 401 {
 402     return lPtr->topItem;
 403 }
 404
 405
 406 Bool
 407 WMListAllowsMultipleSelection(WMList *lPtr)
 408 {
 409     return lPtr->flags.allowMultipleSelection;
 410 }
 411
 412
 413 Bool
 414 WMListAllowsEmptySelection(WMList *lPtr)
 415 {
 416     return lPtr->flags.allowEmptySelection;
 417 }
 418
 419
 420 static void
 421 scrollByAmount(WMList *lPtr, int amount)
 422 {
 423     int itemCount = WMGetArrayItemCount(lPtr->items);
 424
 425     if ((amount < 0 && lPtr->topItem > 0) ||
 426         (amount > 0 && (lPtr->topItem + lPtr->fullFitLines < itemCount))) {
 427
 428         lPtr->topItem += amount;
 429         if (lPtr->topItem < 0)
 430             lPtr->topItem = 0;
 431         if (lPtr->topItem + lPtr->fullFitLines > itemCount)
 432             lPtr->topItem = itemCount - lPtr->fullFitLines;
 433
 434         updateScroller(lPtr);
 435     }
 436 }
 437
 438
 439 static void
 440 vScrollCallBack(WMWidget *scroller, void *self)
 441 {
 442     WMList *lPtr = (WMList*)self;
 443     int height;
 444     int oldTopItem = lPtr->topItem;
 445     int itemCount = WMGetArrayItemCount(lPtr->items);
 446
 447     height = lPtr->view->size.height - 4;
 448
 449     switch (WMGetScrollerHitPart((WMScroller*)scroller)) {
 450     case WSDecrementLine:
 451         //if (lPtr->topItem > 0) {
 452         //    lPtr->topItem--;
 453         //
 454         //    updateScroller(lPtr);
 455         //}
 456         scrollByAmount(lPtr, -1);
 457         break;
 458
 459     case WSIncrementLine:
 460         //if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
 461         //    lPtr->topItem++;
 462         //
 463         //    updateScroller(lPtr);
 464         //}
 465         scrollByAmount(lPtr, 1);
 466         break;
 467
 468     case WSDecrementPage:
 469         //if (lPtr->topItem > 0) {
 470         //    lPtr->topItem -= lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 471         //    if (lPtr->topItem < 0)
 472         //        lPtr->topItem = 0;
 473         //
 474         //    updateScroller(lPtr);
 475         //}
 476         scrollByAmount(lPtr, -lPtr->fullFitLines+(1-lPtr->flags.dontFitAll)+1);
 477         break;
 478
 479     case WSIncrementPage:
 480         //if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
 481         //    lPtr->topItem += lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 482         //
 483         //    if (lPtr->topItem + lPtr->fullFitLines > itemCount)
 484         //        lPtr->topItem = itemCount - lPtr->fullFitLines;
 485         //
 486         //    updateScroller(lPtr);
 487         //}
 488         scrollByAmount(lPtr, lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1);
 489         break;
 490
 491     case WSKnob:
 492         lPtr->topItem = WMGetScrollerValue(lPtr->vScroller) *
 493             (float)(itemCount - lPtr->fullFitLines);
 494
 495         if (oldTopItem != lPtr->topItem)
 496             paintList(lPtr); // use updateScroller(lPtr) here?
 497         break;
 498
 499     case WSKnobSlot:
 500     case WSNoPart:
 501     default:
 502         /* do nothing */
 503         break;
 504     }
 505
 506     if (lPtr->topItem != oldTopItem)
 507         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 508 }
 509
 510
 511 static void
 512 paintItem(List *lPtr, int index)
 513 {
 514     WMView *view = lPtr->view;
 515     W_Screen *scr = view->screen;
 516     int width, height, x, y;
 517     WMListItem *itemPtr;
 518
 519     itemPtr = WMGetFromArray(lPtr->items, index);
 520
 521     width = lPtr->view->size.width - 2 - 19;
 522     height = lPtr->itemHeight;
 523     x = 19;
 524     y = 2 + (index-lPtr->topItem) * lPtr->itemHeight + 1;
 525
 526     if (lPtr->flags.userDrawn) {
 527         WMRect rect;
 528         int flags;
 529
 530         rect.size.width = width;
 531         rect.size.height = height;
 532         rect.pos.x = x;
 533         rect.pos.y = y;
 534
 535         flags = itemPtr->uflags;
 536         if (itemPtr->disabled)
 537             flags |= WLDSDisabled;
 538         if (itemPtr->selected)
 539             flags |= WLDSSelected;
 540         if (itemPtr->isBranch)
 541             flags |= WLDSIsBranch;
 542
 543         if (lPtr->draw)
 544             (*lPtr->draw)(lPtr, index, view->window, itemPtr->text, flags,
 545                           &rect);
 546     } else {
 547         if (itemPtr->selected) {
 548             XFillRectangle(scr->display, view->window, WMColorGC(scr->white),
 549                            x, y, width, height);
 550         } else {
 551             XClearArea(scr->display, view->window, x, y, width, height, False);
 552         }
 553
 554         W_PaintText(view, view->window, scr->normalFont,  x+4, y, width,
 555                     WALeft, WMColorGC(scr->black), False,
 556                     itemPtr->text, strlen(itemPtr->text));
 557     }
 558 }
 559
 560
 561
 562 static void
 563 paintList(List *lPtr)
 564 {
 565     W_Screen *scrPtr = lPtr->view->screen;
 566     int i, lim;
 567
 568     if (!lPtr->view->flags.mapped)
 569         return;
 570
 571     if (WMGetArrayItemCount(lPtr->items) > 0) {
 572         if (lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll
 573             > WMGetArrayItemCount(lPtr->items)) {
 574
 575             lim = WMGetArrayItemCount(lPtr->items) - lPtr->topItem;
 576             XClearArea(scrPtr->display, lPtr->view->window, 19,
 577                        2+lim*lPtr->itemHeight, lPtr->view->size.width-21,
 578                        lPtr->view->size.height-lim*lPtr->itemHeight-3, False);
 579         } else {
 580             lim = lPtr->fullFitLines + lPtr->flags.dontFitAll;
 581         }
 582         for (i = lPtr->topItem; i < lPtr->topItem + lim; i++) {
 583             paintItem(lPtr, i);
 584         }
 585     } else {
 586         XClearWindow(scrPtr->display, lPtr->view->window);
 587     }
 588     W_DrawRelief(scrPtr, lPtr->view->window, 0, 0, lPtr->view->size.width,
 589                  lPtr->view->size.height, WRSunken);
 590 }
 591
 592 #if 0
 593 static void
 594 scrollTo(List *lPtr, int newTop)
 595 {
 596
 597 }
 598 #endif
 599
 600 static void
 601 updateScroller(List *lPtr)
 602 {
 603     float knobProportion, floatValue, tmp;
 604     int count = WMGetArrayItemCount(lPtr->items);
 605
 606     if (lPtr->idleID)
 607         WMDeleteIdleHandler(lPtr->idleID);
 608     lPtr->idleID = NULL;
 609
 610     paintList(lPtr);
 611
 612     if (count == 0 || count <= lPtr->fullFitLines)
 613         WMSetScrollerParameters(lPtr->vScroller, 0, 1);
 614     else {
 615         tmp = lPtr->fullFitLines;
 616         knobProportion = tmp/(float)count;
 617
 618         floatValue = (float)lPtr->topItem/(float)(count - lPtr->fullFitLines);
 619
 620         WMSetScrollerParameters(lPtr->vScroller, floatValue, knobProportion);
 621     }
 622 }
 623
 624
 625 static void
 626 handleEvents(XEvent *event, void *data)
 627 {
 628     List *lPtr = (List*)data;
 629
 630     CHECK_CLASS(data, WC_List);
 631
 632
 633     switch (event->type) {
 634     case Expose:
 635         if (event->xexpose.count!=0)
 636             break;
 637         paintList(lPtr);
 638         break;
 639
 640     case DestroyNotify:
 641         destroyList(lPtr);
 642         break;
 643
 644     }
 645 }
 646
 647
 648 static int
 649 matchTitle(void *item, void *title)
 650 {
 651     return (strcmp(((WMListItem*)item)->text, (char*)title)==0 ? 1 : 0);
 652 }
 653
 654
 655 int
 656 WMFindRowOfListItemWithTitle(WMList *lPtr, char *title)
 657 {
 658     return WMFindInArray(lPtr->items, matchTitle, title);
 659 }
 660
 661
 662 void
 663 WMSelectListItem(WMList *lPtr, int row)
 664 {
 665     WMListItem *item, *oldSelected;
 666
 667     if (row >= WMGetArrayItemCount(lPtr->items))
 668         return;
 669     if (row < 0) {
 670         /* Should row = -1 deselect all or just do nothing ?. Check it. -Dan */
 671         if (!lPtr->flags.allowMultipleSelection) {
 672             WMUnselectAllListItems(lPtr);
 673         }
 674         return;
 675     }
 676
 677     item = WMGetFromArray(lPtr->items, row);
 678     if (item->selected)
 679         return;         /* Return if already selected */
 680
 681     oldSelected = WMGetFromArray(lPtr->selectedItems, 0);
 682
 683     /* unselect previous selected item if case */
 684     if (!lPtr->flags.allowMultipleSelection && oldSelected) {
 685         int oldSelectedRow = WMGetListSelectedItemRow(lPtr);
 686
 687         // better call WMUnselectAllListItems() here? -Dan
 688         oldSelected->selected = 0;
 689         WMDeleteFromArray(lPtr->selectedItems, 0);
 690         // This is faster and have the same effect in the single selected case
 691         // but may leave xxx->selected flags set after a multi->single selected
 692         // switch
 693         //WMEmptyArray(lPtr->selectedItems);
 694
 695         if (lPtr->view->flags.mapped && oldSelectedRow>=lPtr->topItem
 696             && oldSelectedRow<=lPtr->topItem+lPtr->fullFitLines) {
 697             paintItem(lPtr, oldSelectedRow);
 698         }
 699     }
 700
 701     /* select item */
 702     item->selected = 1;
 703     WMAddToArray(lPtr->selectedItems, item);
 704
 705     if (lPtr->view->flags.mapped) {
 706         paintItem(lPtr, row);
 707
 708         if ((row-lPtr->topItem+lPtr->fullFitLines)*lPtr->itemHeight
 709             > lPtr->view->size.height-2)
 710             W_DrawRelief(lPtr->view->screen, lPtr->view->window, 0, 0,
 711                          lPtr->view->size.width, lPtr->view->size.height,
 712                          WRSunken);
 713     }
 714     //lPtr->selectedItem = row;
 715
 716     WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 717 }
 718
 719
 720 static int
 721 getItemIndexAt(List *lPtr, int clickY)
 722 {
 723     int index;
 724
 725     index = (clickY - 2) / lPtr->itemHeight + lPtr->topItem;
 726
 727     if (index < 0 || index >= WMGetArrayItemCount(lPtr->items))
 728         return -1;
 729
 730     return index;
 731 }
 732
 733
 734 static void
 735 handleActionEvents(XEvent *event, void *data)
 736 {
 737     List *lPtr = (List*)data;
 738     int tmp;
 739     int topItem = lPtr->topItem;
 740
 741     CHECK_CLASS(data, WC_List);
 742
 743     switch (event->type) {
 744     case ButtonRelease:
 745 #define CHECK_WHEEL_PATCH
 746 #ifdef CHECK_WHEEL_PATCH
 747         /* Ignore mouse wheel events, they're not "real" button events */
 748         if (event->xbutton.button == WINGsConfiguration.mouseWheelUp ||
 749             event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
 750             break;
 751         }
 752 #endif
 753
 754         lPtr->flags.buttonPressed = 0;
 755         tmp = getItemIndexAt(lPtr, event->xbutton.y);
 756
 757         if (tmp == lPtr->selectedItem && tmp >= 0) {
 758             if (lPtr->action)
 759                 (*lPtr->action)(lPtr, lPtr->clientData);
 760         }
 761         break;
 762
 763     case EnterNotify:
 764         lPtr->flags.buttonPressed = lPtr->flags.buttonWasPressed;
 765         lPtr->flags.buttonWasPressed = 0;
 766         break;
 767
 768     case LeaveNotify:
 769         lPtr->flags.buttonWasPressed = lPtr->flags.buttonPressed;
 770         lPtr->flags.buttonPressed = 0;
 771         break;
 772
 773     case ButtonPress:
 774         if (event->xbutton.x > WMWidgetWidth(lPtr->vScroller)) {
 775 #ifdef CHECK_WHEEL_PATCH
 776             int amount = 0;
 777
 778             // join them
 779             if (event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
 780                 /* Wheel down */
 781                 /*int itemCount = WMGetArrayItemCount(lPtr->items);
 782                 if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
 783                     int incr = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 784                     lPtr->topItem += incr;
 785
 786                     if (lPtr->topItem + lPtr->fullFitLines > itemCount)
 787                         lPtr->topItem = itemCount - lPtr->fullFitLines;
 788
 789                     updateScroller(lPtr);
 790                 }*/
 791                 if (event->xbutton.state & ShiftMask) {
 792                     amount = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 793                 } else if (event->xbutton.state & ControlMask) {
 794                     amount = 1;
 795                 } else {
 796                     amount = lPtr->fullFitLines / 3;
 797                     if (amount == 0)
 798                         amount++;
 799                 }
 800
 801                 scrollByAmount(lPtr, amount);
 802                 break;
 803             }
 804
 805             if (event->xbutton.button == WINGsConfiguration.mouseWheelUp) {
 806                 /* Wheel up */
 807                 /*if (lPtr->topItem > 0) {
 808                     int decr = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 809                     lPtr->topItem -= decr;
 810
 811                     if (lPtr->topItem < 0)
 812                         lPtr->topItem = 0;
 813
 814                     updateScroller(lPtr);
 815                 }*/
 816                 if (event->xbutton.state & ShiftMask) {
 817                     amount = -lPtr->fullFitLines+(1-lPtr->flags.dontFitAll)+1;
 818                 } else if (event->xbutton.state & ControlMask) {
 819                     amount = -1;
 820                 } else {
 821                     amount = -(lPtr->fullFitLines / 3);
 822                     if (amount == 0)
 823                         amount--;
 824                 }
 825
 826                 scrollByAmount(lPtr, amount);
 827                 break;
 828             }
 829 #endif
 830
 831             tmp = getItemIndexAt(lPtr, event->xbutton.y);
 832             lPtr->flags.buttonPressed = 1;
 833
 834             if (tmp >= 0) {
 835                 if (tmp == lPtr->selectedItem && WMIsDoubleClick(event)) {
 836                     WMSelectListItem(lPtr, tmp);
 837                     if (lPtr->doubleAction)
 838                         (*lPtr->doubleAction)(lPtr, lPtr->doubleClientData);
 839                 } else {
 840                     WMSelectListItem(lPtr, tmp);
 841                 }
 842             }
 843         }
 844         break;
 845
 846     case MotionNotify:
 847         if (lPtr->flags.buttonPressed) {
 848             tmp = getItemIndexAt(lPtr, event->xmotion.y);
 849             if (tmp>=0 && tmp != lPtr->selectedItem) {
 850                 WMSelectListItem(lPtr, tmp);
 851             }
 852         }
 853         break;
 854     }
 855     if (lPtr->topItem != topItem)
 856         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 857 }
 858
 859
 860 static void
 861 updateGeometry(WMList *lPtr)
 862 {
 863     lPtr->fullFitLines = (lPtr->view->size.height - 4) / lPtr->itemHeight;
 864     if (lPtr->fullFitLines * lPtr->itemHeight < lPtr->view->size.height - 4) {
 865         lPtr->flags.dontFitAll = 1;
 866     } else {
 867         lPtr->flags.dontFitAll = 0;
 868     }
 869
 870     if (WMGetArrayItemCount(lPtr->items) - lPtr->topItem <= lPtr->fullFitLines) {
 871         lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
 872         if (lPtr->topItem < 0)
 873             lPtr->topItem = 0;
 874     }
 875
 876     updateScroller(lPtr);
 877 }
 878
 879
 880 static void
 881 didResizeList(W_ViewDelegate *self, WMView *view)
 882 {
 883     WMList *lPtr = (WMList*)view->self;
 884
 885     WMResizeWidget(lPtr->vScroller, 1, view->size.height-2);
 886
 887     updateGeometry(lPtr);
 888 }
 889
 890
 891 static void
 892 destroyList(List *lPtr)
 893 {
 894     if (lPtr->idleID)
 895         WMDeleteIdleHandler(lPtr->idleID);
 896     lPtr->idleID = NULL;
 897
 898     WMFreeArray(lPtr->items);
 899
 900     wfree(lPtr);
 901 }
 902
 903