WINGs/wscrollview.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7
   8 typedef struct W_ScrollView {
   9     W_Class widgetClass;
  10     WMView *view;
  11
  12     WMView *contentView;
  13     WMView *viewport;
  14
  15     WMScroller *vScroller;
  16     WMScroller *hScroller;
  17
  18     short lineScroll;
  19     short pageScroll;
  20
  21     struct {
  22         WMReliefType relief:3;
  23         unsigned int hasVScroller:1;
  24         unsigned int hasHScroller:1;
  25
  26     } flags;
  27
  28 } ScrollView;
  29
  30
  31
  32
  33 static void destroyScrollView(ScrollView *sPtr);
  34
  35 static void paintScrollView(ScrollView *sPtr);
  36 static void handleEvents(XEvent *event, void *data);
  37 static void handleViewportEvents(XEvent *event, void *data);
  38 static void resizeScrollView();
  39 static void updateScrollerProportion();
  40
  41 W_ViewDelegate _ScrollViewViewDelegate = {
  42     NULL,
  43         NULL,
  44         resizeScrollView,
  45         NULL,
  46         NULL
  47 };
  48
  49
  50
  51 WMScrollView*
  52 WMCreateScrollView(WMWidget *parent)
  53 {
  54     ScrollView *sPtr;
  55
  56     sPtr = wmalloc(sizeof(ScrollView));
  57     memset(sPtr, 0, sizeof(ScrollView));
  58
  59     sPtr->widgetClass = WC_ScrollView;
  60
  61     sPtr->view = W_CreateView(W_VIEW(parent));
  62     if (!sPtr->view) {
  63         wfree(sPtr);
  64         return NULL;
  65     }
  66     sPtr->viewport = W_CreateView(sPtr->view);
  67     if (!sPtr->viewport) {
  68         W_DestroyView(sPtr->view);
  69         wfree(sPtr);
  70         return NULL;
  71     }
  72     sPtr->view->self = sPtr;
  73     sPtr->viewport->self = sPtr;
  74
  75     sPtr->view->delegate = &_ScrollViewViewDelegate;
  76
  77     sPtr->viewport->flags.mapWhenRealized = 1;
  78
  79     WMCreateEventHandler(sPtr->view, StructureNotifyMask|ExposureMask,
  80                          handleEvents, sPtr);
  81     WMCreateEventHandler(sPtr->viewport, SubstructureNotifyMask,
  82                          handleViewportEvents, sPtr);
  83
  84     sPtr->lineScroll = 4;
  85
  86     sPtr->pageScroll = 0;
  87
  88     return sPtr;
  89 }
  90
  91
  92 static void
  93 applyScrollerValues(WMScrollView *sPtr)
  94 {
  95     int x, y;
  96
  97     if (sPtr->contentView == NULL)
  98         return;
  99
 100     if (sPtr->flags.hasHScroller) {
 101         float v = WMGetScrollerValue(sPtr->hScroller);
 102         int size;
 103
 104         size = sPtr->contentView->size.width-sPtr->viewport->size.width;
 105
 106         x = v * size;
 107     } else {
 108         x = 0;
 109     }
 110
 111     if (sPtr->flags.hasVScroller) {
 112         float v = WMGetScrollerValue(sPtr->vScroller);
 113
 114         int size;
 115
 116         size = sPtr->contentView->size.height-sPtr->viewport->size.height;
 117
 118         y = v * size;
 119     } else {
 120         y = 0;
 121     }
 122
 123
 124
 125     x = WMAX(0, x);
 126     y = WMAX(0, y);
 127
 128     W_MoveView(sPtr->contentView, -x, -y);
 129
 130     W_RaiseView(sPtr->viewport);
 131 }
 132
 133
 134 static void
 135 reorganizeInterior(WMScrollView *sPtr)
 136 {
 137     int hx, hy, hw;
 138     int vx, vy, vh;
 139     int cx, cy, cw, ch;
 140
 141
 142     cw = hw = sPtr->view->size.width;
 143     vh = ch = sPtr->view->size.height;
 144
 145     if (sPtr->flags.relief == WRSimple) {
 146         cw -= 2;
 147         ch -= 2;
 148         cx = 1;
 149         cy = 1;
 150     } else if (sPtr->flags.relief != WRFlat) {
 151         cw -= 3;
 152         ch -= 3;
 153         cx = 2;
 154         cy = 2;
 155     } else {
 156         cx = 0;
 157         cy = 0;
 158     }
 159
 160     if (sPtr->flags.hasHScroller) {
 161         int h = 20;
 162
 163         ch -= h;
 164
 165         if (sPtr->flags.relief == WRSimple) {
 166             hx = 0;
 167             hy = sPtr->view->size.height - h;
 168         } else if (sPtr->flags.relief != WRFlat) {
 169             hx = 1;
 170             hy = sPtr->view->size.height - h - 1;
 171             hw -= 2;
 172         } else {
 173             hx = 0;
 174             hy = sPtr->view->size.height - h;
 175         }
 176     } else {
 177         /* make compiler shutup */
 178         hx = 0;
 179         hy = 0;
 180     }
 181
 182     if (sPtr->flags.hasVScroller) {
 183         int w = 20;
 184         cw -= w;
 185         cx += w;
 186         hx += w - 1;
 187         hw -= w - 1;
 188
 189         if (sPtr->flags.relief == WRSimple) {
 190             vx = 0;
 191             vy = 0;
 192         } else if (sPtr->flags.relief != WRFlat) {
 193             vx = 1;
 194             vy = 1;
 195             vh -= 2;
 196         } else {
 197             vx = 0;
 198             vy = 0;
 199         }
 200     } else {
 201         /* make compiler shutup */
 202         vx = 0;
 203         vy = 0;
 204     }
 205
 206     W_ResizeView(sPtr->viewport, cw, ch);
 207     W_MoveView(sPtr->viewport, cx, cy);
 208
 209     if (sPtr->flags.hasHScroller) {
 210         WMResizeWidget(sPtr->hScroller, hw, 20);
 211         WMMoveWidget(sPtr->hScroller, hx, hy);
 212     }
 213     if (sPtr->flags.hasVScroller) {
 214         WMResizeWidget(sPtr->vScroller, 20, vh);
 215         WMMoveWidget(sPtr->vScroller, vx, vy);
 216     }
 217
 218     applyScrollerValues(sPtr);
 219 }
 220
 221
 222 static void
 223 resizeScrollView(W_ViewDelegate *self, WMView *view)
 224 {
 225     reorganizeInterior(view->self);
 226     updateScrollerProportion(view->self);
 227 }
 228
 229
 230
 231 void
 232 WMResizeScrollViewContent(WMScrollView *sPtr, unsigned int width,
 233                           unsigned int height)
 234 {
 235     int w, h, x;
 236
 237     w = width;
 238     h = height;
 239
 240     x = 0;
 241     if (sPtr->flags.relief == WRSimple) {
 242         w += 2;
 243         h += 2;
 244     } else if (sPtr->flags.relief != WRFlat) {
 245         w += 4;
 246         h += 4;
 247         x = 1;
 248     }
 249
 250     if (sPtr->flags.hasVScroller) {
 251         width -= W_VIEW(sPtr->hScroller)->size.width;
 252         WMResizeWidget(sPtr->vScroller, 20, h);
 253     }
 254     if (sPtr->flags.hasHScroller) {
 255         height -= W_VIEW(sPtr->hScroller)->size.height;
 256         WMResizeWidget(sPtr->hScroller, w, 20);
 257         WMMoveWidget(sPtr->hScroller, x, h);
 258     }
 259
 260     W_ResizeView(sPtr->view, w, h);
 261
 262     W_ResizeView(sPtr->viewport, width, height);
 263 }
 264
 265
 266 void
 267 WMSetScrollViewLineScroll(WMScrollView *sPtr, int amount)
 268 {
 269     assert(amount > 0);
 270
 271     sPtr->lineScroll = amount;
 272 }
 273
 274
 275 void
 276 WMSetScrollViewPageScroll(WMScrollView *sPtr, int amount)
 277 {
 278     assert(amount >= 0);
 279
 280     sPtr->pageScroll = amount;
 281 }
 282
 283
 284 WMRect
 285 WMGetScrollViewVisibleRect(WMScrollView *sPtr)
 286 {
 287     WMRect rect;
 288
 289     rect.pos.x = -sPtr->contentView->pos.x;
 290     rect.pos.y = -sPtr->contentView->pos.y;
 291     rect.size = sPtr->viewport->size;
 292
 293     return rect;
 294 }
 295
 296
 297 void
 298 WMScrollViewScrollPoint(WMScrollView *sPtr, WMPoint point)
 299 {
 300     float xsize, ysize;
 301     float xpos, ypos;
 302
 303     xsize = sPtr->contentView->size.width-sPtr->viewport->size.width;
 304     ysize = sPtr->contentView->size.height-sPtr->viewport->size.height;
 305
 306     xpos = point.x / xsize;
 307     ypos = point.y / ysize;
 308
 309     if (sPtr->hScroller)
 310         WMSetScrollerParameters(sPtr->hScroller, xpos,
 311                                 WMGetScrollerKnobProportion(sPtr->hScroller));
 312     if (sPtr->vScroller)
 313         WMSetScrollerParameters(sPtr->vScroller, ypos,
 314                                 WMGetScrollerKnobProportion(sPtr->vScroller));
 315
 316     W_MoveView(sPtr->contentView, -point.x, -point.y);
 317 }
 318
 319
 320 static void
 321 doScrolling(WMWidget *self, void *data)
 322 {
 323     ScrollView *sPtr = (ScrollView*)data;
 324     float value;
 325     int pos;
 326     int vpsize;
 327     float size;
 328
 329     if (sPtr->hScroller == (WMScroller *)self) {
 330         pos = -sPtr->contentView->pos.x;
 331         size = sPtr->contentView->size.width-sPtr->viewport->size.width;
 332         vpsize = sPtr->viewport->size.width - sPtr->pageScroll;
 333     } else {
 334         pos = -sPtr->contentView->pos.y;
 335         size = sPtr->contentView->size.height-sPtr->viewport->size.height;
 336         vpsize = sPtr->viewport->size.height - sPtr->pageScroll;
 337     }
 338     if (vpsize <= 0)
 339         vpsize = 1;
 340
 341     switch (WMGetScrollerHitPart(self)) {
 342     case WSDecrementLine:
 343         if (pos > 0) {
 344             pos-=sPtr->lineScroll;
 345             if (pos < 0)
 346                 pos = 0;
 347             value = (float)pos / size;
 348             WMSetScrollerParameters(self, value,
 349                                     WMGetScrollerKnobProportion(self));
 350         }
 351         break;
 352     case WSIncrementLine:
 353         if (pos < size) {
 354             pos+=sPtr->lineScroll;
 355             if (pos > size)
 356                 pos = size;
 357             value = (float)pos / size;
 358             WMSetScrollerParameters(self, value,
 359                                     WMGetScrollerKnobProportion(self));
 360         }
 361         break;
 362
 363     case WSKnob:
 364         value = WMGetScrollerValue(self);
 365         pos = value*size;
 366         break;
 367
 368     case WSDecrementPage:
 369         if (pos > 0) {
 370             pos -= vpsize;
 371             if (pos < 0)
 372                 pos = 0;
 373             value = (float)pos / size;
 374             WMSetScrollerParameters(self, value,
 375                                     WMGetScrollerKnobProportion(self));
 376         }
 377         break;
 378
 379     case WSDecrementWheel:
 380         if (pos > 0) {
 381             pos -= vpsize/3;
 382             if (pos < 0)
 383                 pos = 0;
 384             value = (float)pos / size;
 385             WMSetScrollerParameters(self, value,
 386                                     WMGetScrollerKnobProportion(self));
 387         }
 388         break;
 389
 390     case WSIncrementPage:
 391         if (pos < size) {
 392             pos += vpsize;
 393             if (pos > size)
 394                 pos = size;
 395             value = (float)pos / size;
 396             WMSetScrollerParameters(self, value,
 397                                     WMGetScrollerKnobProportion(self));
 398         }
 399         break;
 400
 401     case WSIncrementWheel:
 402         if (pos < size) {
 403             pos += vpsize/3;
 404             if (pos > size)
 405                 pos = size;
 406             value = (float)pos / size;
 407             WMSetScrollerParameters(self, value,
 408                                     WMGetScrollerKnobProportion(self));
 409         }
 410         break;
 411
 412      case WSNoPart:
 413      case WSKnobSlot:
 414         break;
 415     }
 416
 417     if (sPtr->hScroller == (WMScroller *)self) {
 418         W_MoveView(sPtr->contentView, -pos, sPtr->contentView->pos.y);
 419     } else {
 420         W_MoveView(sPtr->contentView, sPtr->contentView->pos.x, -pos);
 421     }
 422 }
 423
 424
 425 WMScroller*
 426 WMGetScrollViewHorizontalScroller(WMScrollView *sPtr)
 427 {
 428     return sPtr->hScroller;
 429 }
 430
 431
 432
 433 WMScroller*
 434 WMGetScrollViewVerticalScroller(WMScrollView *sPtr)
 435 {
 436     return sPtr->vScroller;
 437 }
 438
 439
 440 void
 441 WMSetScrollViewHasHorizontalScroller(WMScrollView *sPtr, Bool flag)
 442 {
 443     if (flag) {
 444         if (sPtr->flags.hasHScroller)
 445             return;
 446         sPtr->flags.hasHScroller = 1;
 447
 448         sPtr->hScroller = WMCreateScroller(sPtr);
 449         WMSetScrollerAction(sPtr->hScroller, doScrolling, sPtr);
 450         /* make it a horiz. scroller */
 451         WMResizeWidget(sPtr->hScroller, 2, 1);
 452
 453         if (W_VIEW_REALIZED(sPtr->view)) {
 454             WMRealizeWidget(sPtr->hScroller);
 455         }
 456
 457         reorganizeInterior(sPtr);
 458
 459         WMMapWidget(sPtr->hScroller);
 460     } else {
 461         if (!sPtr->flags.hasHScroller)
 462             return;
 463
 464         WMUnmapWidget(sPtr->hScroller);
 465         WMDestroyWidget(sPtr->hScroller);
 466         sPtr->hScroller = NULL;
 467         sPtr->flags.hasHScroller = 0;
 468
 469         reorganizeInterior(sPtr);
 470     }
 471 }
 472
 473
 474 void
 475 WMSetScrollViewHasVerticalScroller(WMScrollView *sPtr, Bool flag)
 476 {
 477     if (flag) {
 478         if (sPtr->flags.hasVScroller)
 479             return;
 480         sPtr->flags.hasVScroller = 1;
 481
 482         sPtr->vScroller = WMCreateScroller(sPtr);
 483         WMSetScrollerAction(sPtr->vScroller, doScrolling, sPtr);
 484         WMSetScrollerArrowsPosition(sPtr->vScroller, WSAMaxEnd);
 485         /* make it a vert. scroller */
 486         WMResizeWidget(sPtr->vScroller, 1, 2);
 487
 488         if (W_VIEW_REALIZED(sPtr->view)) {
 489             WMRealizeWidget(sPtr->vScroller);
 490         }
 491
 492         reorganizeInterior(sPtr);
 493
 494         WMMapWidget(sPtr->vScroller);
 495     } else {
 496         if (!sPtr->flags.hasVScroller)
 497             return;
 498         sPtr->flags.hasVScroller = 0;
 499
 500         WMUnmapWidget(sPtr->vScroller);
 501         WMDestroyWidget(sPtr->vScroller);
 502         sPtr->vScroller = NULL;
 503
 504         reorganizeInterior(sPtr);
 505     }
 506 }
 507
 508
 509 void
 510 WMSetScrollViewContentView(WMScrollView *sPtr, WMView *view)
 511 {
 512     assert(sPtr->contentView == NULL);
 513
 514     sPtr->contentView = view;
 515
 516     W_ReparentView(sPtr->contentView, sPtr->viewport, 0, 0);
 517
 518     if (sPtr->flags.hasHScroller) {
 519         float prop;
 520
 521         prop = (float)sPtr->viewport->size.width/sPtr->contentView->size.width;
 522         WMSetScrollerParameters(sPtr->hScroller, 0, prop);
 523     }
 524     if (sPtr->flags.hasVScroller) {
 525         float prop;
 526
 527         prop = (float)sPtr->viewport->size.height/sPtr->contentView->size.height;
 528
 529         WMSetScrollerParameters(sPtr->vScroller, 0, prop);
 530     }
 531 }
 532
 533
 534 void
 535 WMSetScrollViewRelief(WMScrollView *sPtr, WMReliefType type)
 536 {
 537     sPtr->flags.relief = type;
 538
 539     reorganizeInterior(sPtr);
 540
 541     if (sPtr->view->flags.mapped)
 542         paintScrollView(sPtr);
 543
 544
 545 }
 546
 547
 548
 549 static void
 550 paintScrollView(ScrollView *sPtr)
 551 {
 552     W_DrawRelief(sPtr->view->screen, sPtr->view->window, 0, 0,
 553                  sPtr->view->size.width, sPtr->view->size.height,
 554                  sPtr->flags.relief);
 555 }
 556
 557
 558 static void
 559 updateScrollerProportion(ScrollView *sPtr)
 560 {
 561     float prop, value;
 562     float oldV, oldP;
 563
 564     if (sPtr->flags.hasHScroller) {
 565         oldV = WMGetScrollerValue(sPtr->hScroller);
 566         oldP = WMGetScrollerKnobProportion(sPtr->hScroller);
 567
 568         prop = (float)sPtr->viewport->size.width/(float)sPtr->contentView->size.width;
 569
 570         if (oldP == 1.0)
 571             value = 0;
 572         else
 573             value = (prop * oldV) / oldP;
 574         WMSetScrollerParameters(sPtr->hScroller, value, prop);
 575     }
 576     if (sPtr->flags.hasVScroller) {
 577         oldV = WMGetScrollerValue(sPtr->vScroller);
 578         oldP = WMGetScrollerKnobProportion(sPtr->vScroller);
 579
 580         prop = (float)sPtr->viewport->size.height/(float)sPtr->contentView->size.height;
 581
 582         if (oldP == 1.0)
 583             value = 0;
 584         else
 585             value = (prop * oldV) / oldP;
 586         WMSetScrollerParameters(sPtr->vScroller, value, prop);
 587     }
 588     applyScrollerValues(sPtr);
 589 }
 590
 591
 592 static void
 593 handleViewportEvents(XEvent *event, void *data)
 594 {
 595     ScrollView *sPtr = (ScrollView*)data;
 596
 597     if (sPtr->contentView
 598         && event->xconfigure.window == sPtr->contentView->window)
 599         updateScrollerProportion(sPtr);
 600 }
 601
 602
 603 static void
 604 handleEvents(XEvent *event, void *data)
 605 {
 606     ScrollView *sPtr = (ScrollView*)data;
 607
 608     CHECK_CLASS(data, WC_ScrollView);
 609
 610     switch (event->type) {
 611      case Expose:
 612         if (event->xexpose.count!=0)
 613             break;
 614         if (event->xexpose.serial == 0) /* means it's artificial */
 615             W_RedisplayView(sPtr->contentView);
 616         else
 617             paintScrollView(sPtr);
 618         break;
 619
 620      case DestroyNotify:
 621         destroyScrollView(sPtr);
 622         break;
 623
 624     }
 625 }
 626
 627
 628 static void
 629 destroyScrollView(ScrollView *sPtr)
 630 {
 631     wfree(sPtr);
 632 }
 633