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         WMResizeWidget(sPtr->vScroller, 20, h);
 252         width -= W_VIEW(sPtr->vScroller)->size.width;
 253     }
 254
 255     if (sPtr->flags.hasHScroller) {
 256         WMResizeWidget(sPtr->hScroller, w, 20);
 257         WMMoveWidget(sPtr->hScroller, x, h);
 258         height -= W_VIEW(sPtr->hScroller)->size.height;
 259     }
 260
 261     W_ResizeView(sPtr->view, w, h);
 262
 263     W_ResizeView(sPtr->viewport, width, height);
 264 }
 265
 266
 267 void
 268 WMSetScrollViewLineScroll(WMScrollView *sPtr, int amount)
 269 {
 270     assert(amount > 0);
 271
 272     sPtr->lineScroll = amount;
 273 }
 274
 275
 276 void
 277 WMSetScrollViewPageScroll(WMScrollView *sPtr, int amount)
 278 {
 279     assert(amount >= 0);
 280
 281     sPtr->pageScroll = amount;
 282 }
 283
 284
 285 WMRect
 286 WMGetScrollViewVisibleRect(WMScrollView *sPtr)
 287 {
 288     WMRect rect;
 289
 290     rect.pos.x = -sPtr->contentView->pos.x;
 291     rect.pos.y = -sPtr->contentView->pos.y;
 292     rect.size = sPtr->viewport->size;
 293
 294     return rect;
 295 }
 296
 297
 298 void
 299 WMScrollViewScrollPoint(WMScrollView *sPtr, WMPoint point)
 300 {
 301     float xsize, ysize;
 302     float xpos, ypos;
 303
 304     xsize = sPtr->contentView->size.width-sPtr->viewport->size.width;
 305     ysize = sPtr->contentView->size.height-sPtr->viewport->size.height;
 306
 307     xpos = point.x / xsize;
 308     ypos = point.y / ysize;
 309
 310     if (sPtr->hScroller)
 311         WMSetScrollerParameters(sPtr->hScroller, xpos,
 312                                 WMGetScrollerKnobProportion(sPtr->hScroller));
 313     if (sPtr->vScroller)
 314         WMSetScrollerParameters(sPtr->vScroller, ypos,
 315                                 WMGetScrollerKnobProportion(sPtr->vScroller));
 316
 317     W_MoveView(sPtr->contentView, -point.x, -point.y);
 318 }
 319
 320
 321 static void
 322 doScrolling(WMWidget *self, void *data)
 323 {
 324     ScrollView *sPtr = (ScrollView*)data;
 325     float value;
 326     int pos;
 327     int vpsize;
 328     float size;
 329
 330     if (sPtr->hScroller == (WMScroller *)self) {
 331         pos = -sPtr->contentView->pos.x;
 332         size = sPtr->contentView->size.width-sPtr->viewport->size.width;
 333         vpsize = sPtr->viewport->size.width - sPtr->pageScroll;
 334     } else {
 335         pos = -sPtr->contentView->pos.y;
 336         size = sPtr->contentView->size.height-sPtr->viewport->size.height;
 337         vpsize = sPtr->viewport->size.height - sPtr->pageScroll;
 338     }
 339     if (vpsize <= 0)
 340         vpsize = 1;
 341
 342     switch (WMGetScrollerHitPart(self)) {
 343     case WSDecrementLine:
 344         if (pos > 0) {
 345             pos-=sPtr->lineScroll;
 346             if (pos < 0)
 347                 pos = 0;
 348             value = (float)pos / size;
 349             WMSetScrollerParameters(self, value,
 350                                     WMGetScrollerKnobProportion(self));
 351         }
 352         break;
 353     case WSIncrementLine:
 354         if (pos < size) {
 355             pos+=sPtr->lineScroll;
 356             if (pos > size)
 357                 pos = size;
 358             value = (float)pos / size;
 359             WMSetScrollerParameters(self, value,
 360                                     WMGetScrollerKnobProportion(self));
 361         }
 362         break;
 363
 364     case WSKnob:
 365         value = WMGetScrollerValue(self);
 366         pos = value*size;
 367         break;
 368
 369     case WSDecrementPage:
 370         if (pos > 0) {
 371             pos -= vpsize;
 372             if (pos < 0)
 373                 pos = 0;
 374             value = (float)pos / size;
 375             WMSetScrollerParameters(self, value,
 376                                     WMGetScrollerKnobProportion(self));
 377         }
 378         break;
 379
 380     case WSDecrementWheel:
 381         if (pos > 0) {
 382             pos -= vpsize/3;
 383             if (pos < 0)
 384                 pos = 0;
 385             value = (float)pos / size;
 386             WMSetScrollerParameters(self, value,
 387                                     WMGetScrollerKnobProportion(self));
 388         }
 389         break;
 390
 391     case WSIncrementPage:
 392         if (pos < size) {
 393             pos += vpsize;
 394             if (pos > size)
 395                 pos = size;
 396             value = (float)pos / size;
 397             WMSetScrollerParameters(self, value,
 398                                     WMGetScrollerKnobProportion(self));
 399         }
 400         break;
 401
 402     case WSIncrementWheel:
 403         if (pos < size) {
 404             pos += vpsize/3;
 405             if (pos > size)
 406                 pos = size;
 407             value = (float)pos / size;
 408             WMSetScrollerParameters(self, value,
 409                                     WMGetScrollerKnobProportion(self));
 410         }
 411         break;
 412
 413     case WSNoPart:
 414     case WSKnobSlot:
 415         break;
 416     }
 417
 418     if (sPtr->hScroller == (WMScroller *)self) {
 419         W_MoveView(sPtr->contentView, -pos, sPtr->contentView->pos.y);
 420     } else {
 421         W_MoveView(sPtr->contentView, sPtr->contentView->pos.x, -pos);
 422     }
 423 }
 424
 425
 426 WMScroller*
 427 WMGetScrollViewHorizontalScroller(WMScrollView *sPtr)
 428 {
 429     return sPtr->hScroller;
 430 }
 431
 432
 433
 434 WMScroller*
 435 WMGetScrollViewVerticalScroller(WMScrollView *sPtr)
 436 {
 437     return sPtr->vScroller;
 438 }
 439
 440
 441 void
 442 WMSetScrollViewHasHorizontalScroller(WMScrollView *sPtr, Bool flag)
 443 {
 444     if (flag) {
 445         if (sPtr->flags.hasHScroller)
 446             return;
 447         sPtr->flags.hasHScroller = 1;
 448
 449         sPtr->hScroller = WMCreateScroller(sPtr);
 450         WMSetScrollerAction(sPtr->hScroller, doScrolling, sPtr);
 451         /* make it a horiz. scroller */
 452         WMResizeWidget(sPtr->hScroller, 2, 1);
 453
 454         if (W_VIEW_REALIZED(sPtr->view)) {
 455             WMRealizeWidget(sPtr->hScroller);
 456         }
 457
 458         reorganizeInterior(sPtr);
 459
 460         WMMapWidget(sPtr->hScroller);
 461     } else {
 462         if (!sPtr->flags.hasHScroller)
 463             return;
 464
 465         WMUnmapWidget(sPtr->hScroller);
 466         WMDestroyWidget(sPtr->hScroller);
 467         sPtr->hScroller = NULL;
 468         sPtr->flags.hasHScroller = 0;
 469
 470         reorganizeInterior(sPtr);
 471     }
 472 }
 473
 474
 475 void
 476 WMSetScrollViewHasVerticalScroller(WMScrollView *sPtr, Bool flag)
 477 {
 478     if (flag) {
 479         if (sPtr->flags.hasVScroller)
 480             return;
 481         sPtr->flags.hasVScroller = 1;
 482
 483         sPtr->vScroller = WMCreateScroller(sPtr);
 484         WMSetScrollerAction(sPtr->vScroller, doScrolling, sPtr);
 485         WMSetScrollerArrowsPosition(sPtr->vScroller, WSAMaxEnd);
 486         /* make it a vert. scroller */
 487         WMResizeWidget(sPtr->vScroller, 1, 2);
 488
 489         if (W_VIEW_REALIZED(sPtr->view)) {
 490             WMRealizeWidget(sPtr->vScroller);
 491         }
 492
 493         reorganizeInterior(sPtr);
 494
 495         WMMapWidget(sPtr->vScroller);
 496     } else {
 497         if (!sPtr->flags.hasVScroller)
 498             return;
 499         sPtr->flags.hasVScroller = 0;
 500
 501         WMUnmapWidget(sPtr->vScroller);
 502         WMDestroyWidget(sPtr->vScroller);
 503         sPtr->vScroller = NULL;
 504
 505         reorganizeInterior(sPtr);
 506     }
 507 }
 508
 509
 510 void
 511 WMSetScrollViewContentView(WMScrollView *sPtr, WMView *view)
 512 {
 513     assert(sPtr->contentView == NULL);
 514
 515     sPtr->contentView = view;
 516
 517     W_ReparentView(sPtr->contentView, sPtr->viewport, 0, 0);
 518
 519     if (sPtr->flags.hasHScroller) {
 520         float prop;
 521
 522         prop = (float)sPtr->viewport->size.width/sPtr->contentView->size.width;
 523         WMSetScrollerParameters(sPtr->hScroller, 0, prop);
 524     }
 525     if (sPtr->flags.hasVScroller) {
 526         float prop;
 527
 528         prop = (float)sPtr->viewport->size.height/sPtr->contentView->size.height;
 529
 530         WMSetScrollerParameters(sPtr->vScroller, 0, prop);
 531     }
 532 }
 533
 534
 535 void
 536 WMSetScrollViewRelief(WMScrollView *sPtr, WMReliefType type)
 537 {
 538     sPtr->flags.relief = type;
 539
 540     reorganizeInterior(sPtr);
 541
 542     if (sPtr->view->flags.mapped)
 543         paintScrollView(sPtr);
 544
 545
 546 }
 547
 548
 549
 550 static void
 551 paintScrollView(ScrollView *sPtr)
 552 {
 553     W_DrawRelief(sPtr->view->screen, sPtr->view->window, 0, 0,
 554                  sPtr->view->size.width, sPtr->view->size.height,
 555                  sPtr->flags.relief);
 556 }
 557
 558
 559 static void
 560 updateScrollerProportion(ScrollView *sPtr)
 561 {
 562     float prop, value;
 563     float oldV, oldP;
 564
 565     if (sPtr->flags.hasHScroller) {
 566         oldV = WMGetScrollerValue(sPtr->hScroller);
 567         oldP = WMGetScrollerKnobProportion(sPtr->hScroller);
 568
 569         prop = (float)sPtr->viewport->size.width/(float)sPtr->contentView->size.width;
 570
 571         if (oldP == 1.0)
 572             value = 0;
 573         else
 574             value = (prop * oldV) / oldP;
 575         WMSetScrollerParameters(sPtr->hScroller, value, prop);
 576     }
 577     if (sPtr->flags.hasVScroller) {
 578         oldV = WMGetScrollerValue(sPtr->vScroller);
 579         oldP = WMGetScrollerKnobProportion(sPtr->vScroller);
 580
 581         prop = (float)sPtr->viewport->size.height/(float)sPtr->contentView->size.height;
 582
 583         if (oldP == 1.0)
 584             value = 0;
 585         else
 586             value = (prop * oldV) / oldP;
 587         WMSetScrollerParameters(sPtr->vScroller, value, prop);
 588     }
 589     applyScrollerValues(sPtr);
 590 }
 591
 592
 593 static void
 594 handleViewportEvents(XEvent *event, void *data)
 595 {
 596     ScrollView *sPtr = (ScrollView*)data;
 597
 598     if (sPtr->contentView
 599         && event->xconfigure.window == sPtr->contentView->window)
 600         updateScrollerProportion(sPtr);
 601 }
 602
 603
 604 static void
 605 handleEvents(XEvent *event, void *data)
 606 {
 607     ScrollView *sPtr = (ScrollView*)data;
 608
 609     CHECK_CLASS(data, WC_ScrollView);
 610
 611     switch (event->type) {
 612     case Expose:
 613         if (event->xexpose.count!=0)
 614             break;
 615         if (event->xexpose.serial == 0) /* means it's artificial */
 616             W_RedisplayView(sPtr->contentView);
 617         else
 618             paintScrollView(sPtr);
 619         break;
 620
 621     case DestroyNotify:
 622         destroyScrollView(sPtr);
 623         break;
 624
 625     }
 626 }
 627
 628
 629 static void
 630 destroyScrollView(ScrollView *sPtr)
 631 {
 632     wfree(sPtr);
 633 }
 634