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     WMArray *items;         /* list of WMListItem */
  15     WMArray *selectedItems; /* list of selected WMListItems */
  16
  17     short itemHeight;
  18
  19     short topItem;          /* index of first visible item */
  20
  21     short fullFitLines;     /* no of lines that fit entirely */
  22
  23     void *clientData;
  24     WMAction *action;
  25     void *doubleClientData;
  26     WMAction *doubleAction;
  27
  28     WMListDrawProc *draw;
  29
  30     WMHandlerID *idleID;    /* for updating the scroller after adding elements */
  31
  32     WMScroller *vScroller;
  33
  34     struct {
  35         unsigned int allowMultipleSelection:1;
  36         unsigned int allowEmptySelection:1;
  37         unsigned int userDrawn:1;
  38         unsigned int userItemHeight:1;
  39         unsigned int dontFitAll:1;     /* 1 = last item won't be fully visible */
  40         unsigned int redrawPending:1;
  41         unsigned int buttonPressed:1;
  42         unsigned int buttonWasPressed:1;
  43     } flags;
  44 } List;
  45
  46
  47
  48 #define DEFAULT_WIDTH   150
  49 #define DEFAULT_HEIGHT  150
  50
  51
  52 static void destroyList(List *lPtr);
  53 static void paintList(List *lPtr);
  54
  55
  56 static void handleEvents(XEvent *event, void *data);
  57 static void handleActionEvents(XEvent *event, void *data);
  58 static void updateScroller(List *lPtr);
  59
  60 static void vScrollCallBack(WMWidget *scroller, void *self);
  61
  62 static void updateGeometry(WMList *lPtr);
  63 static void didResizeList();
  64
  65
  66 W_ViewDelegate _ListViewDelegate = {
  67     NULL,
  68     NULL,
  69     didResizeList,
  70     NULL,
  71     NULL
  72 };
  73
  74
  75 static void
  76 releaseItem(void *data)
  77 {
  78     WMListItem *item = (WMListItem*)data;
  79
  80     if (item->text)
  81         wfree(item->text);
  82     wfree(item);
  83 }
  84
  85
  86 WMList*
  87 WMCreateList(WMWidget *parent)
  88 {
  89     List *lPtr;
  90     W_Screen *scrPtr = W_VIEW(parent)->screen;
  91
  92     lPtr = wmalloc(sizeof(List));
  93     memset(lPtr, 0, sizeof(List));
  94
  95     lPtr->widgetClass = WC_List;
  96
  97     lPtr->view = W_CreateView(W_VIEW(parent));
  98     if (!lPtr->view) {
  99         wfree(lPtr);
 100         return NULL;
 101     }
 102     lPtr->view->self = lPtr;
 103
 104     lPtr->view->delegate = &_ListViewDelegate;
 105
 106     WMCreateEventHandler(lPtr->view, ExposureMask|StructureNotifyMask
 107                          |ClientMessageMask, handleEvents, lPtr);
 108
 109     WMCreateEventHandler(lPtr->view, ButtonPressMask|ButtonReleaseMask
 110                          |EnterWindowMask|LeaveWindowMask|ButtonMotionMask,
 111                          handleActionEvents, lPtr);
 112
 113     lPtr->itemHeight = WMFontHeight(scrPtr->normalFont) + 1;
 114
 115     lPtr->items = WMCreateArrayWithDestructor(4, releaseItem);
 116     lPtr->selectedItems = WMCreateArray(4);
 117
 118     /* create the vertical scroller */
 119     lPtr->vScroller = WMCreateScroller(lPtr);
 120     WMMoveWidget(lPtr->vScroller, 1, 1);
 121     WMSetScrollerArrowsPosition(lPtr->vScroller, WSAMaxEnd);
 122
 123     WMSetScrollerAction(lPtr->vScroller, vScrollCallBack, lPtr);
 124
 125     /* make the scroller map itself when it's realized */
 126     WMMapWidget(lPtr->vScroller);
 127
 128     W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 129
 130     return lPtr;
 131 }
 132
 133
 134 void
 135 WMSetListAllowMultipleSelection(WMList *lPtr, Bool flag)
 136 {
 137     lPtr->flags.allowMultipleSelection = flag ? 1 : 0;
 138 }
 139
 140
 141 void
 142 WMSetListAllowEmptySelection(WMList *lPtr, Bool flag)
 143 {
 144     lPtr->flags.allowEmptySelection = flag ? 1 : 0;
 145 }
 146
 147
 148 static int
 149 comparator(const void *a, const void *b)
 150 {
 151     return (strcmp((*(WMListItem**)a)->text, (*(WMListItem**)b)->text));
 152 }
 153
 154
 155 void
 156 WMSortListItems(WMList *lPtr)
 157 {
 158     WMSortArray(lPtr->items, comparator);
 159
 160     paintList(lPtr);
 161 }
 162
 163
 164
 165 void
 166 WMSortListItemsWithComparer(WMList *lPtr, WMCompareDataProc *func)
 167 {
 168     WMSortArray(lPtr->items, func);
 169
 170     paintList(lPtr);
 171 }
 172
 173
 174
 175 WMListItem*
 176 WMInsertListItem(WMList *lPtr, int row, char *text)
 177 {
 178     WMListItem *item;
 179
 180     CHECK_CLASS(lPtr, WC_List);
 181
 182     item = wmalloc(sizeof(WMListItem));
 183     memset(item, 0, sizeof(WMListItem));
 184     item->text = wstrdup(text);
 185
 186     row = WMIN(row, WMGetArrayItemCount(lPtr->items));
 187
 188     if (row < 0)
 189         WMAddToArray(lPtr->items, item);
 190     else
 191         WMInsertInArray(lPtr->items, row, item);
 192
 193     /* update the scroller when idle, so that we don't waste time
 194      * updating it when another item is going to be added later */
 195     if (!lPtr->idleID) {
 196         lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
 197     }
 198
 199     return item;
 200 }
 201
 202
 203 void
 204 WMRemoveListItem(WMList *lPtr, int row)
 205 {
 206     WMListItem *item;
 207     int topItem = lPtr->topItem;
 208     int selNotify = 0;
 209
 210     CHECK_CLASS(lPtr, WC_List);
 211
 212     /*wassertr(row>=0 && row<WMGetArrayItemCount(lPtr->items));*/
 213     if (row<0 || row>=WMGetArrayItemCount(lPtr->items))
 214         return;
 215
 216     item = WMGetFromArray(lPtr->items, row);
 217     if (item->selected) {
 218         WMRemoveFromArray(lPtr->selectedItems, item);
 219         selNotify = 1;
 220     }
 221
 222     if (row <= lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll)
 223         lPtr->topItem--;
 224     if (lPtr->topItem < 0)
 225         lPtr->topItem = 0;
 226
 227     WMDeleteFromArray(lPtr->items, row);
 228
 229     if (!lPtr->idleID) {
 230         lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
 231     }
 232     if (lPtr->topItem != topItem) {
 233         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 234     }
 235     if (selNotify) {
 236         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 237     }
 238 }
 239
 240
 241 WMListItem*
 242 WMGetListItem(WMList *lPtr, int row)
 243 {
 244     return WMGetFromArray(lPtr->items, row);
 245 }
 246
 247
 248 WMArray*
 249 WMGetListItems(WMList *lPtr)
 250 {
 251     return lPtr->items;
 252 }
 253
 254
 255 void
 256 WMSetListUserDrawProc(WMList *lPtr, WMListDrawProc *proc)
 257 {
 258     lPtr->flags.userDrawn = 1;
 259     lPtr->draw = proc;
 260 }
 261
 262
 263 void
 264 WMSetListUserDrawItemHeight(WMList *lPtr, unsigned short height)
 265 {
 266     assert(height > 0);
 267
 268     lPtr->flags.userItemHeight = 1;
 269     lPtr->itemHeight = height;
 270
 271     updateGeometry(lPtr);
 272 }
 273
 274
 275 void
 276 WMClearList(WMList *lPtr)
 277 {
 278     int selNo = WMGetArrayItemCount(lPtr->selectedItems);
 279
 280     WMEmptyArray(lPtr->selectedItems);
 281     WMEmptyArray(lPtr->items);
 282
 283     lPtr->topItem = 0;
 284
 285     if (!lPtr->idleID) {
 286         WMDeleteIdleHandler(lPtr->idleID);
 287         lPtr->idleID = NULL;
 288     }
 289     if (lPtr->view->flags.realized) {
 290         updateScroller(lPtr);
 291     }
 292     if (selNo > 0) {
 293         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 294     }
 295 }
 296
 297
 298 void
 299 WMSetListAction(WMList *lPtr, WMAction *action, void *clientData)
 300 {
 301     lPtr->action = action;
 302     lPtr->clientData = clientData;
 303 }
 304
 305
 306 void
 307 WMSetListDoubleAction(WMList *lPtr, WMAction *action, void *clientData)
 308 {
 309     lPtr->doubleAction = action;
 310     lPtr->doubleClientData = clientData;
 311 }
 312
 313
 314 WMArray*
 315 WMGetListSelectedItems(WMList *lPtr)
 316 {
 317     return lPtr->selectedItems;
 318 }
 319
 320
 321 WMListItem*
 322 WMGetListSelectedItem(WMList *lPtr)
 323 {
 324     return WMGetFromArray(lPtr->selectedItems, 0);
 325 }
 326
 327
 328 int
 329 WMGetListSelectedItemRow(WMList *lPtr)
 330 {
 331     WMListItem *item = WMGetFromArray(lPtr->selectedItems, 0);
 332
 333     return (item!=NULL ? WMGetFirstInArray(lPtr->items, item) : WLNotFound);
 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 > WMGetArrayItemCount(lPtr->items))
 349         lPtr->topItem = WMGetArrayItemCount(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 (WMGetArrayItemCount(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 WMGetArrayItemCount(lPtr->items);
 376 }
 377
 378
 379 int
 380 WMGetListPosition(WMList *lPtr)
 381 {
 382     return lPtr->topItem;
 383 }
 384
 385
 386 Bool
 387 WMListAllowsMultipleSelection(WMList *lPtr)
 388 {
 389     return lPtr->flags.allowMultipleSelection;
 390 }
 391
 392
 393 Bool
 394 WMListAllowsEmptySelection(WMList *lPtr)
 395 {
 396     return lPtr->flags.allowEmptySelection;
 397 }
 398
 399
 400 static void
 401 scrollByAmount(WMList *lPtr, int amount)
 402 {
 403     int itemCount = WMGetArrayItemCount(lPtr->items);
 404
 405     if ((amount < 0 && lPtr->topItem > 0) ||
 406         (amount > 0 && (lPtr->topItem + lPtr->fullFitLines < itemCount))) {
 407
 408         lPtr->topItem += amount;
 409         if (lPtr->topItem < 0)
 410             lPtr->topItem = 0;
 411         if (lPtr->topItem + lPtr->fullFitLines > itemCount)
 412             lPtr->topItem = itemCount - lPtr->fullFitLines;
 413
 414         updateScroller(lPtr);
 415     }
 416 }
 417
 418
 419 static void
 420 vScrollCallBack(WMWidget *scroller, void *self)
 421 {
 422     WMList *lPtr = (WMList*)self;
 423     int height;
 424     int oldTopItem = lPtr->topItem;
 425     int itemCount = WMGetArrayItemCount(lPtr->items);
 426
 427     height = lPtr->view->size.height - 4;
 428
 429     switch (WMGetScrollerHitPart((WMScroller*)scroller)) {
 430     case WSDecrementLine:
 431         scrollByAmount(lPtr, -1);
 432         break;
 433
 434     case WSIncrementLine:
 435         scrollByAmount(lPtr, 1);
 436         break;
 437
 438     case WSDecrementPage:
 439         scrollByAmount(lPtr, -lPtr->fullFitLines+(1-lPtr->flags.dontFitAll)+1);
 440         break;
 441
 442     case WSIncrementPage:
 443         scrollByAmount(lPtr, lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1);
 444         break;
 445
 446     case WSDecrementWheel:
 447         scrollByAmount(lPtr, -lPtr->fullFitLines / 3);
 448         break;
 449
 450     case WSIncrementWheel:
 451         scrollByAmount(lPtr, lPtr->fullFitLines / 3);
 452         break;
 453
 454     case WSKnob:
 455         lPtr->topItem = WMGetScrollerValue(lPtr->vScroller) *
 456             (float)(itemCount - lPtr->fullFitLines);
 457
 458         if (oldTopItem != lPtr->topItem)
 459             paintList(lPtr); // use updateScroller(lPtr) here?
 460         break;
 461
 462     case WSKnobSlot:
 463     case WSNoPart:
 464     default:
 465         /* do nothing */
 466         break;
 467     }
 468
 469     if (lPtr->topItem != oldTopItem)
 470         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
 471 }
 472
 473
 474 static void
 475 paintItem(List *lPtr, int index)
 476 {
 477     WMView *view = lPtr->view;
 478     W_Screen *scr = view->screen;
 479     int width, height, x, y;
 480     WMListItem *itemPtr;
 481
 482     itemPtr = WMGetFromArray(lPtr->items, index);
 483
 484     width = lPtr->view->size.width - 2 - 19;
 485     height = lPtr->itemHeight;
 486     x = 19;
 487     y = 2 + (index-lPtr->topItem) * lPtr->itemHeight + 1;
 488
 489     if (lPtr->flags.userDrawn) {
 490         WMRect rect;
 491         int flags;
 492
 493         rect.size.width = width;
 494         rect.size.height = height;
 495         rect.pos.x = x;
 496         rect.pos.y = y;
 497
 498         flags = itemPtr->uflags;
 499         if (itemPtr->disabled)
 500             flags |= WLDSDisabled;
 501         if (itemPtr->selected)
 502             flags |= WLDSSelected;
 503         if (itemPtr->isBranch)
 504             flags |= WLDSIsBranch;
 505
 506         if (lPtr->draw)
 507             (*lPtr->draw)(lPtr, index, view->window, itemPtr->text, flags,
 508                           &rect);
 509     } else {
 510         if (itemPtr->selected) {
 511             XFillRectangle(scr->display, view->window, WMColorGC(scr->white),
 512                            x, y, width, height);
 513         } else {
 514             XClearArea(scr->display, view->window, x, y, width, height, False);
 515         }
 516
 517         W_PaintText(view, view->window, scr->normalFont,  x+4, y, width,
 518                     WALeft, WMColorGC(scr->black), False,
 519                     itemPtr->text, strlen(itemPtr->text));
 520     }
 521
 522     if ((index-lPtr->topItem+lPtr->fullFitLines)*lPtr->itemHeight >
 523         lPtr->view->size.height-2) {
 524         W_DrawRelief(lPtr->view->screen, lPtr->view->window, 0, 0,
 525                      lPtr->view->size.width, lPtr->view->size.height,
 526                      WRSunken);
 527     }
 528 }
 529
 530
 531
 532 static void
 533 paintList(List *lPtr)
 534 {
 535     W_Screen *scrPtr = lPtr->view->screen;
 536     int i, lim;
 537
 538     if (!lPtr->view->flags.mapped)
 539         return;
 540
 541     if (WMGetArrayItemCount(lPtr->items) > 0) {
 542         if (lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll
 543             > WMGetArrayItemCount(lPtr->items)) {
 544
 545             lim = WMGetArrayItemCount(lPtr->items) - lPtr->topItem;
 546             XClearArea(scrPtr->display, lPtr->view->window, 19,
 547                        2+lim*lPtr->itemHeight, lPtr->view->size.width-21,
 548                        lPtr->view->size.height-lim*lPtr->itemHeight-3, False);
 549         } else {
 550             lim = lPtr->fullFitLines + lPtr->flags.dontFitAll;
 551         }
 552         for (i = lPtr->topItem; i < lPtr->topItem + lim; i++) {
 553             paintItem(lPtr, i);
 554         }
 555     } else {
 556         XClearWindow(scrPtr->display, lPtr->view->window);
 557     }
 558     W_DrawRelief(scrPtr, lPtr->view->window, 0, 0, lPtr->view->size.width,
 559                  lPtr->view->size.height, WRSunken);
 560 }
 561
 562 #if 0
 563 static void
 564 scrollTo(List *lPtr, int newTop)
 565 {
 566
 567 }
 568 #endif
 569
 570 static void
 571 updateScroller(List *lPtr)
 572 {
 573     float knobProportion, floatValue, tmp;
 574     int count = WMGetArrayItemCount(lPtr->items);
 575
 576     if (lPtr->idleID)
 577         WMDeleteIdleHandler(lPtr->idleID);
 578     lPtr->idleID = NULL;
 579
 580     paintList(lPtr);
 581
 582     if (count == 0 || count <= lPtr->fullFitLines)
 583         WMSetScrollerParameters(lPtr->vScroller, 0, 1);
 584     else {
 585         tmp = lPtr->fullFitLines;
 586         knobProportion = tmp/(float)count;
 587
 588         floatValue = (float)lPtr->topItem/(float)(count - lPtr->fullFitLines);
 589
 590         WMSetScrollerParameters(lPtr->vScroller, floatValue, knobProportion);
 591     }
 592 }
 593
 594
 595 static void
 596 handleEvents(XEvent *event, void *data)
 597 {
 598     List *lPtr = (List*)data;
 599
 600     CHECK_CLASS(data, WC_List);
 601
 602
 603     switch (event->type) {
 604     case Expose:
 605         if (event->xexpose.count!=0)
 606             break;
 607         paintList(lPtr);
 608         break;
 609
 610     case DestroyNotify:
 611         destroyList(lPtr);
 612         break;
 613
 614     }
 615 }
 616
 617
 618 static int
 619 matchTitle(void *item, void *title)
 620 {
 621     return (strcmp(((WMListItem*)item)->text, (char*)title)==0 ? 1 : 0);
 622 }
 623
 624
 625 int
 626 WMFindRowOfListItemWithTitle(WMList *lPtr, char *title)
 627 {
 628     return WMFindInArray(lPtr->items, matchTitle, title);
 629 }
 630
 631
 632 void
 633 WMSelectListItem(WMList *lPtr, int row)
 634 {
 635     WMListItem *item;
 636
 637     if (row >= WMGetArrayItemCount(lPtr->items))
 638         return;
 639
 640     if (row < 0) {
 641         /* row = -1 will deselects all for backward compatibility.
 642          * will be removed later. -Dan */
 643         WMUnselectAllListItems(lPtr);
 644         return;
 645     }
 646
 647     item = WMGetFromArray(lPtr->items, row);
 648     if (item->selected)
 649         return;           /* Return if already selected */
 650
 651     if (!lPtr->flags.allowMultipleSelection) {
 652         /* unselect previous selected items */
 653         int foo = lPtr->flags.allowEmptySelection;
 654
 655         lPtr->flags.allowEmptySelection = 1;
 656         WMUnselectAllListItems(lPtr);
 657         lPtr->flags.allowEmptySelection = foo;
 658     }
 659
 660     /* select item */
 661     item->selected = 1;
 662     WMAddToArray(lPtr->selectedItems, item);
 663
 664     if (lPtr->view->flags.mapped && row>=lPtr->topItem
 665         && row<=lPtr->topItem+lPtr->fullFitLines) {
 666         paintItem(lPtr, row);
 667     }
 668
 669     WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 670 }
 671
 672
 673 void
 674 WMUnselectListItem(WMList *lPtr, int row)
 675 {
 676     WMListItem *item = WMGetFromArray(lPtr->items, row);
 677
 678     if (!item || !item->selected)
 679         return;
 680
 681     if (!lPtr->flags.allowEmptySelection &&
 682         WMGetArrayItemCount(lPtr->selectedItems) <= 1) {
 683         return;
 684     }
 685
 686     item->selected = 0;
 687     WMRemoveFromArray(lPtr->selectedItems, item);
 688
 689     if (lPtr->view->flags.mapped && row>=lPtr->topItem
 690         && row<=lPtr->topItem+lPtr->fullFitLines) {
 691         paintItem(lPtr, row);
 692     }
 693
 694     WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 695 }
 696
 697
 698 void
 699 WMSelectListItemsInRange(WMList *lPtr, WMRange range)
 700 {
 701     WMListItem *item;
 702     int position = range.position, k = 1, notify = 0;
 703     int total = WMGetArrayItemCount(lPtr->items);
 704
 705     if (!lPtr->flags.allowMultipleSelection)
 706         return;
 707     if (range.count==0)
 708         return; /* Nothing to select */
 709
 710     if (range.count < 0) {
 711         range.count = -range.count;
 712         k = -1;
 713     }
 714
 715     for (; range.count>0 && position>=0 && position<total; range.count--) {
 716         item = WMGetFromArray(lPtr->items, position);
 717         if (!item->selected) {
 718             item->selected = 1;
 719             WMAddToArray(lPtr->selectedItems, item);
 720             if (lPtr->view->flags.mapped && position>=lPtr->topItem
 721                 && position<=lPtr->topItem+lPtr->fullFitLines) {
 722                 paintItem(lPtr, position);
 723             }
 724             notify = 1;
 725         }
 726         position += k;
 727     }
 728
 729     if (notify) {
 730         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 731     }
 732 }
 733
 734
 735 void
 736 WMSetListSelectionToRange(WMList *lPtr, WMRange range)
 737 {
 738     WMListItem *item;
 739     int mark1, mark2, i, k;
 740     int position = range.position, notify = 0;
 741     int total = WMGetArrayItemCount(lPtr->items);
 742
 743     if (!lPtr->flags.allowMultipleSelection)
 744         return;
 745
 746     if (range.count==0) {
 747         WMUnselectAllListItems(lPtr);
 748         return;
 749     }
 750
 751     if (range.count < 0) {
 752         mark1 = range.position + range.count + 1;
 753         mark2 = range.position + 1;
 754         range.count = -range.count;
 755         k = -1;
 756     } else {
 757         mark1 = range.position;
 758         mark2 = range.position + range.count;
 759         k = 1;
 760     }
 761     if (mark1 > total)
 762         mark1 = total;
 763     if (mark2 < 0)
 764         mark2 = 0;
 765
 766     WMEmptyArray(lPtr->selectedItems);
 767
 768     for (i=0; i<mark1; i++) {
 769         item = WMGetFromArray(lPtr->items, i);
 770         if (item->selected) {
 771             item->selected = 0;
 772             if (lPtr->view->flags.mapped && i>=lPtr->topItem
 773                 && i<=lPtr->topItem+lPtr->fullFitLines) {
 774                 paintItem(lPtr, i);
 775             }
 776             notify = 1;
 777         }
 778     }
 779     for (; range.count>0 && position>=0 && position<total; range.count--) {
 780         item = WMGetFromArray(lPtr->items, position);
 781         if (!item->selected) {
 782             item->selected = 1;
 783             if (lPtr->view->flags.mapped && position>=lPtr->topItem
 784                 && position<=lPtr->topItem+lPtr->fullFitLines) {
 785                 paintItem(lPtr, position);
 786             }
 787             notify = 1;
 788         }
 789         WMAddToArray(lPtr->selectedItems, item);
 790         position += k;
 791     }
 792     for (i=mark2; i<total; i++) {
 793         item = WMGetFromArray(lPtr->items, i);
 794         if (item->selected) {
 795             item->selected = 0;
 796             if (lPtr->view->flags.mapped && i>=lPtr->topItem
 797                 && i<=lPtr->topItem+lPtr->fullFitLines) {
 798                 paintItem(lPtr, i);
 799             }
 800             notify = 1;
 801         }
 802     }
 803
 804     if (notify) {
 805         WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 806     }
 807 }
 808
 809
 810 void
 811 WMSelectAllListItems(WMList *lPtr)
 812 {
 813     int i;
 814     WMListItem *item;
 815
 816     if (!lPtr->flags.allowMultipleSelection)
 817         return;
 818
 819     if (WMGetArrayItemCount(lPtr->items) ==
 820         WMGetArrayItemCount(lPtr->selectedItems)) {
 821         return; /* All items are selected already */
 822     }
 823
 824     WMFreeArray(lPtr->selectedItems);
 825     lPtr->selectedItems = WMCreateArrayWithArray(lPtr->items);
 826
 827     for (i=0; i<WMGetArrayItemCount(lPtr->items); i++) {
 828         item = WMGetFromArray(lPtr->items, i);
 829         if (!item->selected) {
 830             item->selected = 1;
 831             if (lPtr->view->flags.mapped && i>=lPtr->topItem
 832                 && i<=lPtr->topItem+lPtr->fullFitLines) {
 833                 paintItem(lPtr, i);
 834             }
 835         }
 836     }
 837
 838     WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 839 }
 840
 841
 842 void
 843 WMUnselectAllListItems(WMList *lPtr)
 844 {
 845     int i, keep;
 846     WMListItem *item, *keepItem;
 847
 848     keep = lPtr->flags.allowEmptySelection ? 0 : 1;
 849
 850     if (WMGetArrayItemCount(lPtr->selectedItems) == keep)
 851         return;
 852
 853     keepItem = (keep==1 ? WMGetFromArray(lPtr->selectedItems, 0) : NULL);
 854
 855     for (i=0; i<WMGetArrayItemCount(lPtr->items); i++) {
 856         item = WMGetFromArray(lPtr->items, i);
 857         if (item!=keepItem && item->selected) {
 858             item->selected = 0;
 859             if (lPtr->view->flags.mapped && i>=lPtr->topItem
 860                 && i<=lPtr->topItem+lPtr->fullFitLines) {
 861                 paintItem(lPtr, i);
 862             }
 863         }
 864     }
 865
 866     WMEmptyArray(lPtr->selectedItems);
 867     if (keepItem!=NULL)
 868         WMAddToArray(lPtr->selectedItems, keepItem);
 869
 870     WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, NULL);
 871 }
 872
 873
 874 static int
 875 getItemIndexAt(List *lPtr, int clickY)
 876 {
 877     int index;
 878
 879     index = (clickY - 2) / lPtr->itemHeight + lPtr->topItem;
 880
 881     if (index < 0 || index >= WMGetArrayItemCount(lPtr->items))
 882         return -1;
 883
 884     return index;
 885 }
 886
 887
 888 static void
 889 toggleItemSelection(WMList *lPtr, int index)
 890 {
 891     WMListItem *item = WMGetFromArray(lPtr->items, index);
 892
 893     if (item && item->selected) {
 894         WMUnselectListItem(lPtr, index);
 895     } else {
 896         WMSelectListItem(lPtr, index);
 897     }
 898 }
 899
 900
 901 static void
 902 handleActionEvents(XEvent *event, void *data)
 903 {
 904     List *lPtr = (List*)data;
 905     int tmp;
 906     int topItem = lPtr->topItem;
 907     static int lastClicked = -1, prevItem = -1;
 908
 909     CHECK_CLASS(data, WC_List);
 910
 911     switch (event->type) {
 912     case ButtonRelease:
 913         /* Ignore mouse wheel events, they're not "real" button events */
 914         if (event->xbutton.button == WINGsConfiguration.mouseWheelUp ||
 915             event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
 916             break;
 917         }
 918
 919         lPtr->flags.buttonPressed = 0;
 920         tmp = getItemIndexAt(lPtr, event->xbutton.y);
 921
 922         if (tmp >= 0) {
 923             if (lPtr->action)
 924                 (*lPtr->action)(lPtr, lPtr->clientData);
 925         }
 926
 927         if (!(event->xbutton.state & ShiftMask))
 928             lastClicked = prevItem = tmp;
 929
 930         break;
 931
 932     case EnterNotify:
 933         lPtr->flags.buttonPressed = lPtr->flags.buttonWasPressed;
 934         lPtr->flags.buttonWasPressed = 0;
 935         break;
 936
 937     case LeaveNotify:
 938         lPtr->flags.buttonWasPressed = lPtr->flags.buttonPressed;
 939         lPtr->flags.buttonPressed = 0;
 940         break;
 941
 942     case ButtonPress:
 943         if (event->xbutton.x <= WMWidgetWidth(lPtr->vScroller))
 944             break;
 945         if (event->xbutton.button == WINGsConfiguration.mouseWheelDown ||
 946             event->xbutton.button == WINGsConfiguration.mouseWheelUp) {
 947             int amount = 0;
 948
 949             if (event->xbutton.state & ControlMask) {
 950                 amount = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
 951             } else if (event->xbutton.state & ShiftMask) {
 952                 amount = 1;
 953             } else {
 954                 amount = lPtr->fullFitLines / 3;
 955                 if (amount == 0)
 956                     amount++;
 957             }
 958             if (event->xbutton.button == WINGsConfiguration.mouseWheelUp)
 959                 amount = -amount;
 960
 961             scrollByAmount(lPtr, amount);
 962             break;
 963         }
 964
 965         tmp = getItemIndexAt(lPtr, event->xbutton.y);
 966         lPtr->flags.buttonPressed = 1;
 967
 968         if (tmp >= 0) {
 969             if (tmp == lastClicked && WMIsDoubleClick(event)) {
 970                 WMSelectListItem(lPtr, tmp);
 971                 if (lPtr->doubleAction)
 972                     (*lPtr->doubleAction)(lPtr, lPtr->doubleClientData);
 973             } else {
 974                 if (!lPtr->flags.allowMultipleSelection) {
 975                     if (event->xbutton.state & ControlMask) {
 976                         toggleItemSelection(lPtr, tmp);
 977                     } else {
 978                         WMSelectListItem(lPtr, tmp);
 979                     }
 980                 } else {
 981                     WMRange range;
 982                     WMListItem *lastSel;
 983
 984                     if (event->xbutton.state & ControlMask) {
 985                         toggleItemSelection(lPtr, tmp);
 986                     } else if (event->xbutton.state & ShiftMask) {
 987                         if (WMGetArrayItemCount(lPtr->selectedItems) == 0) {
 988                             WMSelectListItem(lPtr, tmp);
 989                         } else {
 990                             lastSel = WMGetFromArray(lPtr->items, lastClicked);
 991                             range.position = WMGetFirstInArray(lPtr->items,
 992                                                                lastSel);
 993                             if (tmp >= range.position)
 994                                 range.count = tmp - range.position + 1;
 995                             else
 996                                 range.count = tmp - range.position - 1;
 997
 998                             WMSetListSelectionToRange(lPtr, range);
 999                         }
1000                     } else {
1001                         range.position = tmp;
1002                         range.count = 1;
1003                         WMSetListSelectionToRange(lPtr, range);
1004                     }
1005                 }
1006             }
1007         }
1008
1009         if (!(event->xbutton.state & ShiftMask))
1010             lastClicked = prevItem = tmp;
1011
1012         break;
1013
1014     case MotionNotify:
1015         if (lPtr->flags.buttonPressed) {
1016             tmp = getItemIndexAt(lPtr, event->xmotion.y);
1017             if (tmp>=0 && tmp!=prevItem) {
1018                 if (lPtr->flags.allowMultipleSelection) {
1019                     WMRange range;
1020
1021                     range.position = lastClicked;
1022                     if (tmp >= lastClicked)
1023                         range.count = tmp - lastClicked + 1;
1024                     else
1025                         range.count = tmp - lastClicked - 1;
1026                     WMSetListSelectionToRange(lPtr, range);
1027                 } else {
1028                     WMSelectListItem(lPtr, tmp);
1029                 }
1030             }
1031             prevItem = tmp;
1032         }
1033         break;
1034     }
1035     if (lPtr->topItem != topItem)
1036         WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
1037 }
1038
1039
1040 static void
1041 updateGeometry(WMList *lPtr)
1042 {
1043     lPtr->fullFitLines = (lPtr->view->size.height - 4) / lPtr->itemHeight;
1044     if (lPtr->fullFitLines * lPtr->itemHeight < lPtr->view->size.height - 4) {
1045         lPtr->flags.dontFitAll = 1;
1046     } else {
1047         lPtr->flags.dontFitAll = 0;
1048     }
1049
1050     if (WMGetArrayItemCount(lPtr->items) - lPtr->topItem <= lPtr->fullFitLines) {
1051         lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
1052         if (lPtr->topItem < 0)
1053             lPtr->topItem = 0;
1054     }
1055
1056     updateScroller(lPtr);
1057 }
1058
1059
1060 static void
1061 didResizeList(W_ViewDelegate *self, WMView *view)
1062 {
1063     WMList *lPtr = (WMList*)view->self;
1064
1065     WMResizeWidget(lPtr->vScroller, 1, view->size.height-2);
1066
1067     updateGeometry(lPtr);
1068 }
1069
1070
1071 static void
1072 destroyList(List *lPtr)
1073 {
1074     if (lPtr->idleID)
1075         WMDeleteIdleHandler(lPtr->idleID);
1076     lPtr->idleID = NULL;
1077
1078     WMFreeArray(lPtr->items);
1079
1080     wfree(lPtr);
1081 }
1082
1083