WINGs/wscroller.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 /* undefine will disable the autoadjusting of the knob dimple to be
   8  * directly below the cursor
   9  * DOES NOT WORK */
  10 #undef STRICT_NEXT_BEHAVIOUR
  11
  12 #define AUTOSCROLL_INITIAL_DELAY        200
  13
  14 #define AUTOSCROLL_DELAY                40
  15
  16
  17 typedef struct W_Scroller {
  18     W_Class widgetClass;
  19     W_View *view;
  20
  21     void *clientData;
  22     WMAction *action;
  23
  24     float knobProportion;
  25     float floatValue;
  26
  27     WMHandlerID timerID;               /* for continuous scrolling mode */
  28
  29 #ifndef STRICT_NEXT_BEHAVIOUR
  30     int dragPoint;                     /* point where the knob is being
  31                                         * dragged */
  32 #endif
  33     struct {
  34         WMScrollArrowPosition arrowsPosition:4;
  35
  36         unsigned int horizontal:1;
  37
  38         WMScrollerPart hitPart:4;
  39
  40         /* */
  41         unsigned int documentFullyVisible:1;   /* document is fully visible */
  42
  43         unsigned int prevSelected:1;
  44
  45         unsigned int pushed:1;
  46
  47         unsigned int incrDown:1;      /* whether increment button is down */
  48
  49         unsigned int decrDown:1;
  50
  51         unsigned int draggingKnob:1;
  52
  53         unsigned int configured:1;
  54
  55         unsigned int redrawPending:1;
  56     } flags;
  57 } Scroller;
  58
  59
  60
  61 #define DEFAULT_HEIGHT          60
  62 #define DEFAULT_WIDTH           SCROLLER_WIDTH
  63 #define DEFAULT_ARROWS_POSITION WSAMinEnd
  64
  65
  66
  67 static void destroyScroller(Scroller *sPtr);
  68 static void paintScroller(Scroller *sPtr);
  69
  70 static void willResizeScroller();
  71 static void handleEvents(XEvent *event, void *data);
  72 static void handleActionEvents(XEvent *event, void *data);
  73
  74 static void handleMotion(Scroller *sPtr, int mouseX, int mouseY);
  75
  76
  77 W_ViewDelegate _ScrollerViewDelegate = {
  78     NULL,
  79         NULL,
  80         NULL,
  81         NULL,
  82         willResizeScroller
  83 };
  84
  85
  86
  87
  88 WMScroller*
  89 WMCreateScroller(WMWidget *parent)
  90 {
  91     Scroller *sPtr;
  92
  93     sPtr = wmalloc(sizeof(Scroller));
  94     memset(sPtr, 0, sizeof(Scroller));
  95
  96     sPtr->widgetClass = WC_Scroller;
  97
  98     sPtr->view = W_CreateView(W_VIEW(parent));
  99     if (!sPtr->view) {
 100         wfree(sPtr);
 101         return NULL;
 102     }
 103     sPtr->view->self = sPtr;
 104
 105     sPtr->view->delegate = &_ScrollerViewDelegate;
 106
 107     sPtr->flags.documentFullyVisible = 1;
 108
 109     WMCreateEventHandler(sPtr->view, ExposureMask|StructureNotifyMask
 110                          |ClientMessageMask, handleEvents, sPtr);
 111
 112     W_ResizeView(sPtr->view, DEFAULT_WIDTH, DEFAULT_WIDTH);
 113     sPtr->flags.arrowsPosition = DEFAULT_ARROWS_POSITION;
 114
 115     WMCreateEventHandler(sPtr->view, ButtonPressMask|ButtonReleaseMask
 116                          |EnterWindowMask|LeaveWindowMask|ButtonMotionMask,
 117                          handleActionEvents, sPtr);
 118
 119     sPtr->flags.hitPart = WSNoPart;
 120
 121     return sPtr;
 122 }
 123
 124
 125
 126 void
 127 WMSetScrollerArrowsPosition(WMScroller *sPtr, WMScrollArrowPosition position)
 128 {
 129     sPtr->flags.arrowsPosition = position;
 130     if (sPtr->view->flags.realized) {
 131         paintScroller(sPtr);
 132     }
 133 }
 134
 135
 136 static void
 137 willResizeScroller(W_ViewDelegate *self, WMView *view,
 138                    unsigned int *width, unsigned int *height)
 139 {
 140     WMScroller *sPtr = (WMScroller*)view->self;
 141
 142     if (*width > *height) {
 143         sPtr->flags.horizontal = 1;
 144         *height = SCROLLER_WIDTH;
 145     } else {
 146         sPtr->flags.horizontal = 0;
 147         *width = SCROLLER_WIDTH;
 148     }
 149 }
 150
 151
 152 void
 153 WMSetScrollerAction(WMScroller *sPtr, WMAction *action, void *clientData)
 154 {
 155     CHECK_CLASS(sPtr, WC_Scroller);
 156
 157     sPtr->action = action;
 158
 159     sPtr->clientData = clientData;
 160 }
 161
 162
 163 void
 164 WMSetScrollerParameters(WMScroller *sPtr, float floatValue,
 165                         float knobProportion)
 166 {
 167     CHECK_CLASS(sPtr, WC_Scroller);
 168
 169     if (floatValue < 0.0)
 170         sPtr->floatValue = 0.0;
 171     else if (floatValue > 1.0)
 172         sPtr->floatValue = 1.0;
 173     else
 174         sPtr->floatValue = floatValue;
 175
 176     if (knobProportion <= 0.0) {
 177
 178         sPtr->knobProportion = 0.0;
 179         sPtr->flags.documentFullyVisible = 0;
 180
 181     } else if (knobProportion >= 1.0) {
 182
 183         sPtr->knobProportion = 1.0;
 184         sPtr->flags.documentFullyVisible = 1;
 185
 186     } else {
 187         sPtr->knobProportion = knobProportion;
 188         sPtr->flags.documentFullyVisible = 0;
 189     }
 190
 191     if (sPtr->view->flags.realized)
 192         paintScroller(sPtr);
 193 }
 194
 195
 196 float
 197 WMGetScrollerKnobProportion(WMScroller *sPtr)
 198 {
 199     CHECK_CLASS(sPtr, WC_Scroller);
 200
 201     return sPtr->knobProportion;
 202 }
 203
 204
 205 float
 206 WMGetScrollerValue(WMScroller *sPtr)
 207 {
 208     CHECK_CLASS(sPtr, WC_Scroller);
 209
 210     return sPtr->floatValue;
 211 }
 212
 213
 214 WMScrollerPart
 215 WMGetScrollerHitPart(WMScroller *sPtr)
 216 {
 217     CHECK_CLASS(sPtr, WC_Scroller);
 218
 219     return sPtr->flags.hitPart;
 220 }
 221
 222
 223 static void
 224 paintArrow(WMScroller *sPtr, Drawable d, int part)
 225 /*
 226  * part- 0 paints the decrement arrow, 1 the increment arrow
 227  */
 228 {
 229     WMView *view = sPtr->view;
 230     WMScreen *scr = view->screen;
 231     int ofs, bsize;
 232     W_Pixmap *arrow;
 233
 234 #ifndef DOUBLE_BUFFER
 235     GC gc = scr->lightGC;
 236 #endif
 237
 238     bsize = SCROLLER_WIDTH - 4;
 239
 240
 241     if (part == 0) { /* decrement button */
 242         if (sPtr->flags.horizontal) {
 243             if (sPtr->flags.arrowsPosition == WSAMaxEnd) {
 244                 ofs = view->size.width - 2*(bsize+1) - 1;
 245             } else {
 246                 ofs = 2;
 247             }
 248             if (sPtr->flags.decrDown)
 249                 arrow = scr->hiLeftArrow;
 250             else
 251                 arrow = scr->leftArrow;
 252
 253         } else {
 254             if (sPtr->flags.arrowsPosition == WSAMaxEnd) {
 255                 ofs = view->size.height - 2*(bsize+1) - 1;
 256             } else {
 257                 ofs = 2;
 258             }
 259             if (sPtr->flags.decrDown)
 260                 arrow = scr->hiUpArrow;
 261             else
 262                 arrow = scr->upArrow;
 263         }
 264
 265 #ifndef DOUBLE_BUFFER
 266         if (sPtr->flags.decrDown)
 267             gc = WMColorGC(scr->white);
 268 #endif
 269     } else { /* increment button */
 270         if (sPtr->flags.horizontal) {
 271             if (sPtr->flags.arrowsPosition == WSAMaxEnd) {
 272                 ofs = view->size.width - bsize+1 - 3;
 273             } else {
 274                 ofs = 2 + bsize+1;
 275             }
 276             if (sPtr->flags.incrDown)
 277                 arrow = scr->hiRightArrow;
 278             else
 279                 arrow = scr->rightArrow;
 280         } else {
 281             if (sPtr->flags.arrowsPosition == WSAMaxEnd) {
 282                 ofs = view->size.height - bsize+1 - 3;
 283             } else {
 284                 ofs = 2 + bsize+1;
 285             }
 286             if (sPtr->flags.incrDown)
 287                 arrow = scr->hiDownArrow;
 288             else
 289                 arrow = scr->downArrow;
 290         }
 291
 292 #ifndef DOUBLE_BUFFER
 293         if (sPtr->flags.incrDown)
 294             gc = scr->whiteGC;
 295 #endif
 296     }
 297
 298
 299     if (sPtr->flags.horizontal) {
 300
 301         /* paint button */
 302 #ifndef DOUBLE_BUFFER
 303         XFillRectangle(scr->display, d, gc,
 304                        ofs+1, 2+1, bsize+1-3, bsize-3);
 305 #else
 306         if ((!part&&sPtr->flags.decrDown) || (part&&sPtr->flags.incrDown))
 307             XFillRectangle(scr->display, d, WMColorGC(scr->white),
 308                            ofs+1, 2+1, bsize+1-3, bsize-3);
 309 #endif /* DOUBLE_BUFFER */
 310         W_DrawRelief(scr, d, ofs, 2, bsize, bsize, WRRaised);
 311
 312         /* paint arrow */
 313         XSetClipMask(scr->display, scr->clipGC, arrow->mask);
 314         XSetClipOrigin(scr->display, scr->clipGC,
 315                        ofs + (bsize - arrow->width) / 2,
 316                        2 + (bsize - arrow->height) / 2);
 317
 318         XCopyArea(scr->display, arrow->pixmap, d, scr->clipGC,
 319                   0, 0, arrow->width, arrow->height,
 320                   ofs + (bsize - arrow->width) / 2,
 321                   2 + (bsize - arrow->height) / 2);
 322
 323     } else { /* vertical */
 324
 325         /* paint button */
 326 #ifndef DOUBLE_BUFFER
 327         XFillRectangle(scr->display, d, gc,
 328                        2+1, ofs+1, bsize-3, bsize+1-3);
 329 #else
 330         if ((!part&&sPtr->flags.decrDown) || (part&&sPtr->flags.incrDown))
 331             XFillRectangle(scr->display, d, WMColorGC(scr->white),
 332                            2+1, ofs+1, bsize-3, bsize+1-3);
 333 #endif /* DOUBLE_BUFFER */
 334         W_DrawRelief(scr, d, 2, ofs, bsize, bsize, WRRaised);
 335
 336         /* paint arrow */
 337
 338         XSetClipMask(scr->display, scr->clipGC, arrow->mask);
 339         XSetClipOrigin(scr->display, scr->clipGC,
 340                        2 + (bsize - arrow->width) / 2,
 341                        ofs + (bsize - arrow->height) / 2);
 342         XCopyArea(scr->display, arrow->pixmap, d, scr->clipGC,
 343                   0, 0, arrow->width, arrow->height,
 344                   2 + (bsize - arrow->width) / 2,
 345                   ofs + (bsize - arrow->height) / 2);
 346     }
 347 }
 348
 349
 350 static int
 351 knobLength(Scroller *sPtr)
 352 {
 353     int tmp, length;
 354
 355
 356     if (sPtr->flags.horizontal)
 357         length = sPtr->view->size.width - 4;
 358     else
 359         length = sPtr->view->size.height - 4;
 360
 361     if (sPtr->flags.arrowsPosition == WSAMaxEnd) {
 362         length -= (SCROLLER_WIDTH - 4 + 1)*2;
 363     } else if (sPtr->flags.arrowsPosition == WSAMinEnd) {
 364         length -= (SCROLLER_WIDTH - 4 + 1)*2;
 365     }
 366
 367     tmp = (int)((float)length * sPtr->knobProportion + 0.5);
 368     /* keep minimum size */
 369     if (tmp < SCROLLER_WIDTH-4)
 370         tmp = SCROLLER_WIDTH-4;
 371
 372     return tmp;
 373 }
 374
 375
 376 static void
 377 paintScroller(Scroller *sPtr)
 378 {
 379     WMView *view = sPtr->view;
 380     WMScreen *scr = view->screen;
 381 #ifdef DOUBLE_BUFFER
 382     Pixmap d;
 383 #else
 384     Drawable d = view->window;
 385 #endif
 386     int length, ofs;
 387     float knobP, knobL;
 388
 389
 390 #ifdef DOUBLE_BUFFER
 391     d = XCreatePixmap(scr->display, view->window, view->size.width,
 392                       view->size.height, scr->depth);
 393     XFillRectangle(scr->display, d, WMColorGC(scr->gray), 0, 0,
 394                    view->size.width, view->size.height);
 395 #endif
 396
 397     XDrawRectangle(scr->display, d, WMColorGC(scr->black), 0, 0,
 398                    view->size.width-1, view->size.height-1);
 399 #ifndef DOUBLE_BUFFER
 400     XDrawRectangle(scr->display, d, WMColorGC(scr->gray), 1, 1,
 401                    view->size.width-3, view->size.height-3);
 402 #endif
 403
 404     if (sPtr->flags.horizontal)
 405         length = view->size.width - 4;
 406     else
 407         length = view->size.height - 4;
 408
 409     if (sPtr->flags.documentFullyVisible) {
 410         XFillRectangle(scr->display, d, scr->stippleGC, 2, 2,
 411                        view->size.width-4, view->size.height-4);
 412     } else {
 413         if (sPtr->flags.arrowsPosition==WSAMaxEnd) {
 414             ofs = 0;
 415             length -= (SCROLLER_WIDTH - 4 + 1)*2;
 416         } else if (sPtr->flags.arrowsPosition==WSAMinEnd) {
 417             ofs = (SCROLLER_WIDTH - 4 + 1)*2;
 418             length -= (SCROLLER_WIDTH - 4 + 1)*2;
 419         } else {
 420             ofs = 0;
 421         }
 422
 423         knobL = (float)knobLength(sPtr);
 424
 425         knobP = sPtr->floatValue * ((float)length - knobL);
 426
 427
 428         if (sPtr->flags.horizontal) {
 429             /* before */
 430             XFillRectangle(scr->display, d, scr->stippleGC,
 431                            ofs+2, 2, (int)knobP, view->size.height-4);
 432
 433             /* knob */
 434 #ifndef DOUBLE_BUFFER
 435             XFillRectangle(scr->display, d, scr->lightGC,
 436                            ofs+2+(int)knobP+2, 2+2, (int)knobL-4,
 437                            view->size.height-4-4);
 438 #endif
 439             W_DrawRelief(scr, d, ofs+2+(int)knobP, 2, (int)knobL,
 440                          view->size.height-4, WRRaised);
 441
 442             XCopyArea(scr->display, scr->scrollerDimple->pixmap, d,
 443                       scr->copyGC, 0, 0,
 444                       scr->scrollerDimple->width, scr->scrollerDimple->height,
 445                       ofs+2+(int)knobP+((int)knobL-scr->scrollerDimple->width-1)/2,
 446                       (view->size.height-scr->scrollerDimple->height-1)/2);
 447
 448             /* after */
 449             if ((int)(knobP+knobL) < length)
 450                 XFillRectangle(scr->display, d, scr->stippleGC,
 451                                ofs+2+(int)(knobP+knobL), 2,
 452                                length-(int)(knobP+knobL),
 453                                view->size.height-4);
 454         } else {
 455             /* before */
 456             if (knobP>0.0)
 457                 XFillRectangle(scr->display, d, scr->stippleGC,
 458                                2, ofs+2, view->size.width-4, (int)knobP);
 459
 460             /* knob */
 461 #ifndef DOUBLE_BUFFER
 462             XFillRectangle(scr->display, d, scr->lightGC,
 463                            2+2, ofs+2+(int)knobP+2,
 464                            view->size.width-4-4, (int)knobL-4);
 465 #endif
 466             XCopyArea(scr->display, scr->scrollerDimple->pixmap, d,
 467                       scr->copyGC, 0, 0,
 468                       scr->scrollerDimple->width, scr->scrollerDimple->height,
 469                       (view->size.width-scr->scrollerDimple->width-1)/2,
 470                       ofs+2+(int)knobP+((int)knobL-scr->scrollerDimple->height-1)/2);
 471
 472             W_DrawRelief(scr, d, 2, ofs+2+(int)knobP,
 473                          view->size.width-4, (int)knobL, WRRaised);
 474
 475             /* after */
 476             if ((int)(knobP+knobL) < length)
 477                 XFillRectangle(scr->display, d, scr->stippleGC,
 478                                2, ofs+2+(int)(knobP+knobL),
 479                                view->size.width-4,
 480                                length-(int)(knobP+knobL));
 481         }
 482
 483         if (sPtr->flags.arrowsPosition != WSANone) {
 484             paintArrow(sPtr, d, 0);
 485             paintArrow(sPtr, d, 1);
 486         }
 487     }
 488
 489 #ifdef DOUBLE_BUFFER
 490     XCopyArea(scr->display, d, view->window, scr->copyGC, 0, 0,
 491               view->size.width, view->size.height, 0, 0);
 492     XFreePixmap(scr->display, d);
 493 #endif
 494 }
 495
 496
 497
 498 static void
 499 handleEvents(XEvent *event, void *data)
 500 {
 501     Scroller *sPtr = (Scroller*)data;
 502
 503     CHECK_CLASS(data, WC_Scroller);
 504
 505
 506     switch (event->type) {
 507      case Expose:
 508         if (event->xexpose.count==0)
 509             paintScroller(sPtr);
 510         break;
 511
 512      case DestroyNotify:
 513         destroyScroller(sPtr);
 514         break;
 515     }
 516 }
 517
 518
 519
 520 /*
 521  * locatePointInScroller-
 522  *     Return the part of the scroller where the point is located.
 523  */
 524 static WMScrollerPart
 525 locatePointInScroller(Scroller *sPtr, int x, int y, int alternate)
 526 {
 527     int width = sPtr->view->size.width;
 528     int height = sPtr->view->size.height;
 529     int c, p1, p2, p3, p4, p5, p6;
 530     int knobL, slotL;
 531
 532
 533     /* if there is no knob... */
 534     if (sPtr->flags.documentFullyVisible)
 535         return WSKnobSlot;
 536
 537     if (sPtr->flags.horizontal)
 538         c = x;
 539     else
 540         c = y;
 541
 542     /*     p1  p2           p3           p4   p5   p6
 543      * |   |   |###########|             |#####|   |   |
 544      * | < | > |###########|      O      |#####| < | > |
 545      * |   |   |###########|             |#####|   |   |
 546      */
 547
 548     if (sPtr->flags.arrowsPosition == WSAMinEnd) {
 549         p1 = 18;
 550         p2 = 36;
 551
 552         if (sPtr->flags.horizontal) {
 553             slotL = width - 36;
 554             p5 = width;
 555         } else {
 556             slotL = height - 36;
 557             p5 = height;
 558         }
 559         p6 = p5;
 560     } else if (sPtr->flags.arrowsPosition == WSAMaxEnd) {
 561         if (sPtr->flags.horizontal) {
 562             slotL = width - 36;
 563             p6 = width - 18;
 564         } else {
 565             slotL = height - 36;
 566             p6 = height - 18;
 567         }
 568         p5 = p6 - 18;
 569
 570         p1 = p2 = 0;
 571     } else {
 572         /* no arrows */
 573         p1 = p2 = 0;
 574
 575         if (sPtr->flags.horizontal) {
 576             slotL = p5 = p6 = width;
 577         } else {
 578             slotL = p5 = p6 = height;
 579         }
 580     }
 581
 582     knobL = knobLength(sPtr);
 583     p3 = p2 + (int)((float)(slotL-knobL) * sPtr->floatValue);
 584     p4 = p3 + knobL;
 585
 586     /* uses a mix of the NS and Win ways of doing scroll page */
 587     if (c <= p1)
 588         return alternate ? WSDecrementPage : WSDecrementLine;
 589     else if (c <= p2)
 590         return alternate ? WSIncrementPage : WSIncrementLine;
 591     else if (c <= p3)
 592         return WSDecrementPage;
 593     else if (c <= p4)
 594         return WSKnob;
 595     else if (c <= p5)
 596         return WSIncrementPage;
 597     else if (c <= p6)
 598         return alternate ? WSDecrementPage : WSDecrementLine;
 599     else
 600         return alternate ? WSIncrementPage : WSIncrementLine;
 601 }
 602
 603
 604
 605 static void
 606 handlePush(Scroller *sPtr, int pushX, int pushY, int alternate)
 607 {
 608     WMScrollerPart part;
 609     int doAction = 0;
 610
 611     part = locatePointInScroller(sPtr, pushX, pushY, alternate);
 612
 613     sPtr->flags.hitPart = part;
 614
 615     switch (part) {
 616      case WSIncrementLine:
 617         sPtr->flags.incrDown = 1;
 618         doAction = 1;
 619         break;
 620
 621      case WSIncrementPage:
 622         doAction = 1;
 623         break;
 624
 625      case WSDecrementLine:
 626         sPtr->flags.decrDown = 1;
 627         doAction = 1;
 628         break;
 629
 630      case WSDecrementPage:
 631         doAction = 1;
 632         break;
 633
 634      case WSKnob:
 635         sPtr->flags.draggingKnob = 1;
 636 #ifndef STRICT_NEXT_BEHAVIOUR
 637         if (sPtr->flags.horizontal)
 638             sPtr->dragPoint = pushX;
 639         else
 640             sPtr->dragPoint = pushY;
 641
 642         {
 643             int noButtons = (sPtr->flags.arrowsPosition == WSANone);
 644             int length, knobP;
 645
 646             if (sPtr->flags.horizontal)
 647                 length = sPtr->view->size.width - 4;
 648             else
 649                 length = sPtr->view->size.height - 4;
 650
 651             if (!noButtons)
 652                 length -= 36;
 653
 654             knobP = (int)(sPtr->floatValue * (float)(length-knobLength(sPtr)));
 655
 656             if (sPtr->flags.arrowsPosition == WSAMinEnd)
 657                 sPtr->dragPoint -= 2 + (noButtons ? 0 : 36) + knobP;
 658             else
 659                 sPtr->dragPoint -= 2 + knobP;
 660         }
 661 #endif /* STRICT_NEXT_BEHAVIOUR */
 662         /* This does not seem necesary here since we don't know yet if the
 663          * knob will be dragged later. -Dan
 664         handleMotion(sPtr, pushX, pushY); */
 665         break;
 666
 667      case WSKnobSlot:
 668      case WSNoPart:
 669         /* dummy */
 670         break;
 671     }
 672
 673     if (doAction && sPtr->action) {
 674         (*sPtr->action)(sPtr, sPtr->clientData);
 675     }
 676 }
 677
 678
 679 static float
 680 floatValueForPoint(int slotOfs, int slotLength, int knobLength, int point)
 681 {
 682     float floatValue = 0;
 683     float position;
 684
 685 #ifdef STRICT_NEXT_BEHAVIOUR
 686     if (point < slotOfs + knobLength/2)
 687         position = (float)(slotOfs + knobLength/2);
 688     else if (point > slotOfs + slotLength - knobLength/2)
 689         position = (float)(slotOfs + slotLength - knobLength/2);
 690     else
 691         position = (float)point;
 692
 693     floatValue = (position-(float)(slotOfs+slotLength/2))
 694         /(float)(slotLength-knobLength);
 695 #else
 696     /* Adjust the last point to lie inside the knob slot */
 697     if (point < slotOfs)
 698         position = (float)slotOfs;
 699     else if (point > slotOfs + slotLength)
 700         position = (float)(slotOfs + slotLength);
 701     else
 702         position = (float)point;
 703
 704     /* Compute the float value */
 705     floatValue = (position-(float)slotOfs) / (float)(slotLength-knobLength);
 706 #endif
 707
 708     return floatValue;
 709 }
 710
 711
 712 static void
 713 handleMotion(Scroller *sPtr, int mouseX, int mouseY)
 714 {
 715     int slotOffset;
 716     int slotLength;
 717     int noButtons = (sPtr->flags.arrowsPosition == WSANone);
 718
 719     if (sPtr->flags.arrowsPosition == WSAMinEnd)
 720         slotOffset = 2 + (noButtons ? 0 : 36);
 721     else
 722         slotOffset = 2;
 723
 724     if (sPtr->flags.draggingKnob) {
 725         float newFloatValue;
 726 #ifdef STRICT_NEXT_BEHAVIOUR
 727         if (sPtr->flags.horizontal) {
 728             slotLength = sPtr->view->size.width-4-(noButtons ? 0 : 36);
 729             newFloatValue = floatValueForPoint(slotOffset, slotLength,
 730                                        (int)(slotLength*sPtr->knobProportion),
 731                                        mouseX);
 732         } else {
 733             slotLength = sPtr->view->size.height-4-(noButtons ? 0 : 36);
 734             newFloatValue = floatValueForPoint(slotOffset, slotLength,
 735                                        (int)(slotLength*sPtr->knobProportion),
 736                                        mouseY);
 737         }
 738 #else
 739         if (sPtr->flags.horizontal) {
 740             slotLength = sPtr->view->size.width-4-(noButtons ? 0 : 36);
 741             newFloatValue = floatValueForPoint(slotOffset, slotLength,
 742                                        (int)(slotLength*sPtr->knobProportion),
 743                                        mouseX-sPtr->dragPoint);
 744         } else {
 745             slotLength = sPtr->view->size.height-4-(noButtons ? 0 : 36);
 746             newFloatValue = floatValueForPoint(slotOffset, slotLength,
 747                                        (int)(slotLength*sPtr->knobProportion),
 748                                        mouseY-sPtr->dragPoint);
 749         }
 750 #endif /* !STRICT_NEXT_BEHAVIOUR */
 751         WMSetScrollerParameters(sPtr, newFloatValue, sPtr->knobProportion);
 752         if (sPtr->action) {
 753             (*sPtr->action)(sPtr, sPtr->clientData);
 754         }
 755     } else {
 756         int part;
 757
 758         part = locatePointInScroller(sPtr, mouseX, mouseY, False);
 759
 760         sPtr->flags.hitPart = part;
 761
 762         if (part == WSIncrementLine && sPtr->flags.decrDown) {
 763             sPtr->flags.decrDown = 0;
 764             sPtr->flags.incrDown = 1;
 765         } else if (part == WSDecrementLine && sPtr->flags.incrDown) {
 766             sPtr->flags.incrDown = 0;
 767             sPtr->flags.decrDown = 1;
 768         } else if (part != WSIncrementLine && part != WSDecrementLine) {
 769             sPtr->flags.incrDown = 0;
 770             sPtr->flags.decrDown = 0;
 771         }
 772     }
 773 }
 774
 775
 776 static void
 777 autoScroll(void *clientData)
 778 {
 779     Scroller *sPtr = (Scroller*)clientData;
 780
 781     if (sPtr->action) {
 782         (*sPtr->action)(sPtr, sPtr->clientData);
 783     }
 784     sPtr->timerID= WMAddTimerHandler(AUTOSCROLL_DELAY, autoScroll, clientData);
 785 }
 786
 787
 788 static void
 789 handleActionEvents(XEvent *event, void *data)
 790 {
 791     Scroller *sPtr = (Scroller*)data;
 792     int id, dd;
 793
 794
 795     /* check if we're really dealing with a scroller, as something
 796      * might have gone wrong in the event dispatching stuff */
 797     CHECK_CLASS(sPtr, WC_Scroller);
 798
 799     id = sPtr->flags.incrDown;
 800     dd = sPtr->flags.decrDown;
 801
 802     switch (event->type) {
 803      case EnterNotify:
 804
 805         break;
 806
 807      case LeaveNotify:
 808         if (sPtr->timerID) {
 809             WMDeleteTimerHandler(sPtr->timerID);
 810             sPtr->timerID = NULL;
 811         }
 812         sPtr->flags.incrDown = 0;
 813         sPtr->flags.decrDown = 0;
 814         break;
 815
 816      case ButtonPress:
 817         /* FIXME: change Mod1Mask with something else */
 818         handlePush(sPtr, event->xbutton.x, event->xbutton.y,
 819                    (event->xbutton.state & Mod1Mask)
 820                    ||event->xbutton.button==Button2);
 821         /* continue scrolling if pushed on the buttons */
 822         if (sPtr->flags.hitPart == WSIncrementLine
 823             || sPtr->flags.hitPart == WSDecrementLine) {
 824             sPtr->timerID = WMAddTimerHandler(AUTOSCROLL_INITIAL_DELAY,
 825                                               autoScroll, sPtr);
 826         }
 827         break;
 828
 829      case ButtonRelease:
 830         if (sPtr->flags.draggingKnob) {
 831             if (sPtr->action) {
 832                 (*sPtr->action)(sPtr, sPtr->clientData);
 833             }
 834         }
 835         if (sPtr->timerID) {
 836             WMDeleteTimerHandler(sPtr->timerID);
 837             sPtr->timerID = NULL;
 838         }
 839         sPtr->flags.incrDown = 0;
 840         sPtr->flags.decrDown = 0;
 841         sPtr->flags.draggingKnob = 0;
 842         break;
 843
 844      case MotionNotify:
 845         handleMotion(sPtr, event->xbutton.x, event->xbutton.y);
 846         if (sPtr->timerID && sPtr->flags.hitPart != WSIncrementLine
 847             && sPtr->flags.hitPart != WSDecrementLine) {
 848             WMDeleteTimerHandler(sPtr->timerID);
 849             sPtr->timerID = NULL;
 850         }
 851         break;
 852     }
 853     if (id != sPtr->flags.incrDown || dd != sPtr->flags.decrDown)
 854         paintScroller(sPtr);
 855 }
 856
 857
 858
 859 static void
 860 destroyScroller(Scroller *sPtr)
 861 {
 862     /* we don't want autoscroll try to scroll a freed widget */
 863     if (sPtr->timerID) {
 864         WMDeleteTimerHandler(sPtr->timerID);
 865     }
 866
 867     wfree(sPtr);
 868 }
 869