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