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
 119     /* create the vertical scroller */
 120     lPtr->vScroller = WMCreateScroller(lPtr);
 121     WMMoveWidget(lPtr->vScroller, 1, 1);
 122     WMSetScrollerArrowsPosition(lPtr->vScroller, WSAMaxEnd);
 123
 124     WMSetScrollerAction(lPtr->vScroller, vScrollCallBack, lPtr);
 125
 126     /* make the scroller map itself when it's realized */
 127     WMMapWidget(lPtr->vScroller);
 128
 129     W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 130
 131     lPtr->selectedItem = -1;
 132
 133     return lPtr;
 134 }
 135
 136
 137 static int
 138 comparator(const void *a, const void *b)
 139 {
 140     return (strcmp((*(WMListItem**)a)->text, (*(WMListItem**)b)->text));
 141 }
 142
 143
 144 void
 145 WMSortListItems(WMList *lPtr)
 146 {
 147     WMSortArray(lPtr->items, comparator);
 148
 149     paintList(lPtr);
 150 }
 151
 152
 153
 154 void
 155 WMSortListItemsWithComparer(WMList *lPtr, int (f)(const void*, const void*))
 156 {
 157     WMSortArray(lPtr->items, f);
 158
 159     paintList(lPtr);
 160 }
 161
 162
 163
 164 WMListItem*
 165 WMInsertListItem(WMList *lPtr, int row, char *text)
 166 {
 167     WMListItem *item;
 168
 169     CHECK_CLASS(lPtr, WC_List);
 170
 171     item = wmalloc(sizeof(WMListItem));
 172     memset(item, 0, sizeof(WMListItem));
 173     item->text = wstrdup(text);
 174
 175
 176     if (lPtr->selectedItem >= row && lPtr->selectedItem >= 0
 177         && row >= 0)
 178         lPtr->selectedItem++;
 179
 180     row = WMIN(row, WMGetArrayItemCount(lPtr->items));
 181
 182     if (row < 0)
 183         WMAddToArray(lPtr->items, item);
 184     else
 185         WMInsertInArray(lPtr->items, row, item);
 186
 187     /* update the scroller when idle, so that we don't waste time
 188      * updating it when another item is going to be added later */
 189     if (!lPtr->idleID) {
 190         lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
 191     }
 192
 193     return item;
 194 }
 195
 196
 197 void
 198 WMRemoveListItem(WMList *lPtr, int row)
 199 {
 200     int topItem = lPtr->topItem;
 201     int selNotify = 0;
 202
 203     CHECK_CLASS(lPtr, WC_List);
 204
 205     if (row < 0 || row >= WMGetArrayItemCount(lPtr->items))
 206         return;
 207
 208     if (lPtr->selectedItem == row) {
 209         lPtr->selectedItem = -1;
 210         selNotify = 1;
 211     } else if (lPtr->selectedItem > row) {
 212         lPtr->selectedItem--;
 213     }
 214
 215     if (row <= lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll)
 216         lPtr->topItem--;
 217     if (lPtr->topItem < 0)
 218         lPtr->topItem = 0;
 219
 220     WMDeleteFromArray(lPtr->items, row);
 221
 222     if (!lPtr->idleID) {
 223         lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
 224     }
 225     if (lPtr->topItem != topItem)
 226         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 227     if (selNotify)
 228         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr,
 229                                (void*)((int)lPtr->selectedItem));
 230 }
 231
 232
 233
 234 WMListItem*
 235 WMGetListItem(WMList *lPtr, int row)
 236 {
 237     return WMGetFromArray(lPtr->items, row);
 238 }
 239
 240
 241 WMArray*
 242 WMGetListItems(WMList *lPtr)
 243 {
 244     return lPtr->items;
 245 }
 246
 247
 248
 249 void
 250 WMSetListUserDrawProc(WMList *lPtr, WMListDrawProc *proc)
 251 {
 252     lPtr->flags.userDrawn = 1;
 253     lPtr->draw = proc;
 254 }
 255
 256
 257 void
 258 WMSetListUserDrawItemHeight(WMList *lPtr, unsigned short height)
 259 {
 260     assert(height > 0);
 261
 262     lPtr->flags.userItemHeight = 1;
 263     lPtr->itemHeight = height;
 264
 265     updateGeometry(lPtr);
 266 }
 267
 268
 269 void
 270 WMClearList(WMList *lPtr)
 271 {
 272     int oldSelected = lPtr->selectedItem;
 273     int i;
 274
 275     WMEmptyArray(lPtr->items);
 276
 277     lPtr->topItem = 0;
 278     lPtr->selectedItem = -1;
 279
 280     if (!lPtr->idleID) {
 281         WMDeleteIdleHandler(lPtr->idleID);
 282         lPtr->idleID = NULL;
 283     }
 284     if (lPtr->view->flags.realized) {
 285         updateScroller(lPtr);
 286     }
 287     if (oldSelected != -1)
 288         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr,
 289                                (void*)-1);
 290 }
 291
 292
 293 void
 294 WMSetListAction(WMList *lPtr, WMAction *action, void *clientData)
 295 {
 296     lPtr->action = action;
 297     lPtr->clientData = clientData;
 298 }
 299
 300
 301 void
 302 WMSetListDoubleAction(WMList *lPtr, WMAction *action, void *clientData)
 303 {
 304     lPtr->doubleAction = action;
 305     lPtr->doubleClientData = clientData;
 306 }
 307
 308
 309 WMListItem*
 310 WMGetListSelectedItem(WMList *lPtr)
 311 {
 312     if (lPtr->selectedItem < 0)
 313         return NULL;
 314
 315     return WMGetFromArray(lPtr->items, lPtr->selectedItem);
 316 }
 317
 318
 319 int
 320 WMGetListSelectedItemRow(WMList *lPtr)
 321 {
 322     return lPtr->selectedItem;
 323 }
 324
 325
 326 int
 327 WMGetListItemHeight(WMList *lPtr)
 328 {
 329     return lPtr->itemHeight;
 330 }
 331
 332
 333 void
 334 WMSetListPosition(WMList *lPtr, int row)
 335 {
 336     lPtr->topItem = row;
 337     if (lPtr->topItem + lPtr->fullFitLines > WMGetArrayItemCount(lPtr->items))
 338         lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
 339
 340     if (lPtr->topItem < 0)
 341         lPtr->topItem = 0;
 342
 343     if (lPtr->view->flags.realized)
 344         updateScroller(lPtr);
 345 }
 346
 347
 348 void
 349 WMSetListBottomPosition(WMList *lPtr, int row)
 350 {
 351     if (WMGetArrayItemCount(lPtr->items) > lPtr->fullFitLines) {
 352         lPtr->topItem = row - lPtr->fullFitLines;
 353         if (lPtr->topItem < 0)
 354             lPtr->topItem = 0;
 355         if (lPtr->view->flags.realized)
 356             updateScroller(lPtr);
 357     }
 358 }
 359
 360
 361 int
 362 WMGetListNumberOfRows(WMList *lPtr)
 363 {
 364     return WMGetArrayItemCount(lPtr->items);
 365 }
 366
 367 int
 368 WMGetListPosition(WMList *lPtr)
 369 {
 370     return lPtr->topItem;
 371 }
 372
 373
 374 static void
 375 vScrollCallBack(WMWidget *scroller, void *self)
 376 {
 377     WMList *lPtr = (WMList*)self;
 378     WMScroller *sPtr = (WMScroller*)scroller;
 379     int height;
 380     int topItem = lPtr->topItem;
 381     int itemCount = WMGetArrayItemCount(lPtr->items);
 382
 383     height = lPtr->view->size.height - 4;
 384
 385     switch (WMGetScrollerHitPart(sPtr)) {
 386     case WSDecrementLine:
 387         if (lPtr->topItem > 0) {
 388             lPtr->topItem--;
 389
 390             updateScroller(lPtr);
 391         }
 392         break;
 393
 394     case WSDecrementPage:
 395         if (lPtr->topItem > 0) {
 396             lPtr->topItem -= lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 397             if (lPtr->topItem < 0)
 398                 lPtr->topItem = 0;
 399
 400             updateScroller(lPtr);
 401         }
 402         break;
 403
 404
 405     case WSIncrementLine:
 406         if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
 407             lPtr->topItem++;
 408
 409             updateScroller(lPtr);
 410         }
 411         break;
 412
 413     case WSIncrementPage:
 414         if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
 415             lPtr->topItem += lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 416
 417             if (lPtr->topItem + lPtr->fullFitLines > itemCount)
 418                 lPtr->topItem = itemCount - lPtr->fullFitLines;
 419
 420             updateScroller(lPtr);
 421         }
 422         break;
 423
 424     case WSKnob:
 425         {
 426             int oldTopItem = lPtr->topItem;
 427
 428             lPtr->topItem = WMGetScrollerValue(lPtr->vScroller) *
 429                 (float)(itemCount - lPtr->fullFitLines);
 430
 431             if (oldTopItem != lPtr->topItem)
 432                 paintList(lPtr);
 433         }
 434         break;
 435
 436     case WSKnobSlot:
 437     case WSNoPart:
 438         /* do nothing */
 439         break;
 440     }
 441
 442     if (lPtr->topItem != topItem)
 443         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 444 }
 445
 446
 447 static void
 448 paintItem(List *lPtr, int index)
 449 {
 450     WMView *view = lPtr->view;
 451     W_Screen *scr = view->screen;
 452     int width, height, x, y;
 453     WMListItem *itemPtr;
 454
 455     itemPtr = WMGetFromArray(lPtr->items, index);
 456
 457     width = lPtr->view->size.width - 2 - 19;
 458     height = lPtr->itemHeight;
 459     x = 19;
 460     y = 2 + (index-lPtr->topItem) * lPtr->itemHeight + 1;
 461
 462     if (lPtr->flags.userDrawn) {
 463         WMRect rect;
 464         int flags;
 465
 466         rect.size.width = width;
 467         rect.size.height = height;
 468         rect.pos.x = x;
 469         rect.pos.y = y;
 470
 471         flags = itemPtr->uflags;
 472         if (itemPtr->disabled)
 473             flags |= WLDSDisabled;
 474         if (itemPtr->selected)
 475             flags |= WLDSSelected;
 476         if (itemPtr->isBranch)
 477             flags |= WLDSIsBranch;
 478
 479         if (lPtr->draw)
 480             (*lPtr->draw)(lPtr, index, view->window, itemPtr->text, flags,
 481                           &rect);
 482     } else {
 483         if (itemPtr->selected)
 484             XFillRectangle(scr->display, view->window, WMColorGC(scr->white),
 485                            x, y, width, height);
 486         else
 487             XClearArea(scr->display, view->window, x, y, width, height, False);
 488
 489         W_PaintText(view, view->window, scr->normalFont,  x+4, y, width,
 490                     WALeft, WMColorGC(scr->black), False,
 491                     itemPtr->text, strlen(itemPtr->text));
 492     }
 493 }
 494
 495
 496
 497 static void
 498 paintList(List *lPtr)
 499 {
 500     W_Screen *scrPtr = lPtr->view->screen;
 501     int i, lim;
 502
 503     if (!lPtr->view->flags.mapped)
 504         return;
 505
 506     if (WMGetArrayItemCount(lPtr->items) > 0) {
 507         if (lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll
 508             > WMGetArrayItemCount(lPtr->items)) {
 509
 510             lim = WMGetArrayItemCount(lPtr->items) - lPtr->topItem;
 511             XClearArea(scrPtr->display, lPtr->view->window, 19,
 512                        2+lim*lPtr->itemHeight, lPtr->view->size.width-21,
 513                        lPtr->view->size.height-lim*lPtr->itemHeight-3, False);
 514         } else {
 515             lim = lPtr->fullFitLines + lPtr->flags.dontFitAll;
 516         }
 517         for (i = lPtr->topItem; i < lPtr->topItem + lim; i++) {
 518             paintItem(lPtr, i);
 519         }
 520     } else {
 521         XClearWindow(scrPtr->display, lPtr->view->window);
 522     }
 523     W_DrawRelief(scrPtr, lPtr->view->window, 0, 0, lPtr->view->size.width,
 524                  lPtr->view->size.height, WRSunken);
 525 }
 526
 527 #if 0
 528 static void
 529 scrollTo(List *lPtr, int newTop)
 530 {
 531
 532 }
 533 #endif
 534
 535 static void
 536 updateScroller(List *lPtr)
 537 {
 538     float knobProportion, floatValue, tmp;
 539     int count = WMGetArrayItemCount(lPtr->items);
 540
 541     if (lPtr->idleID)
 542         WMDeleteIdleHandler(lPtr->idleID);
 543     lPtr->idleID = NULL;
 544
 545     paintList(lPtr);
 546
 547     if (count == 0 || count <= lPtr->fullFitLines)
 548         WMSetScrollerParameters(lPtr->vScroller, 0, 1);
 549     else {
 550         tmp = lPtr->fullFitLines;
 551         knobProportion = tmp/(float)count;
 552
 553         floatValue = (float)lPtr->topItem/(float)(count - lPtr->fullFitLines);
 554
 555         WMSetScrollerParameters(lPtr->vScroller, floatValue, knobProportion);
 556     }
 557 }
 558
 559
 560 static void
 561 handleEvents(XEvent *event, void *data)
 562 {
 563     List *lPtr = (List*)data;
 564
 565     CHECK_CLASS(data, WC_List);
 566
 567
 568     switch (event->type) {
 569     case Expose:
 570         if (event->xexpose.count!=0)
 571             break;
 572         paintList(lPtr);
 573         break;
 574
 575     case DestroyNotify:
 576         destroyList(lPtr);
 577         break;
 578
 579     }
 580 }
 581
 582
 583 static int
 584 matchTitle(void *item, void *title)
 585 {
 586     return (strcmp(((WMListItem*)item)->text, (char*)title)==0 ? 1 : 0);
 587 }
 588
 589
 590 int
 591 WMFindRowOfListItemWithTitle(WMList *lPtr, char *title)
 592 {
 593     return WMFindInArray(lPtr->items, matchTitle, title);
 594 }
 595
 596
 597 void
 598 WMSelectListItem(WMList *lPtr, int row)
 599 {
 600     WMListItem *itemPtr;
 601     int notify = 0;
 602
 603     if (row >= WMGetArrayItemCount(lPtr->items))
 604         return;
 605
 606     /* the check below must be changed when the multiple selection is
 607      * implemented. -Dan
 608      */
 609     if (!lPtr->flags.allowMultipleSelection && row == lPtr->selectedItem)
 610         notify = 0;
 611     else
 612         notify = 1;
 613
 614     assert(lPtr->selectedItem < WMGetArrayItemCount(lPtr->items));
 615
 616     if (!lPtr->flags.allowMultipleSelection) {
 617         /* unselect previous selected item */
 618         if (lPtr->selectedItem >= 0) {
 619             itemPtr = WMGetFromArray(lPtr->items, lPtr->selectedItem);
 620
 621             if (itemPtr->selected) {
 622                 itemPtr->selected = 0;
 623                 if (lPtr->view->flags.mapped
 624                     && lPtr->selectedItem>=lPtr->topItem
 625                     && lPtr->selectedItem<=lPtr->topItem+lPtr->fullFitLines) {
 626                     paintItem(lPtr, lPtr->selectedItem);
 627                 }
 628             }
 629         }
 630     }
 631
 632     if (row < 0) {
 633         if (!lPtr->flags.allowMultipleSelection) {
 634             lPtr->selectedItem = -1;
 635             if (notify)
 636                 WMPostNotificationName(WMListSelectionDidChangeNotification,
 637                                        lPtr, (void*)((int)lPtr->selectedItem));
 638         }
 639         return;
 640     }
 641
 642     /* select item */
 643     itemPtr = WMGetFromArray(lPtr->items, row);
 644
 645     if (lPtr->flags.allowMultipleSelection)
 646         itemPtr->selected = !itemPtr->selected;
 647     else
 648         itemPtr->selected = 1;
 649
 650     if (lPtr->view->flags.mapped) {
 651         paintItem(lPtr, row);
 652
 653         if ((row-lPtr->topItem+lPtr->fullFitLines)*lPtr->itemHeight
 654             > lPtr->view->size.height-2)
 655             W_DrawRelief(lPtr->view->screen, lPtr->view->window, 0, 0,
 656                          lPtr->view->size.width, lPtr->view->size.height,
 657                          WRSunken);
 658     }
 659     lPtr->selectedItem = row;
 660     if (notify)
 661         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr,
 662                                (void*)((int)lPtr->selectedItem));
 663 }
 664
 665
 666 static int
 667 getItemIndexAt(List *lPtr, int clickY)
 668 {
 669     int index;
 670
 671     index = (clickY - 2) / lPtr->itemHeight + lPtr->topItem;
 672
 673     if (index < 0 || index >= WMGetArrayItemCount(lPtr->items))
 674         return -1;
 675
 676     return index;
 677 }
 678
 679
 680 static void
 681 handleActionEvents(XEvent *event, void *data)
 682 {
 683     List *lPtr = (List*)data;
 684     int tmp;
 685     int topItem = lPtr->topItem;
 686
 687     CHECK_CLASS(data, WC_List);
 688
 689     switch (event->type) {
 690     case ButtonRelease:
 691 #define CHECK_WHEEL_PATCH
 692 #ifdef CHECK_WHEEL_PATCH
 693         /* Ignore mouse wheel events, they're not "real" button events */
 694         if (event->xbutton.button == WINGsConfiguration.mouseWheelUp ||
 695             event->xbutton.button == WINGsConfiguration.mouseWheelDown)
 696             break;
 697 #endif
 698
 699         lPtr->flags.buttonPressed = 0;
 700         tmp = getItemIndexAt(lPtr, event->xbutton.y);
 701
 702         if (tmp == lPtr->selectedItem && tmp >= 0) {
 703             if (lPtr->action)
 704                 (*lPtr->action)(lPtr, lPtr->clientData);
 705         }
 706         break;
 707
 708     case EnterNotify:
 709         lPtr->flags.buttonPressed = lPtr->flags.buttonWasPressed;
 710         lPtr->flags.buttonWasPressed = 0;
 711         break;
 712
 713     case LeaveNotify:
 714         lPtr->flags.buttonWasPressed = lPtr->flags.buttonPressed;
 715         lPtr->flags.buttonPressed = 0;
 716         break;
 717
 718     case ButtonPress:
 719         if (event->xbutton.x > WMWidgetWidth(lPtr->vScroller)) {
 720 #ifdef CHECK_WHEEL_PATCH
 721             /* Mouse wheel events need to be properly handled here. It would
 722              * be best to somehow route them to lPtr->vScroller so that the
 723              * correct chain of actions is triggered. However, I found no
 724              * clean way to do so, so I mostly copied the code that deals with
 725              * WSIncrementPage and WSDecrementPage from vScrollCallBack.
 726              *
 727              *          - Martynas Kunigelis <diskena@linuxfreak.com> */
 728
 729             if (event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
 730                 /* Wheel down */
 731                 int itemCount = WMGetArrayItemCount(lPtr->items);
 732                 if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
 733                     int incr = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 734                     lPtr->topItem += incr;
 735
 736                     if (lPtr->topItem + lPtr->fullFitLines > itemCount)
 737                         lPtr->topItem = itemCount - lPtr->fullFitLines;
 738
 739                     updateScroller(lPtr);
 740                 }
 741                 break;
 742             }
 743
 744             if (event->xbutton.button == WINGsConfiguration.mouseWheelUp) {
 745                 /* Wheel up */
 746                 if (lPtr->topItem > 0) {
 747                     int decr = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 748                     lPtr->topItem -= decr;
 749
 750                     if (lPtr->topItem < 0)
 751                         lPtr->topItem = 0;
 752
 753                     updateScroller(lPtr);
 754                 }
 755                 break;
 756             }
 757 #endif
 758
 759             tmp = getItemIndexAt(lPtr, event->xbutton.y);
 760             lPtr->flags.buttonPressed = 1;
 761
 762             if (tmp >= 0) {
 763                 if (tmp == lPtr->selectedItem && WMIsDoubleClick(event)) {
 764                     WMSelectListItem(lPtr, tmp);
 765                     if (lPtr->doubleAction)
 766                         (*lPtr->doubleAction)(lPtr, lPtr->doubleClientData);
 767                 } else {
 768                     WMSelectListItem(lPtr, tmp);
 769                 }
 770             }
 771         }
 772         break;
 773
 774     case MotionNotify:
 775         if (lPtr->flags.buttonPressed) {
 776             tmp = getItemIndexAt(lPtr, event->xmotion.y);
 777             if (tmp>=0 && tmp != lPtr->selectedItem) {
 778                 WMSelectListItem(lPtr, tmp);
 779             }
 780         }
 781         break;
 782     }
 783     if (lPtr->topItem != topItem)
 784         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 785 }
 786
 787
 788 static void
 789 updateGeometry(WMList *lPtr)
 790 {
 791     lPtr->fullFitLines = (lPtr->view->size.height - 4) / lPtr->itemHeight;
 792     if (lPtr->fullFitLines * lPtr->itemHeight < lPtr->view->size.height - 4) {
 793         lPtr->flags.dontFitAll = 1;
 794     } else {
 795         lPtr->flags.dontFitAll = 0;
 796     }
 797
 798     if (WMGetArrayItemCount(lPtr->items) - lPtr->topItem <= lPtr->fullFitLines) {
 799         lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
 800         if (lPtr->topItem < 0)
 801             lPtr->topItem = 0;
 802     }
 803
 804     updateScroller(lPtr);
 805 }
 806
 807
 808 static void
 809 didResizeList(W_ViewDelegate *self, WMView *view)
 810 {
 811     WMList *lPtr = (WMList*)view->self;
 812
 813     WMResizeWidget(lPtr->vScroller, 1, view->size.height-2);
 814
 815     updateGeometry(lPtr);
 816 }
 817
 818
 819 static void
 820 destroyList(List *lPtr)
 821 {
 822     if (lPtr->idleID)
 823         WMDeleteIdleHandler(lPtr->idleID);
 824     lPtr->idleID = NULL;
 825
 826     WMFreeArray(lPtr->items);
 827
 828     wfree(lPtr);
 829 }