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