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