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