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.width-sPtr->viewport->size.width;
 117
 118         y = v * size;
 119     } else {
 120         y = 0;
 121     }
 122
 123     x = WMAX(0, x);
 124     y = WMAX(0, y);
 125
 126     W_MoveView(sPtr->contentView, -x, -y);
 127
 128     W_RaiseView(sPtr->viewport);
 129 }
 130
 131
 132 static void
 133 reorganizeInterior(WMScrollView *sPtr)
 134 {
 135     int hx, hy, hw;
 136     int vx, vy, vh;
 137     int cx, cy, cw, ch;
 138
 139
 140     cw = hw = sPtr->view->size.width;
 141     vh = ch = sPtr->view->size.height;
 142
 143     if (sPtr->flags.relief == WRSimple) {
 144         cw -= 2;
 145         ch -= 2;
 146         cx = 1;
 147         cy = 1;
 148     } else if (sPtr->flags.relief != WRFlat) {
 149         cw -= 3;
 150         ch -= 3;
 151         cx = 2;
 152         cy = 2;
 153     } else {
 154         cx = 0;
 155         cy = 0;
 156     }
 157
 158     if (sPtr->flags.hasHScroller) {
 159         int h = 20;
 160
 161         ch -= h;
 162
 163         if (sPtr->flags.relief == WRSimple) {
 164             hx = 0;
 165             hy = sPtr->view->size.height - h;
 166         } else if (sPtr->flags.relief != WRFlat) {
 167             hx = 1;
 168             hy = sPtr->view->size.height - h - 1;
 169             hw -= 2;
 170         } else {
 171             hx = 0;
 172             hy = sPtr->view->size.height - h;
 173         }
 174     } else {
 175         /* make compiler shutup */
 176         hx = 0;
 177         hy = 0;
 178     }
 179
 180     if (sPtr->flags.hasVScroller) {
 181         int w = 20;
 182         cw -= w;
 183         cx += w;
 184         hx += w - 1;
 185         hw -= w - 1;
 186
 187         if (sPtr->flags.relief == WRSimple) {
 188             vx = 0;
 189             vy = 0;
 190         } else if (sPtr->flags.relief != WRFlat) {
 191             vx = 1;
 192             vy = 1;
 193             vh -= 2;
 194         } else {
 195             vx = 0;
 196             vy = 0;
 197         }
 198     } else {
 199         /* make compiler shutup */
 200         vx = 0;
 201         vy = 0;
 202     }
 203
 204     W_ResizeView(sPtr->viewport, cw, ch);
 205     W_MoveView(sPtr->viewport, cx, cy);
 206
 207     if (sPtr->flags.hasHScroller) {
 208         WMResizeWidget(sPtr->hScroller, hw, 20);
 209         WMMoveWidget(sPtr->hScroller, hx, hy);
 210     }
 211     if (sPtr->flags.hasVScroller) {
 212         WMResizeWidget(sPtr->vScroller, 20, vh);
 213         WMMoveWidget(sPtr->vScroller, vx, vy);
 214     }
 215
 216     applyScrollerValues(sPtr);
 217 }
 218
 219
 220 static void
 221 resizeScrollView(W_ViewDelegate *self, WMView *view)
 222 {
 223     reorganizeInterior(view->self);
 224     updateScrollerProportion(view->self);
 225 }
 226
 227
 228
 229 void
 230 WMResizeScrollViewContent(WMScrollView *sPtr, unsigned int width,
 231                           unsigned int height)
 232 {
 233     int w, h, x;
 234
 235     w = width;
 236     h = height;
 237
 238     x = 0;
 239     if (sPtr->flags.relief == WRSimple) {
 240         w += 2;
 241         h += 2;
 242     } else if (sPtr->flags.relief != WRFlat) {
 243         w += 4;
 244         h += 4;
 245         x = 1;
 246     }
 247
 248     if (sPtr->flags.hasVScroller) {
 249         width -= W_VIEW(sPtr->hScroller)->size.width;
 250         WMResizeWidget(sPtr->vScroller, 20, h);
 251     }
 252     if (sPtr->flags.hasHScroller) {
 253         height -= W_VIEW(sPtr->hScroller)->size.height;
 254         WMResizeWidget(sPtr->hScroller, w, 20);
 255         WMMoveWidget(sPtr->hScroller, x, h);
 256     }
 257
 258     W_ResizeView(sPtr->view, w, h);
 259
 260     W_ResizeView(sPtr->viewport, width, height);
 261 }
 262
 263
 264 void
 265 WMSetScrollViewLineScroll(WMScrollView *sPtr, int amount)
 266 {
 267     assert(amount > 0);
 268
 269     sPtr->lineScroll = amount;
 270 }
 271
 272
 273 void
 274 WMSetScrollViewPageScroll(WMScrollView *sPtr, int amount)
 275 {
 276     assert(amount >= 0);
 277
 278     sPtr->pageScroll = amount;
 279 }
 280
 281
 282 WMRect
 283 WMGetScrollViewVisibleRect(WMScrollView *sPtr)
 284 {
 285     WMRect rect;
 286
 287     rect.pos.x = -sPtr->contentView->pos.x;
 288     rect.pos.y = -sPtr->contentView->pos.y;
 289     rect.size = sPtr->viewport->size;
 290
 291     return rect;
 292 }
 293
 294
 295 void
 296 WMScrollViewScrollPoint(WMScrollView *sPtr, WMPoint point)
 297 {
 298     float xsize, ysize;
 299     float xpos, ypos;
 300
 301     xsize = sPtr->contentView->size.width-sPtr->viewport->size.width;
 302     ysize = sPtr->contentView->size.height-sPtr->viewport->size.height;
 303
 304     xpos = point.x / xsize;
 305     ypos = point.y / ysize;
 306
 307     if (sPtr->hScroller)
 308         WMSetScrollerParameters(sPtr->hScroller, xpos,
 309                                 WMGetScrollerKnobProportion(sPtr->hScroller));
 310     if (sPtr->vScroller)
 311         WMSetScrollerParameters(sPtr->vScroller, ypos,
 312                                 WMGetScrollerKnobProportion(sPtr->vScroller));
 313
 314     W_MoveView(sPtr->contentView, -point.x, -point.y);
 315 }
 316
 317
 318 static void
 319 doScrolling(WMWidget *self, void *data)
 320 {
 321     ScrollView *sPtr = (ScrollView*)data;
 322     float value;
 323     int pos;
 324     int vpsize;
 325     float size;
 326
 327     if (sPtr->hScroller == (WMScroller *)self) {
 328         pos = -sPtr->contentView->pos.x;
 329         size = sPtr->contentView->size.width-sPtr->viewport->size.width;
 330         vpsize = sPtr->viewport->size.width - sPtr->pageScroll;
 331     } else {
 332         pos = -sPtr->contentView->pos.y;
 333         size = sPtr->contentView->size.height-sPtr->viewport->size.height;
 334         vpsize = sPtr->viewport->size.height - sPtr->pageScroll;
 335     }
 336     if (vpsize <= 0)
 337         vpsize = 1;
 338
 339     switch (WMGetScrollerHitPart(self)) {
 340     case WSDecrementLine:
 341         if (pos > 0) {
 342             pos-=sPtr->lineScroll;
 343             if (pos < 0)
 344                 pos = 0;
 345             value = (float)pos / size;
 346             WMSetScrollerParameters(self, value,
 347                                     WMGetScrollerKnobProportion(self));
 348         }
 349         break;
 350     case WSIncrementLine:
 351         if (pos < size) {
 352             pos+=sPtr->lineScroll;
 353             if (pos > size)
 354                 pos = size;
 355             value = (float)pos / size;
 356             WMSetScrollerParameters(self, value,
 357                                     WMGetScrollerKnobProportion(self));
 358         }
 359         break;
 360
 361     case WSKnob:
 362         value = WMGetScrollerValue(self);
 363         pos = value*size;
 364         break;
 365
 366     case WSDecrementPage:
 367         if (pos > 0) {
 368             pos -= vpsize;
 369             if (pos < 0)
 370                 pos = 0;
 371             value = (float)pos / size;
 372             WMSetScrollerParameters(self, value,
 373                                     WMGetScrollerKnobProportion(self));
 374         }
 375         break;
 376
 377     case WSDecrementWheel:
 378         if (pos > 0) {
 379             pos -= vpsize/3;
 380             if (pos < 0)
 381                 pos = 0;
 382             value = (float)pos / size;
 383             WMSetScrollerParameters(self, value,
 384                                     WMGetScrollerKnobProportion(self));
 385         }
 386         break;
 387
 388     case WSIncrementPage:
 389         if (pos < size) {
 390             pos += vpsize;
 391             if (pos > size)
 392                 pos = size;
 393             value = (float)pos / size;
 394             WMSetScrollerParameters(self, value,
 395                                     WMGetScrollerKnobProportion(self));
 396         }
 397         break;
 398
 399     case WSIncrementWheel:
 400         if (pos < size) {
 401             pos += vpsize/3;
 402             if (pos > size)
 403                 pos = size;
 404             value = (float)pos / size;
 405             WMSetScrollerParameters(self, value,
 406                                     WMGetScrollerKnobProportion(self));
 407         }
 408         break;
 409
 410      case WSNoPart:
 411      case WSKnobSlot:
 412         break;
 413     }
 414
 415     if (sPtr->hScroller == (WMScroller *)self) {
 416         W_MoveView(sPtr->contentView, -pos, sPtr->contentView->pos.y);
 417     } else {
 418         W_MoveView(sPtr->contentView, sPtr->contentView->pos.x, -pos);
 419     }
 420 }
 421
 422
 423 WMScroller*
 424 WMGetScrollViewHorizontalScroller(WMScrollView *sPtr)
 425 {
 426     return sPtr->hScroller;
 427 }
 428
 429
 430
 431 WMScroller*
 432 WMGetScrollViewVerticalScroller(WMScrollView *sPtr)
 433 {
 434     return sPtr->vScroller;
 435 }
 436
 437
 438 void
 439 WMSetScrollViewHasHorizontalScroller(WMScrollView *sPtr, Bool flag)
 440 {
 441     if (flag) {
 442         if (sPtr->flags.hasHScroller)
 443             return;
 444         sPtr->flags.hasHScroller = 1;
 445
 446         sPtr->hScroller = WMCreateScroller(sPtr);
 447         WMSetScrollerAction(sPtr->hScroller, doScrolling, sPtr);
 448         /* make it a horiz. scroller */
 449         WMResizeWidget(sPtr->hScroller, 2, 1);
 450
 451         reorganizeInterior(sPtr);
 452
 453         WMMapWidget(sPtr->hScroller);
 454     } else {
 455         if (!sPtr->flags.hasHScroller)
 456             return;
 457
 458         WMUnmapWidget(sPtr->hScroller);
 459         WMDestroyWidget(sPtr->hScroller);
 460         sPtr->hScroller = NULL;
 461         sPtr->flags.hasHScroller = 0;
 462
 463         reorganizeInterior(sPtr);
 464     }
 465 }
 466
 467
 468 void
 469 WMSetScrollViewHasVerticalScroller(WMScrollView *sPtr, Bool flag)
 470 {
 471     if (flag) {
 472         if (sPtr->flags.hasVScroller)
 473             return;
 474         sPtr->flags.hasVScroller = 1;
 475
 476         sPtr->vScroller = WMCreateScroller(sPtr);
 477         WMSetScrollerAction(sPtr->vScroller, doScrolling, sPtr);
 478         WMSetScrollerArrowsPosition(sPtr->vScroller, WSAMaxEnd);
 479         /* make it a vert. scroller */
 480         WMResizeWidget(sPtr->vScroller, 1, 2);
 481
 482         reorganizeInterior(sPtr);
 483
 484         WMMapWidget(sPtr->vScroller);
 485     } else {
 486         if (!sPtr->flags.hasVScroller)
 487             return;
 488         sPtr->flags.hasVScroller = 0;
 489
 490         WMUnmapWidget(sPtr->vScroller);
 491         WMDestroyWidget(sPtr->vScroller);
 492         sPtr->vScroller = NULL;
 493
 494         reorganizeInterior(sPtr);
 495     }
 496 }
 497
 498
 499 void
 500 WMSetScrollViewContentView(WMScrollView *sPtr, WMView *view)
 501 {
 502     assert(sPtr->contentView == NULL);
 503
 504     sPtr->contentView = view;
 505
 506     W_ReparentView(sPtr->contentView, sPtr->viewport, 0, 0);
 507
 508     if (sPtr->flags.hasHScroller) {
 509         float prop;
 510
 511         prop = (float)sPtr->viewport->size.width/sPtr->contentView->size.width;
 512         WMSetScrollerParameters(sPtr->hScroller, 0, prop);
 513     }
 514     if (sPtr->flags.hasVScroller) {
 515         float prop;
 516
 517         prop = (float)sPtr->viewport->size.height/sPtr->contentView->size.height;
 518
 519         WMSetScrollerParameters(sPtr->vScroller, 0, prop);
 520     }
 521 }
 522
 523
 524 void
 525 WMSetScrollViewRelief(WMScrollView *sPtr, WMReliefType type)
 526 {
 527     sPtr->flags.relief = type;
 528
 529     reorganizeInterior(sPtr);
 530
 531     if (sPtr->view->flags.mapped)
 532         paintScrollView(sPtr);
 533
 534
 535 }
 536
 537
 538
 539 static void
 540 paintScrollView(ScrollView *sPtr)
 541 {
 542     W_DrawRelief(sPtr->view->screen, sPtr->view->window, 0, 0,
 543                  sPtr->view->size.width, sPtr->view->size.height,
 544                  sPtr->flags.relief);
 545 }
 546
 547
 548 static void
 549 updateScrollerProportion(ScrollView *sPtr)
 550 {
 551     float prop, value;
 552
 553     if (sPtr->flags.hasHScroller) {
 554         prop = (float)sPtr->viewport->size.width/sPtr->contentView->size.width;
 555         value = WMGetScrollerValue(sPtr->hScroller);
 556
 557         WMSetScrollerParameters(sPtr->hScroller, value, prop);
 558     }
 559     if (sPtr->flags.hasVScroller) {
 560         prop = (float)sPtr->viewport->size.height/sPtr->contentView->size.height;
 561
 562         value = WMGetScrollerValue(sPtr->vScroller);
 563
 564         WMSetScrollerParameters(sPtr->vScroller, value, prop);
 565     }
 566 }
 567
 568
 569 static void
 570 handleViewportEvents(XEvent *event, void *data)
 571 {
 572     ScrollView *sPtr = (ScrollView*)data;
 573
 574     if (sPtr->contentView
 575         && event->xconfigure.window == sPtr->contentView->window)
 576         updateScrollerProportion(sPtr);
 577 }
 578
 579
 580 static void
 581 handleEvents(XEvent *event, void *data)
 582 {
 583     ScrollView *sPtr = (ScrollView*)data;
 584
 585     CHECK_CLASS(data, WC_ScrollView);
 586
 587     switch (event->type) {
 588      case Expose:
 589         if (event->xexpose.count!=0)
 590             break;
 591         paintScrollView(sPtr);
 592         break;
 593
 594      case DestroyNotify:
 595         destroyScrollView(sPtr);
 596         break;
 597
 598     }
 599 }
 600
 601
 602 static void
 603 destroyScrollView(ScrollView *sPtr)
 604 {
 605     puts("destroyScrollView not implemented");
 606
 607     wfree(sPtr);
 608 }
 609