WINGs/wlist.c

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