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