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